# File: matplotlib-main/ci/check_version_number.py
""""""
import sys
import matplotlib
print(f'Version {matplotlib.__version__} installed')
if matplotlib.__version__[0] == '0':
    sys.exit('Version incorrectly starts with 0')

# File: matplotlib-main/ci/check_wheel_licenses.py
""""""
from pathlib import Path
import sys
import zipfile
if len(sys.argv) <= 1:
    sys.exit('At least one wheel must be specified in command-line arguments.')
project_dir = Path(__file__).parent.resolve().parent
license_dir = project_dir / 'LICENSE'
license_file_names = {path.name for path in sorted(license_dir.glob('*'))}
for wheel in sys.argv[1:]:
    print(f'Checking LICENSE files in: {wheel}')
    with zipfile.ZipFile(wheel) as f:
        wheel_license_file_names = {Path(path).name for path in sorted(f.namelist()) if '.dist-info/LICENSE' in path}
        if not (len(wheel_license_file_names) and wheel_license_file_names.issuperset(license_file_names)):
            sys.exit(f'LICENSE file(s) missing:\n{wheel_license_file_names} !=\n{license_file_names}')

# File: matplotlib-main/ci/export_sdist_name.py
""""""
import os
from pathlib import Path
import sys
paths = [p.name for p in Path('dist').glob('*.tar.gz')]
if len(paths) != 1:
    sys.exit(f'Only a single sdist is supported, but found: {paths}')
print(paths[0])
with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
    f.write(f'SDIST_NAME={paths[0]}\n')

# File: matplotlib-main/ci/schemas/vendor_schemas.py
""""""
import os
import pathlib
import urllib.request
HERE = pathlib.Path(__file__).parent
SCHEMAS = ['https://json.schemastore.org/appveyor.json', 'https://json.schemastore.org/circleciconfig.json', 'https://json.schemastore.org/github-funding.json', 'https://json.schemastore.org/github-issue-config.json', 'https://json.schemastore.org/github-issue-forms.json', 'https://json.schemastore.org/codecov.json', 'https://json.schemastore.org/pull-request-labeler-5.json', 'https://github.com/microsoft/vscode-python/raw/main/schemas/conda-environment.json']

def print_progress(block_count, block_size, total_size):
    size = block_count * block_size
    if total_size != -1:
        size = min(size, total_size)
        width = 50
        percent = size / total_size * 100
        filled = int(percent // (100 // width))
        percent_str = '█' * filled + '░' * (width - filled)
    print(f'{percent_str} {size:6d} / {total_size:6d}', end='\r')
for json in HERE.glob('*.json'):
    os.remove(json)
for schema in SCHEMAS:
    path = HERE / schema.rsplit('/', 1)[-1]
    print(f'Downloading {schema} to {path}')
    urllib.request.urlretrieve(schema, filename=path, reporthook=print_progress)
    print()
    path.write_text(path.read_text())

# File: matplotlib-main/doc/_embedded_plots/axes_margins.py
import numpy as np
import matplotlib.pyplot as plt
(fig, ax) = plt.subplots(figsize=(6.5, 4))
x = np.linspace(0, 1, 33)
y = -np.sin(x * 2 * np.pi)
ax.plot(x, y, 'o')
ax.margins(0.5, 0.2)
ax.set_title('margins(x=0.5, y=0.2)')
ax.set(xlim=ax.get_xlim(), ylim=ax.get_ylim())

def arrow(p1, p2, **props):
    ax.annotate('', p1, p2, arrowprops=dict(arrowstyle='<->', shrinkA=0, shrinkB=0, **props))
(axmin, axmax) = ax.get_xlim()
(aymin, aymax) = ax.get_ylim()
(xmin, xmax) = (x.min(), x.max())
(ymin, ymax) = (y.min(), y.max())
y0 = -0.8
ax.axvspan(axmin, xmin, color=('orange', 0.1))
ax.axvspan(xmax, axmax, color=('orange', 0.1))
arrow((xmin, y0), (xmax, y0), color='sienna')
arrow((xmax, y0), (axmax, y0), color='orange')
ax.text((xmax + axmax) / 2, y0 + 0.05, 'x margin\n* x data range', ha='center', va='bottom', color='orange')
ax.text(0.55, y0 + 0.1, 'x data range', va='bottom', color='sienna')
x0 = 0.1
ax.axhspan(aymin, ymin, color=('tab:green', 0.1))
ax.axhspan(ymax, aymax, color=('tab:green', 0.1))
arrow((x0, ymin), (x0, ymax), color='darkgreen')
arrow((x0, ymax), (x0, aymax), color='tab:green')
ax.text(x0, (ymax + aymax) / 2, '  y margin * y data range', va='center', color='tab:green')
ax.text(x0, 0.5, '  y data range', color='darkgreen')

# File: matplotlib-main/doc/conf.py
from datetime import datetime, timezone
import logging
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys
import time
from urllib.parse import urlsplit, urlunsplit
import warnings
from packaging.version import parse as parse_version
import sphinx
import yaml
import matplotlib
print(f'Building Documentation for Matplotlib: {matplotlib.__version__}')
is_release_build = tags.has('release')
CIRCLECI = 'CIRCLECI' in os.environ
DEVDOCS = CIRCLECI and os.environ.get('CIRCLE_PROJECT_USERNAME') == 'matplotlib' and (os.environ.get('CIRCLE_BRANCH') == 'main') and (not os.environ.get('CIRCLE_PULL_REQUEST', '').startswith('https://github.com/matplotlib/matplotlib/pull'))

def _parse_skip_subdirs_file():
    default_skip_subdirs = ['users/prev_whats_new/*', 'users/explain/*', 'api/*', 'gallery/*', 'tutorials/*', 'plot_types/*', 'devel/*']
    try:
        with open('.mpl_skip_subdirs.yaml', 'r') as fin:
            print('Reading subdirectories to skip from', '.mpl_skip_subdirs.yaml')
            out = yaml.full_load(fin)
        return out['skip_subdirs']
    except FileNotFoundError:
        with open('.mpl_skip_subdirs.yaml', 'w') as fout:
            yamldict = {'skip_subdirs': default_skip_subdirs, 'comment': 'For use with make html-skip-subdirs'}
            yaml.dump(yamldict, fout)
        print('Skipping subdirectories, but .mpl_skip_subdirs.yaml', 'not found so creating a default one. Edit this file', 'to customize which directories are included in build.')
        return default_skip_subdirs
skip_subdirs = []
if 'skip_sub_dirs=1' in sys.argv:
    skip_subdirs = _parse_skip_subdirs_file()
sourceyear = datetime.fromtimestamp(int(os.environ.get('SOURCE_DATE_EPOCH', time.time())), timezone.utc).year
sys.path.append(os.path.abspath('.'))
sys.path.append('.')
warnings.filterwarnings('error', append=True)
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.autosummary', 'sphinx.ext.inheritance_diagram', 'sphinx.ext.intersphinx', 'sphinx.ext.ifconfig', 'IPython.sphinxext.ipython_console_highlighting', 'IPython.sphinxext.ipython_directive', 'numpydoc', 'sphinx_gallery.gen_gallery', 'matplotlib.sphinxext.mathmpl', 'matplotlib.sphinxext.plot_directive', 'matplotlib.sphinxext.roles', 'matplotlib.sphinxext.figmpl_directive', 'sphinxcontrib.inkscapeconverter', 'sphinxext.github', 'sphinxext.math_symbol_table', 'sphinxext.missing_references', 'sphinxext.mock_gui_toolkits', 'sphinxext.skip_deprecated', 'sphinxext.redirect_from', 'sphinx_copybutton', 'sphinx_design', 'sphinx_tags']
exclude_patterns = ['api/prev_api_changes/api_changes_*/*', '**/*inc.rst', 'users/explain/index.rst']
exclude_patterns += skip_subdirs

def _check_dependencies():
    names = {**{ext: ext.split('.')[0] for ext in extensions}, 'colorspacious': 'colorspacious', 'mpl_sphinx_theme': 'mpl_sphinx_theme', 'sphinxcontrib.inkscapeconverter': 'sphinxcontrib-svg2pdfconverter'}
    missing = []
    for name in names:
        try:
            __import__(name)
        except ImportError:
            missing.append(names[name])
    if missing:
        raise ImportError(f"The following dependencies are missing to build the documentation: {', '.join(missing)}")
    if 'mpl_sphinx_theme' not in missing:
        import pydata_sphinx_theme
        import mpl_sphinx_theme
        print(f'pydata sphinx theme: {pydata_sphinx_theme.__version__}')
        print(f'mpl sphinx theme: {mpl_sphinx_theme.__version__}')
    if shutil.which('dot') is None:
        raise OSError('No binary named dot - graphviz must be installed to build the documentation')
    if shutil.which('latex') is None:
        raise OSError('No binary named latex - a LaTeX distribution must be installed to build the documentation')
_check_dependencies()
import sphinx_gallery
if parse_version(sphinx_gallery.__version__) >= parse_version('0.16.0'):
    gallery_order_sectionorder = 'sphinxext.gallery_order.sectionorder'
    gallery_order_subsectionorder = 'sphinxext.gallery_order.subsectionorder'
    clear_basic_units = 'sphinxext.util.clear_basic_units'
    matplotlib_reduced_latex_scraper = 'sphinxext.util.matplotlib_reduced_latex_scraper'
else:
    from sphinxext.gallery_order import sectionorder as gallery_order_sectionorder, subsectionorder as gallery_order_subsectionorder
    from sphinxext.util import clear_basic_units, matplotlib_reduced_latex_scraper
if parse_version(sphinx_gallery.__version__) >= parse_version('0.17.0'):
    sg_matplotlib_animations = (True, 'mp4')
else:
    sg_matplotlib_animations = True
from sphinx_gallery import gen_rst
warnings.filterwarnings('ignore', category=UserWarning, message='(\\n|.)*is non-interactive, and thus cannot be shown')

def tutorials_download_error(record):
    if re.match('download file not readable: .*tutorials_(python|jupyter).zip', record.msg):
        return False
logger = logging.getLogger('sphinx')
logger.addFilter(tutorials_download_error)
autosummary_generate = True
autodoc_typehints = 'none'
warnings.filterwarnings('ignore', category=DeprecationWarning, module='importlib', message='(\\n|.)*module was deprecated.*')
autodoc_docstring_signature = True
autodoc_default_options = {'members': None, 'undoc-members': None}
warnings.filterwarnings('ignore', category=DeprecationWarning, module='sphinx.util.inspect')
nitpicky = True
missing_references_write_json = False
missing_references_warn_unused_ignores = False
intersphinx_mapping = {'Pillow': ('https://pillow.readthedocs.io/en/stable/', None), 'cycler': ('https://matplotlib.org/cycler/', None), 'dateutil': ('https://dateutil.readthedocs.io/en/stable/', None), 'ipykernel': ('https://ipykernel.readthedocs.io/en/latest/', None), 'numpy': ('https://numpy.org/doc/stable/', None), 'pandas': ('https://pandas.pydata.org/pandas-docs/stable/', None), 'pytest': ('https://pytest.org/en/stable/', None), 'python': ('https://docs.python.org/3/', None), 'scipy': ('https://docs.scipy.org/doc/scipy/', None), 'tornado': ('https://www.tornadoweb.org/en/stable/', None), 'xarray': ('https://docs.xarray.dev/en/stable/', None), 'meson-python': ('https://meson-python.readthedocs.io/en/stable/', None), 'pip': ('https://pip.pypa.io/en/stable/', None)}
gallery_dirs = [f'{ed}' for ed in ['gallery', 'tutorials', 'plot_types', 'users/explain'] if f'{ed}/*' not in skip_subdirs]
example_dirs = []
for gd in gallery_dirs:
    gd = gd.replace('gallery', 'examples').replace('users/explain', 'users_explain')
    example_dirs += [f'../galleries/{gd}']
sphinx_gallery_conf = {'backreferences_dir': Path('api', '_as_gen'), 'compress_images': ('thumbnails', 'images') if is_release_build else (), 'doc_module': ('matplotlib', 'mpl_toolkits'), 'examples_dirs': example_dirs, 'filename_pattern': '^((?!sgskip).)*$', 'gallery_dirs': gallery_dirs, 'image_scrapers': (matplotlib_reduced_latex_scraper,), 'image_srcset': ['2x'], 'junit': '../test-results/sphinx-gallery/junit.xml' if CIRCLECI else '', 'matplotlib_animations': sg_matplotlib_animations, 'min_reported_time': 1, 'plot_gallery': 'True', 'reference_url': {'matplotlib': None, 'mpl_toolkits': None}, 'prefer_full_module': {'mpl_toolkits\\.'}, 'remove_config_comments': True, 'reset_modules': ('matplotlib', clear_basic_units), 'subsection_order': gallery_order_sectionorder, 'thumbnail_size': (320, 224), 'within_subsection_order': gallery_order_subsectionorder, 'capture_repr': (), 'copyfile_regex': '.*\\.rst'}
if parse_version(sphinx_gallery.__version__) >= parse_version('0.17.0'):
    sphinx_gallery_conf['parallel'] = True
    warnings.filterwarnings('default', category=UserWarning, module='joblib')
if 'plot_gallery=0' in sys.argv:

    def gallery_image_warning_filter(record):
        msg = record.msg
        for pattern in sphinx_gallery_conf['gallery_dirs'] + ['_static/constrained_layout']:
            if msg.startswith(f'image file not readable: {pattern}'):
                return False
        if msg == 'Could not obtain image size. :scale: option is ignored.':
            return False
        return True
    logger = logging.getLogger('sphinx')
    logger.addFilter(gallery_image_warning_filter)
tags_create_tags = True
tags_page_title = 'All tags'
tags_create_badges = True
tags_badge_colors = {'animation': 'primary', 'component:*': 'secondary', 'event-handling': 'success', 'interactivity:*': 'dark', 'plot-type:*': 'danger', '*': 'light'}
mathmpl_fontsize = 11.0
mathmpl_srcset = ['2x']
gen_rst.EXAMPLE_HEADER = '\n.. DO NOT EDIT.\n.. THIS FILE WAS AUTOMATICALLY GENERATED BY SPHINX-GALLERY.\n.. TO MAKE CHANGES, EDIT THE SOURCE PYTHON FILE:\n.. "{0}"\n.. LINE NUMBERS ARE GIVEN BELOW.\n\n.. only:: html\n\n    .. meta::\n        :keywords: codex\n\n    .. note::\n        :class: sphx-glr-download-link-note\n\n        :ref:`Go to the end <sphx_glr_download_{1}>`\n        to download the full example code.{2}\n\n.. rst-class:: sphx-glr-example-title\n\n.. _sphx_glr_{1}:\n\n'
templates_path = ['_templates']
source_suffix = '.rst'
source_encoding = 'utf-8'
root_doc = 'index'
try:
    SHA = subprocess.check_output(['git', 'describe', '--dirty']).decode('utf-8').strip()
except (subprocess.CalledProcessError, FileNotFoundError):
    SHA = matplotlib.__version__
html_context = {'doc_version': SHA}
project = 'Matplotlib'
copyright = f'2002–2012 John Hunter, Darren Dale, Eric Firing, Michael Droettboom and the Matplotlib development team; 2012–{sourceyear} The Matplotlib development team'
version = matplotlib.__version__
release = version
today_fmt = '%B %d, %Y'
unused_docs = []
pygments_style = 'sphinx'
default_role = 'obj'
formats = {'html': ('png', 100), 'latex': ('pdf', 100)}
plot_formats = [formats[target] for target in ['html', 'latex'] if target in sys.argv] or list(formats.values())
plot_srcset = ['2x']
github_project_url = 'https://github.com/matplotlib/matplotlib/'

def add_html_cache_busting(app, pagename, templatename, context, doctree):
    from sphinx.builders.html import Stylesheet, JavaScript
    css_tag = context['css_tag']
    js_tag = context['js_tag']

    def css_tag_with_cache_busting(css):
        if isinstance(css, Stylesheet) and css.filename is not None:
            url = urlsplit(css.filename)
            if not url.netloc and (not url.query):
                url = url._replace(query=SHA)
                css = Stylesheet(urlunsplit(url), priority=css.priority, **css.attributes)
        return css_tag(css)

    def js_tag_with_cache_busting(js):
        if isinstance(js, JavaScript) and js.filename is not None:
            url = urlsplit(js.filename)
            if not url.netloc and (not url.query):
                url = url._replace(query=SHA)
                js = JavaScript(urlunsplit(url), priority=js.priority, **js.attributes)
        return js_tag(js)
    context['css_tag'] = css_tag_with_cache_busting
    context['js_tag'] = js_tag_with_cache_busting
html_css_files = ['mpl.css']
html_theme = 'mpl_sphinx_theme'
html_theme_options = {'navbar_links': 'internal', 'collapse_navigation': not is_release_build, 'show_prev_next': False, 'switcher': {'json_url': f"https://output.circle-artifacts.com/output/job/{os.environ['CIRCLE_WORKFLOW_JOB_ID']}/artifacts/{os.environ['CIRCLE_NODE_INDEX']}/doc/build/html/_static/switcher.json" if CIRCLECI and (not DEVDOCS) else f'https://matplotlib.org/devdocs/_static/switcher.json?{SHA}', 'version_match': matplotlib.__version__ if matplotlib.__version_info__.releaselevel == 'final' else 'dev'}, 'navbar_end': ['theme-switcher', 'version-switcher', 'mpl_icon_links'], 'navbar_persistent': ['search-button'], 'footer_start': ['copyright', 'sphinx-version', 'doc_version'], 'announcement': 'unreleased' if not is_release_build else '', 'show_version_warning_banner': True}
include_analytics = is_release_build
if include_analytics:
    html_theme_options['analytics'] = {'plausible_analytics_domain': 'matplotlib.org', 'plausible_analytics_url': 'https://views.scientific-python.org/js/script.js'}
html_static_path = ['_static']
html_file_suffix = '.html'
html_baseurl = 'https://matplotlib.org/stable/'
html_last_updated_fmt = '%b %d, %Y'
html_index = 'index.html'
html_sidebars = {'index': ['cheatsheet_sidebar.html', 'donate_sidebar.html'], 'users/release_notes': ['empty_sidebar.html']}
html_show_sourcelink = False
copybutton_prompt_text = '>>> |\\.\\.\\. '
copybutton_prompt_is_regexp = True
html_use_index = False
html_domain_index = False
html_use_opensearch = 'https://matplotlib.org/stable'
htmlhelp_basename = 'Matplotlibdoc'
smartquotes = False
html_favicon = '_static/favicon.ico'
latex_paper_size = 'letter'
latex_documents = [(root_doc, 'Matplotlib.tex', 'Matplotlib', 'John Hunter\\and Darren Dale\\and Eric Firing\\and Michael Droettboom\\and and the matplotlib development team', 'manual')]
latex_logo = None
latex_engine = 'xelatex'
latex_elements = {}
latex_elements['babel'] = '\\usepackage{babel}'
latex_elements['fontenc'] = '\n\\usepackage{fontspec}\n\\defaultfontfeatures[\\rmfamily,\\sffamily,\\ttfamily]{}\n'
latex_elements['fontpkg'] = '\n\\IfFontExistsTF{XITS}{\n \\setmainfont{XITS}\n}{\n \\setmainfont{XITS}[\n  Extension      = .otf,\n  UprightFont    = *-Regular,\n  ItalicFont     = *-Italic,\n  BoldFont       = *-Bold,\n  BoldItalicFont = *-BoldItalic,\n]}\n\\IfFontExistsTF{FreeSans}{\n \\setsansfont{FreeSans}\n}{\n \\setsansfont{FreeSans}[\n  Extension      = .otf,\n  UprightFont    = *,\n  ItalicFont     = *Oblique,\n  BoldFont       = *Bold,\n  BoldItalicFont = *BoldOblique,\n]}\n\\IfFontExistsTF{FreeMono}{\n \\setmonofont{FreeMono}\n}{\n \\setmonofont{FreeMono}[\n  Extension      = .otf,\n  UprightFont    = *,\n  ItalicFont     = *Oblique,\n  BoldFont       = *Bold,\n  BoldItalicFont = *BoldOblique,\n]}\n% needed for \\mathbb (blackboard alphabet) to actually work\n\\usepackage{unicode-math}\n\\IfFontExistsTF{XITS Math}{\n \\setmathfont{XITS Math}\n}{\n \\setmathfont{XITSMath-Regular}[\n  Extension      = .otf,\n]}\n'
latex_elements['passoptionstopackages'] = '\n    \\PassOptionsToPackage{headheight=14pt}{geometry}\n'
latex_elements['preamble'] = "\n   % Show Parts and Chapters in Table of Contents\n   \\setcounter{tocdepth}{0}\n   % One line per author on title page\n   \\DeclareRobustCommand{\\and}%\n     {\\end{tabular}\\kern-\\tabcolsep\\\\\\begin{tabular}[t]{c}}%\n   \\usepackage{etoolbox}\n   \\AtBeginEnvironment{sphinxthebibliography}{\\appendix\\part{Appendices}}\n   \\usepackage{expdlist}\n   \\let\\latexdescription=\\description\n   \\def\\description{\\latexdescription{}{} \\breaklabel}\n   % But expdlist old LaTeX package requires fixes:\n   % 1) remove extra space\n   \\makeatletter\n   \\patchcmd\\@item{{\\@breaklabel} }{{\\@breaklabel}}{}{}\n   \\makeatother\n   % 2) fix bug in expdlist's way of breaking the line after long item label\n   \\makeatletter\n   \\def\\breaklabel{%\n       \\def\\@breaklabel{%\n           \\leavevmode\\par\n           % now a hack because Sphinx inserts \\leavevmode after term node\n           \\def\\leavevmode{\\def\\leavevmode{\\unhbox\\voidb@x}}%\n      }%\n   }\n   \\makeatother\n"
latex_elements['maxlistdepth'] = '10'
latex_elements['pointsize'] = '11pt'
latex_elements['printindex'] = '\\footnotesize\\raggedright\\printindex'
latex_appendices = []
latex_use_modindex = True
latex_toplevel_sectioning = 'part'
autoclass_content = 'both'
texinfo_documents = [(root_doc, 'matplotlib', 'Matplotlib Documentation', 'John Hunter@*Darren Dale@*Eric Firing@*Michael Droettboom@*The matplotlib development team', 'Matplotlib', 'Python plotting package', 'Programming', 1)]
numpydoc_show_class_members = False
inheritance_graph_attrs = dict(size='1000.0', splines='polyline')
inheritance_node_attrs = dict(height=0.02, margin=0.055, penwidth=1, width=0.01)
inheritance_edge_attrs = dict(penwidth=1)
graphviz_dot = shutil.which('dot')
graphviz_output_format = 'svg'
link_github = True
if link_github:
    import inspect
    extensions.append('sphinx.ext.linkcode')

    def linkcode_resolve(domain, info):
        if domain != 'py':
            return None
        modname = info['module']
        fullname = info['fullname']
        submod = sys.modules.get(modname)
        if submod is None:
            return None
        obj = submod
        for part in fullname.split('.'):
            try:
                obj = getattr(obj, part)
            except AttributeError:
                return None
        if inspect.isfunction(obj):
            obj = inspect.unwrap(obj)
        try:
            fn = inspect.getsourcefile(obj)
        except TypeError:
            fn = None
        if not fn or fn.endswith('__init__.py'):
            try:
                fn = inspect.getsourcefile(sys.modules[obj.__module__])
            except (TypeError, AttributeError, KeyError):
                fn = None
        if not fn:
            return None
        try:
            (source, lineno) = inspect.getsourcelines(obj)
        except (OSError, TypeError):
            lineno = None
        linespec = f'#L{lineno:d}-L{lineno + len(source) - 1:d}' if lineno else ''
        startdir = Path(matplotlib.__file__).parent.parent
        try:
            fn = os.path.relpath(fn, start=startdir).replace(os.path.sep, '/')
        except ValueError:
            return None
        if not fn.startswith(('matplotlib/', 'mpl_toolkits/')):
            return None
        version = parse_version(matplotlib.__version__)
        tag = 'main' if version.is_devrelease else f'v{version.public}'
        return f'https://github.com/matplotlib/matplotlib/blob/{tag}/lib/{fn}{linespec}'
else:
    extensions.append('sphinx.ext.viewcode')

def setup(app):
    if any((st in version for st in ('post', 'dev', 'alpha', 'beta'))):
        bld_type = 'dev'
    else:
        bld_type = 'rel'
    app.add_config_value('skip_sub_dirs', 0, '')
    app.add_config_value('releaselevel', bld_type, 'env')
    if sphinx.version_info[:2] < (7, 1):
        app.connect('html-page-context', add_html_cache_busting, priority=1000)

# File: matplotlib-main/doc/sphinxext/gallery_order.py
""""""
from sphinx_gallery.sorting import ExplicitOrder
UNSORTED = 'unsorted'
examples_order = ['../galleries/examples/lines_bars_and_markers', '../galleries/examples/images_contours_and_fields', '../galleries/examples/subplots_axes_and_figures', '../galleries/examples/statistics', '../galleries/examples/pie_and_polar_charts', '../galleries/examples/text_labels_and_annotations', '../galleries/examples/color', '../galleries/examples/shapes_and_collections', '../galleries/examples/style_sheets', '../galleries/examples/pyplots', '../galleries/examples/axes_grid1', '../galleries/examples/axisartist', '../galleries/examples/showcase', UNSORTED, '../galleries/examples/userdemo']
tutorials_order = ['../galleries/tutorials/introductory', '../galleries/tutorials/intermediate', '../galleries/tutorials/advanced', UNSORTED, '../galleries/tutorials/provisional']
plot_types_order = ['../galleries/plot_types/basic', '../galleries/plot_types/stats', '../galleries/plot_types/arrays', '../galleries/plot_types/unstructured', '../galleries/plot_types/3D', UNSORTED]
folder_lists = [examples_order, tutorials_order, plot_types_order]
explicit_order_folders = [fd for folders in folder_lists for fd in folders[:folders.index(UNSORTED)]]
explicit_order_folders.append(UNSORTED)
explicit_order_folders.extend([fd for folders in folder_lists for fd in folders[folders.index(UNSORTED):]])

class MplExplicitOrder(ExplicitOrder):

    def __call__(self, item):
        if item in self.ordered_list:
            return f'{self.ordered_list.index(item):04d}'
        else:
            return f'{self.ordered_list.index(UNSORTED):04d}{item}'
list_all = ['quick_start', 'pyplot', 'images', 'lifecycle', 'customizing', 'artists', 'legend_guide', 'color_cycle', 'constrainedlayout_guide', 'tight_layout_guide', 'text_intro', 'text_props', 'colors', 'color_demo', 'pie_features', 'pie_demo2', 'plot', 'scatter_plot', 'bar', 'stem', 'step', 'fill_between', 'imshow', 'pcolormesh', 'contour', 'contourf', 'barbs', 'quiver', 'streamplot', 'hist_plot', 'boxplot_plot', 'errorbar_plot', 'violin', 'eventplot', 'hist2d', 'hexbin', 'pie', 'tricontour', 'tricontourf', 'tripcolor', 'triplot', 'spines', 'spine_placement_demo', 'spines_dropped', 'multiple_yaxis_with_spines', 'centered_spines_with_arrows']
explicit_subsection_order = [item + '.py' for item in list_all]

class MplExplicitSubOrder(ExplicitOrder):

    def __init__(self, src_dir):
        self.src_dir = src_dir
        self.ordered_list = explicit_subsection_order

    def __call__(self, item):
        if item in self.ordered_list:
            return f'{self.ordered_list.index(item):04d}'
        else:
            return 'zzz' + item
sectionorder = MplExplicitOrder(explicit_order_folders)
subsectionorder = MplExplicitSubOrder

# File: matplotlib-main/doc/sphinxext/github.py
""""""
from docutils import nodes, utils
from docutils.parsers.rst.roles import set_classes

def make_link_node(rawtext, app, type, slug, options):
    try:
        base = app.config.github_project_url
        if not base:
            raise AttributeError
        if not base.endswith('/'):
            base += '/'
    except AttributeError as err:
        raise ValueError(f'github_project_url configuration value is not set ({err})') from err
    ref = base + type + '/' + slug + '/'
    set_classes(options)
    prefix = '#'
    if type == 'pull':
        prefix = 'PR ' + prefix
    node = nodes.reference(rawtext, prefix + utils.unescape(slug), refuri=ref, **options)
    return node

def ghissue_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
    try:
        issue_num = int(text)
        if issue_num <= 0:
            raise ValueError
    except ValueError:
        msg = inliner.reporter.error('GitHub issue number must be a number greater than or equal to 1; "%s" is invalid.' % text, line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return ([prb], [msg])
    app = inliner.document.settings.env.app
    if 'pull' in name.lower():
        category = 'pull'
    elif 'issue' in name.lower():
        category = 'issues'
    else:
        msg = inliner.reporter.error('GitHub roles include "ghpull" and "ghissue", "%s" is invalid.' % name, line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return ([prb], [msg])
    node = make_link_node(rawtext, app, category, str(issue_num), options)
    return ([node], [])

def ghuser_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
    ref = 'https://www.github.com/' + text
    node = nodes.reference(rawtext, text, refuri=ref, **options)
    return ([node], [])

def ghcommit_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
    app = inliner.document.settings.env.app
    try:
        base = app.config.github_project_url
        if not base:
            raise AttributeError
        if not base.endswith('/'):
            base += '/'
    except AttributeError as err:
        raise ValueError(f'github_project_url configuration value is not set ({err})') from err
    ref = base + text
    node = nodes.reference(rawtext, text[:6], refuri=ref, **options)
    return ([node], [])

def setup(app):
    app.add_role('ghissue', ghissue_role)
    app.add_role('ghpull', ghissue_role)
    app.add_role('ghuser', ghuser_role)
    app.add_role('ghcommit', ghcommit_role)
    app.add_config_value('github_project_url', None, 'env')
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
    return metadata

# File: matplotlib-main/doc/sphinxext/math_symbol_table.py
import re
from docutils.parsers.rst import Directive
from matplotlib import _mathtext, _mathtext_data
bb_pattern = re.compile('Bbb[A-Z]')
scr_pattern = re.compile('scr[a-zA-Z]')
frak_pattern = re.compile('frak[A-Z]')
symbols = [['Lower-case Greek', 4, ('\\alpha', '\\beta', '\\gamma', '\\chi', '\\delta', '\\epsilon', '\\eta', '\\iota', '\\kappa', '\\lambda', '\\mu', '\\nu', '\\omega', '\\phi', '\\pi', '\\psi', '\\rho', '\\sigma', '\\tau', '\\theta', '\\upsilon', '\\xi', '\\zeta', '\\digamma', '\\varepsilon', '\\varkappa', '\\varphi', '\\varpi', '\\varrho', '\\varsigma', '\\vartheta')], ['Upper-case Greek', 4, ('\\Delta', '\\Gamma', '\\Lambda', '\\Omega', '\\Phi', '\\Pi', '\\Psi', '\\Sigma', '\\Theta', '\\Upsilon', '\\Xi')], ['Hebrew', 6, ('\\aleph', '\\beth', '\\gimel', '\\daleth')], ['Latin named characters', 6, '\\aa \\AA \\ae \\AE \\oe \\OE \\O \\o \\thorn \\Thorn \\ss \\eth \\dh \\DH'.split()], ['Delimiters', 5, _mathtext.Parser._delims], ['Big symbols', 5, _mathtext.Parser._overunder_symbols | _mathtext.Parser._dropsub_symbols], ['Standard function names', 5, {f'\\{fn}' for fn in _mathtext.Parser._function_names}], ['Binary operation symbols', 4, _mathtext.Parser._binary_operators], ['Relation symbols', 4, _mathtext.Parser._relation_symbols], ['Arrow symbols', 4, _mathtext.Parser._arrow_symbols], ['Dot symbols', 4, '\\cdots \\vdots \\ldots \\ddots \\adots \\Colon \\therefore \\because'.split()], ['Black-board characters', 6, [f'\\{symbol}' for symbol in _mathtext_data.tex2uni if re.match(bb_pattern, symbol)]], ['Script characters', 6, [f'\\{symbol}' for symbol in _mathtext_data.tex2uni if re.match(scr_pattern, symbol)]], ['Fraktur characters', 6, [f'\\{symbol}' for symbol in _mathtext_data.tex2uni if re.match(frak_pattern, symbol)]], ['Miscellaneous symbols', 4, '\\neg \\infty \\forall \\wp \\exists \\bigstar \\angle \\partial\n     \\nexists \\measuredangle \\emptyset \\sphericalangle \\clubsuit\n     \\varnothing \\complement \\diamondsuit \\imath \\Finv \\triangledown\n     \\heartsuit \\jmath \\Game \\spadesuit \\ell \\hbar \\vartriangle\n     \\hslash \\blacksquare \\blacktriangle \\sharp \\increment\n     \\prime \\blacktriangledown \\Im \\flat \\backprime \\Re \\natural\n     \\circledS \\P \\copyright \\circledR \\S \\yen \\checkmark \\$\n     \\cent \\triangle \\QED \\sinewave \\dag \\ddag \\perthousand \\ac\n     \\lambdabar \\L \\l \\degree \\danger \\maltese \\clubsuitopen\n     \\i \\hermitmatrix \\sterling \\nabla \\mho'.split()]]

def run(state_machine):

    def render_symbol(sym, ignore_variant=False):
        if ignore_variant and sym not in ('\\varnothing', '\\varlrtriangle'):
            sym = sym.replace('\\var', '\\')
        if sym.startswith('\\'):
            sym = sym.lstrip('\\')
            if sym not in _mathtext.Parser._overunder_functions | _mathtext.Parser._function_names:
                sym = chr(_mathtext_data.tex2uni[sym])
        return f'\\{sym}' if sym in ('\\', '|', '+', '-', '*') else sym
    lines = []
    for (category, columns, syms) in symbols:
        syms = sorted(syms, key=lambda sym: (render_symbol(sym, ignore_variant=True), sym.startswith('\\var')), reverse=category == 'Hebrew')
        rendered_syms = [f'{render_symbol(sym)} ``{sym}``' for sym in syms]
        columns = min(columns, len(syms))
        lines.append('**%s**' % category)
        lines.append('')
        max_width = max(map(len, rendered_syms))
        header = ('=' * max_width + ' ') * columns
        lines.append(header.rstrip())
        for part in range(0, len(rendered_syms), columns):
            row = ' '.join((sym.rjust(max_width) for sym in rendered_syms[part:part + columns]))
            lines.append(row)
        lines.append(header.rstrip())
        lines.append('')
    state_machine.insert_input(lines, 'Symbol table')
    return []

class MathSymbolTableDirective(Directive):
    has_content = False
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {}

    def run(self):
        return run(self.state_machine)

def setup(app):
    app.add_directive('math_symbol_table', MathSymbolTableDirective)
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
    return metadata
if __name__ == '__main__':
    print('SYMBOLS NOT IN STIX:')
    all_symbols = {}
    for (category, columns, syms) in symbols:
        if category == 'Standard Function Names':
            continue
        for sym in syms:
            if len(sym) > 1:
                all_symbols[sym[1:]] = None
                if sym[1:] not in _mathtext_data.tex2uni:
                    print(sym)
    all_symbols.update({v[1:]: k for (k, v) in _mathtext.Parser._accent_map.items()})
    all_symbols.update({v: v for v in _mathtext.Parser._wide_accents})
    print('SYMBOLS NOT IN TABLE:')
    for (sym, val) in _mathtext_data.tex2uni.items():
        if sym not in all_symbols:
            print(f'{sym} = {chr(val)}')

# File: matplotlib-main/doc/sphinxext/missing_references.py
""""""
from collections import defaultdict
import json
from pathlib import Path
from docutils.utils import get_source_line
from sphinx.util import logging as sphinx_logging
import matplotlib
logger = sphinx_logging.getLogger(__name__)

def get_location(node, app):
    (source, line) = get_source_line(node)
    if source:
        if ':docstring of' in source:
            (path, *post) = source.rpartition(':docstring of')
            post = ''.join(post)
        else:
            path = source
            post = ''
        basepath = Path(app.srcdir).parent.resolve()
        fullpath = Path(path).resolve()
        try:
            path = fullpath.relative_to(basepath)
        except ValueError:
            path = Path('<external>') / fullpath.name
        path = path.as_posix()
    else:
        path = '<unknown>'
        post = ''
    if not line:
        line = ''
    return f'{path}{post}:{line}'

def _truncate_location(location):
    return location.split(':', 1)[0]

def handle_missing_reference(app, domain, node):
    refdomain = node['refdomain']
    reftype = node['reftype']
    target = node['reftarget']
    location = get_location(node, app)
    domain_type = f'{refdomain}:{reftype}'
    app.env.missing_references_events[domain_type, target].add(location)
    if location in app.env.missing_references_ignored_references.get((domain_type, target), []):
        return True

def warn_unused_missing_references(app, exc):
    basepath = Path(matplotlib.__file__).parent.parent.parent.resolve()
    srcpath = Path(app.srcdir).parent.resolve()
    if basepath != srcpath:
        return
    references_ignored = app.env.missing_references_ignored_references
    references_events = app.env.missing_references_events
    for ((domain_type, target), locations) in references_ignored.items():
        missing_reference_locations = [_truncate_location(location) for location in references_events.get((domain_type, target), [])]
        for ignored_reference_location in locations:
            short_location = _truncate_location(ignored_reference_location)
            if short_location not in missing_reference_locations:
                msg = f'Reference {domain_type} {target} for {ignored_reference_location} can be removed from {app.config.missing_references_filename}. It is no longer a missing reference in the docs.'
                logger.warning(msg, location=ignored_reference_location, type='ref', subtype=domain_type)

def save_missing_references(app, exc):
    json_path = Path(app.confdir) / app.config.missing_references_filename
    references_warnings = app.env.missing_references_events
    _write_missing_references_json(references_warnings, json_path)

def _write_missing_references_json(records, json_path):
    transformed_records = defaultdict(dict)
    for ((domain_type, target), paths) in records.items():
        transformed_records[domain_type][target] = sorted(paths)
    with json_path.open('w') as stream:
        json.dump(transformed_records, stream, sort_keys=True, indent=2)
        stream.write('\n')

def _read_missing_references_json(json_path):
    with json_path.open('r') as stream:
        data = json.load(stream)
    ignored_references = {}
    for (domain_type, targets) in data.items():
        for (target, locations) in targets.items():
            ignored_references[domain_type, target] = locations
    return ignored_references

def prepare_missing_references_setup(app):
    if not app.config.missing_references_enabled:
        return
    app.connect('warn-missing-reference', handle_missing_reference)
    if app.config.missing_references_warn_unused_ignores:
        app.connect('build-finished', warn_unused_missing_references)
    if app.config.missing_references_write_json:
        app.connect('build-finished', save_missing_references)
    json_path = Path(app.confdir) / app.config.missing_references_filename
    app.env.missing_references_ignored_references = _read_missing_references_json(json_path) if json_path.exists() else {}
    app.env.missing_references_events = defaultdict(set)

def setup(app):
    app.add_config_value('missing_references_enabled', True, 'env')
    app.add_config_value('missing_references_write_json', False, 'env')
    app.add_config_value('missing_references_warn_unused_ignores', True, 'env')
    app.add_config_value('missing_references_filename', 'missing-references.json', 'env')
    app.connect('builder-inited', prepare_missing_references_setup)
    return {'parallel_read_safe': True}

# File: matplotlib-main/doc/sphinxext/redirect_from.py
""""""
from pathlib import Path
from sphinx.util.docutils import SphinxDirective
from sphinx.domains import Domain
from sphinx.util import logging
logger = logging.getLogger(__name__)
HTML_TEMPLATE = '<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset="utf-8">\n    <meta http-equiv="refresh" content="0; url={v}">\n  </head>\n</html>\n'

def setup(app):
    app.add_directive('redirect-from', RedirectFrom)
    app.add_domain(RedirectFromDomain)
    app.connect('builder-inited', _clear_redirects)
    app.connect('build-finished', _generate_redirects)
    metadata = {'parallel_read_safe': True}
    return metadata

class RedirectFromDomain(Domain):
    name = 'redirect_from'
    label = 'redirect_from'

    @property
    def redirects(self):
        return self.data.setdefault('redirects', {})

    def clear_doc(self, docname):
        self.redirects.pop(docname, None)

    def merge_domaindata(self, docnames, otherdata):
        for (src, dst) in otherdata['redirects'].items():
            if src not in self.redirects:
                self.redirects[src] = dst
            elif self.redirects[src] != dst:
                raise ValueError(f"Inconsistent redirections from {src} to {self.redirects[src]} and {otherdata['redirects'][src]}")

class RedirectFrom(SphinxDirective):
    required_arguments = 1

    def run(self):
        (redirected_doc,) = self.arguments
        domain = self.env.get_domain('redirect_from')
        current_doc = self.env.path2doc(self.state.document.current_source)
        (redirected_reldoc, _) = self.env.relfn2path(redirected_doc, current_doc)
        if redirected_reldoc in domain.redirects:
            raise ValueError(f'{redirected_reldoc} is already noted as redirecting to {domain.redirects[redirected_reldoc]}')
        domain.redirects[redirected_reldoc] = current_doc
        return []

def _generate_redirects(app, exception):
    builder = app.builder
    if builder.name != 'html' or exception:
        return
    for (k, v) in app.env.get_domain('redirect_from').redirects.items():
        p = Path(app.outdir, k + builder.out_suffix)
        html = HTML_TEMPLATE.format(v=builder.get_relative_uri(k, v))
        if p.is_file():
            if p.read_text() != html:
                logger.warning('A redirect-from directive is trying to create %s, but that file already exists (perhaps you need to run "make clean")', p)
        else:
            logger.info('making refresh html file: %s redirect to %s', k, v)
            p.parent.mkdir(parents=True, exist_ok=True)
            p.write_text(html, encoding='utf-8')

def _clear_redirects(app):
    domain = app.env.get_domain('redirect_from')
    if domain.redirects:
        logger.info('clearing cached redirects')
        domain.redirects.clear()

# File: matplotlib-main/doc/sphinxext/skip_deprecated.py
def skip_deprecated(app, what, name, obj, skip, options):
    if skip:
        return skip
    skipped = {'matplotlib.colors': ['ColorConverter', 'hex2color', 'rgb2hex']}
    skip_list = skipped.get(getattr(obj, '__module__', None))
    if skip_list is not None:
        return getattr(obj, '__name__', None) in skip_list

def setup(app):
    app.connect('autodoc-skip-member', skip_deprecated)
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
    return metadata

# File: matplotlib-main/doc/sphinxext/util.py
import sys

def matplotlib_reduced_latex_scraper(block, block_vars, gallery_conf, **kwargs):
    from sphinx_gallery.scrapers import matplotlib_scraper
    if gallery_conf['builder_name'] == 'latex':
        gallery_conf['image_srcset'] = []
    return matplotlib_scraper(block, block_vars, gallery_conf, **kwargs)

def clear_basic_units(gallery_conf, fname):
    return sys.modules.pop('basic_units', None)

# File: matplotlib-main/doc/users/generate_credits.py
from collections import Counter
import locale
import re
import subprocess
TEMPLATE = ".. Note: This file is auto-generated using generate_credits.py\n\n.. _credits:\n\n*******\nCredits\n*******\n\n\nMatplotlib was written by John D. Hunter, with contributions from an\never-increasing number of users and developers.  The current lead developer is\nThomas A. Caswell, who is assisted by many `active developers\n<https://www.openhub.net/p/matplotlib/contributors>`_.\nPlease also see our instructions on :doc:`/citing`.\n\nThe following is a list of contributors extracted from the\ngit revision control history of the project:\n\n{contributors}\n\nSome earlier contributors not included above are (with apologies\nto any we have missed):\n\nCharles Twardy,\nGary Ruben,\nJohn Gill,\nDavid Moore,\nPaul Barrett,\nJared Wahlstrand,\nJim Benson,\nPaul Mcguire,\nAndrew Dalke,\nNadia Dencheva,\nBaptiste Carvello,\nSigve Tjoraand,\nTed Drain,\nJames Amundson,\nDaishi Harada,\nNicolas Young,\nPaul Kienzle,\nJohn Porter,\nand Jonathon Taylor.\n\nThanks to Tony Yu for the original logo design.\n\nWe also thank all who have reported bugs, commented on\nproposed changes, or otherwise contributed to Matplotlib's\ndevelopment and usefulness.\n"

def check_duplicates():
    text = subprocess.check_output(['git', 'shortlog', '--summary', '--email'])
    lines = text.decode('utf8').split('\n')
    contributors = [line.split('\t', 1)[1].strip() for line in lines if line]
    emails = [re.match('.*<(.*)>', line).group(1) for line in contributors]
    email_counter = Counter(emails)
    if email_counter.most_common(1)[0][1] > 1:
        print('DUPLICATE CHECK: The following email addresses are used with more than one name.\nConsider adding them to .mailmap.\n')
        for (email, count) in email_counter.items():
            if count > 1:
                print('{}\n{}'.format(email, '\n'.join((l for l in lines if email in l))))

def generate_credits():
    text = subprocess.check_output(['git', 'shortlog', '--summary'])
    lines = text.decode('utf8').split('\n')
    contributors = [line.split('\t', 1)[1].strip() for line in lines if line]
    contributors.sort(key=locale.strxfrm)
    with open('credits.rst', 'w') as f:
        f.write(TEMPLATE.format(contributors=',\n'.join(contributors)))
if __name__ == '__main__':
    check_duplicates()
    generate_credits()

# File: matplotlib-main/galleries/plot_types/3D/bar3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
x = [1, 1, 2, 2]
y = [1, 2, 1, 2]
z = [0, 0, 0, 0]
dx = np.ones_like(x) * 0.5
dy = np.ones_like(x) * 0.5
dz = [2, 3, 1, 4]
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.bar3d(x, y, z, dx, dy, dz)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/fill_between3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
n = 50
theta = np.linspace(0, 2 * np.pi, n)
x1 = np.cos(theta)
y1 = np.sin(theta)
z1 = np.linspace(0, 1, n)
x2 = np.cos(theta + np.pi)
y2 = np.sin(theta + np.pi)
z2 = z1
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.fill_between(x1, y1, z1, x2, y2, z2, alpha=0.5)
ax.plot(x1, y1, z1, linewidth=2, color='C0')
ax.plot(x2, y2, z2, linewidth=2, color='C0')
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/plot3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
n = 100
xs = np.linspace(0, 1, n)
ys = np.sin(xs * 6 * np.pi)
zs = np.cos(xs * 6 * np.pi)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.plot(xs, ys, zs)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/quiver3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
n = 4
x = np.linspace(-1, 1, n)
y = np.linspace(-1, 1, n)
z = np.linspace(-1, 1, n)
(X, Y, Z) = np.meshgrid(x, y, z)
U = (X + Y) / 5
V = (Y - X) / 5
W = Z * 0
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.quiver(X, Y, Z, U, V, W)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/scatter3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(19680801)
n = 100
rng = np.random.default_rng()
xs = rng.uniform(23, 32, n)
ys = rng.uniform(0, 100, n)
zs = rng.uniform(-50, -25, n)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.scatter(xs, ys, zs)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/stem3d.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
n = 20
x = np.sin(np.linspace(0, 2 * np.pi, n))
y = np.cos(np.linspace(0, 2 * np.pi, n))
z = np.linspace(0, 1, n)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.stem(x, y, z)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/surface3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm
plt.style.use('_mpl-gallery')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
(X, Y) = np.meshgrid(X, Y)
R = np.sqrt(X ** 2 + Y ** 2)
Z = np.sin(R)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.plot_surface(X, Y, Z, vmin=Z.min() * 2, cmap=cm.Blues)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/trisurf3d_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm
plt.style.use('_mpl-gallery')
n_radii = 8
n_angles = 36
radii = np.linspace(0.125, 1.0, n_radii)
angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)[..., np.newaxis]
x = np.append(0, (radii * np.cos(angles)).flatten())
y = np.append(0, (radii * np.sin(angles)).flatten())
z = np.sin(-x * y)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.plot_trisurf(x, y, z, vmin=z.min() * 2, cmap=cm.Blues)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/voxels_simple.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
(x, y, z) = np.indices((8, 8, 8))
cube1 = (x < 3) & (y < 3) & (z < 3)
cube2 = (x >= 5) & (y >= 5) & (z >= 5)
voxelarray = cube1 | cube2
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.voxels(voxelarray, edgecolor='k')
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/3D/wire3d_simple.py
""""""
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import axes3d
plt.style.use('_mpl-gallery')
(X, Y, Z) = axes3d.get_test_data(0.05)
(fig, ax) = plt.subplots(subplot_kw={'projection': '3d'})
ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/barbs.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
(X, Y) = np.meshgrid([1, 2, 3, 4], [1, 2, 3, 4])
angle = np.pi / 180 * np.array([[15.0, 30, 35, 45], [25.0, 40, 55, 60], [35.0, 50, 65, 75], [45.0, 60, 75, 90]])
amplitude = np.array([[5, 10, 25, 50], [10, 15, 30, 60], [15, 26, 50, 70], [20, 45, 80, 100]])
U = amplitude * np.sin(angle)
V = amplitude * np.cos(angle)
(fig, ax) = plt.subplots()
ax.barbs(X, Y, U, V, barbcolor='C0', flagcolor='C0', length=7, linewidth=1.5)
ax.set(xlim=(0, 4.5), ylim=(0, 4.5))
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/contour.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
(X, Y) = np.meshgrid(np.linspace(-3, 3, 256), np.linspace(-3, 3, 256))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
levels = np.linspace(np.min(Z), np.max(Z), 7)
(fig, ax) = plt.subplots()
ax.contour(X, Y, Z, levels=levels)
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/contourf.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
(X, Y) = np.meshgrid(np.linspace(-3, 3, 256), np.linspace(-3, 3, 256))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
levels = np.linspace(Z.min(), Z.max(), 7)
(fig, ax) = plt.subplots()
ax.contourf(X, Y, Z, levels=levels)
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/imshow.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
(X, Y) = np.meshgrid(np.linspace(-3, 3, 16), np.linspace(-3, 3, 16))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
(fig, ax) = plt.subplots()
ax.imshow(Z, origin='lower')
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/pcolormesh.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
x = [-3, -2, -1.6, -1.2, -0.8, -0.5, -0.2, 0.1, 0.3, 0.5, 0.8, 1.1, 1.5, 1.9, 2.3, 3]
(X, Y) = np.meshgrid(x, np.linspace(-3, 3, 128))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
(fig, ax) = plt.subplots()
ax.pcolormesh(X, Y, Z, vmin=-0.5, vmax=1.0)
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/quiver.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
x = np.linspace(-4, 4, 6)
y = np.linspace(-4, 4, 6)
(X, Y) = np.meshgrid(x, y)
U = X + Y
V = Y - X
(fig, ax) = plt.subplots()
ax.quiver(X, Y, U, V, color='C0', angles='xy', scale_units='xy', scale=5, width=0.015)
ax.set(xlim=(-5, 5), ylim=(-5, 5))
plt.show()

# File: matplotlib-main/galleries/plot_types/arrays/streamplot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
(X, Y) = np.meshgrid(np.linspace(-3, 3, 256), np.linspace(-3, 3, 256))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
V = np.diff(Z[1:, :], axis=1)
U = -np.diff(Z[:, 1:], axis=0)
(fig, ax) = plt.subplots()
ax.streamplot(X[1:, 1:], Y[1:, 1:], U, V)
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/bar.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
x = 0.5 + np.arange(8)
y = [4.8, 5.5, 3.5, 4.6, 6.5, 6.6, 2.6, 3.0]
(fig, ax) = plt.subplots()
ax.bar(x, y, width=1, edgecolor='white', linewidth=0.7)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/fill_between.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(1)
x = np.linspace(0, 8, 16)
y1 = 3 + 4 * x / 8 + np.random.uniform(0.0, 0.5, len(x))
y2 = 1 + 2 * x / 8 + np.random.uniform(0.0, 0.5, len(x))
(fig, ax) = plt.subplots()
ax.fill_between(x, y1, y2, alpha=0.5, linewidth=0)
ax.plot(x, (y1 + y2) / 2, linewidth=2)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/plot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
x = np.linspace(0, 10, 100)
y = 4 + 1 * np.sin(2 * x)
x2 = np.linspace(0, 10, 25)
y2 = 4 + 1 * np.sin(2 * x2)
(fig, ax) = plt.subplots()
ax.plot(x2, y2 + 2.5, 'x', markeredgewidth=2)
ax.plot(x, y, linewidth=2.0)
ax.plot(x2, y2 - 2.5, 'o-', linewidth=2)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/scatter_plot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(3)
x = 4 + np.random.normal(0, 2, 24)
y = 4 + np.random.normal(0, 2, len(x))
sizes = np.random.uniform(15, 80, len(x))
colors = np.random.uniform(15, 80, len(x))
(fig, ax) = plt.subplots()
ax.scatter(x, y, s=sizes, c=colors, vmin=0, vmax=100)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/stackplot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
x = np.arange(0, 10, 2)
ay = [1, 1.25, 2, 2.75, 3]
by = [1, 1, 1, 1, 1]
cy = [2, 1, 2, 1, 2]
y = np.vstack([ay, by, cy])
(fig, ax) = plt.subplots()
ax.stackplot(x, y)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/stairs.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
y = [4.8, 5.5, 3.5, 4.6, 6.5, 6.6, 2.6, 3.0]
(fig, ax) = plt.subplots()
ax.stairs(y, linewidth=2.5)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/basic/stem.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
x = 0.5 + np.arange(8)
y = [4.8, 5.5, 3.5, 4.6, 6.5, 6.6, 2.6, 3.0]
(fig, ax) = plt.subplots()
ax.stem(x, y)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/boxplot_plot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(10)
D = np.random.normal((3, 5, 4), (1.25, 1.0, 1.25), (100, 3))
(fig, ax) = plt.subplots()
VP = ax.boxplot(D, positions=[2, 4, 6], widths=1.5, patch_artist=True, showmeans=False, showfliers=False, medianprops={'color': 'white', 'linewidth': 0.5}, boxprops={'facecolor': 'C0', 'edgecolor': 'white', 'linewidth': 0.5}, whiskerprops={'color': 'C0', 'linewidth': 1.5}, capprops={'color': 'C0', 'linewidth': 1.5})
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/ecdf.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(1)
x = 4 + np.random.normal(0, 1.5, 200)
(fig, ax) = plt.subplots()
ax.ecdf(x)
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/errorbar_plot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(1)
x = [2, 4, 6]
y = [3.6, 5, 4.2]
yerr = [0.9, 1.2, 0.5]
(fig, ax) = plt.subplots()
ax.errorbar(x, y, yerr, fmt='o', linewidth=2, capsize=6)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/eventplot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(1)
x = [2, 4, 6]
D = np.random.gamma(4, size=(3, 50))
(fig, ax) = plt.subplots()
ax.eventplot(D, orientation='vertical', lineoffsets=x, linewidth=0.75)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/hexbin.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.randn(5000)
y = 1.2 * x + np.random.randn(5000) / 3
(fig, ax) = plt.subplots()
ax.hexbin(x, y, gridsize=20)
ax.set(xlim=(-2, 2), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/hist2d.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.randn(5000)
y = 1.2 * x + np.random.randn(5000) / 3
(fig, ax) = plt.subplots()
ax.hist2d(x, y, bins=(np.arange(-3, 3, 0.1), np.arange(-3, 3, 0.1)))
ax.set(xlim=(-2, 2), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/hist_plot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(1)
x = 4 + np.random.normal(0, 1.5, 200)
(fig, ax) = plt.subplots()
ax.hist(x, bins=8, linewidth=0.5, edgecolor='white')
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 56), yticks=np.linspace(0, 56, 9))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/pie.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
x = [1, 2, 3, 4]
colors = plt.get_cmap('Blues')(np.linspace(0.2, 0.7, len(x)))
(fig, ax) = plt.subplots()
ax.pie(x, colors=colors, radius=3, center=(4, 4), wedgeprops={'linewidth': 1, 'edgecolor': 'white'}, frame=True)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/stats/violin.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery')
np.random.seed(10)
D = np.random.normal((3, 5, 4), (0.75, 1.0, 0.75), (200, 3))
(fig, ax) = plt.subplots()
vp = ax.violinplot(D, [2, 4, 6], widths=2, showmeans=False, showmedians=False, showextrema=False)
for body in vp['bodies']:
    body.set_alpha(0.9)
ax.set(xlim=(0, 8), xticks=np.arange(1, 8), ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()

# File: matplotlib-main/galleries/plot_types/unstructured/tricontour.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.uniform(-3, 3, 256)
y = np.random.uniform(-3, 3, 256)
z = (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
levels = np.linspace(z.min(), z.max(), 7)
(fig, ax) = plt.subplots()
ax.plot(x, y, 'o', markersize=2, color='lightgrey')
ax.tricontour(x, y, z, levels=levels)
ax.set(xlim=(-3, 3), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/plot_types/unstructured/tricontourf.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.uniform(-3, 3, 256)
y = np.random.uniform(-3, 3, 256)
z = (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
levels = np.linspace(z.min(), z.max(), 7)
(fig, ax) = plt.subplots()
ax.plot(x, y, 'o', markersize=2, color='grey')
ax.tricontourf(x, y, z, levels=levels)
ax.set(xlim=(-3, 3), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/plot_types/unstructured/tripcolor.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.uniform(-3, 3, 256)
y = np.random.uniform(-3, 3, 256)
z = (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
(fig, ax) = plt.subplots()
ax.plot(x, y, 'o', markersize=2, color='grey')
ax.tripcolor(x, y, z)
ax.set(xlim=(-3, 3), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/plot_types/unstructured/triplot.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('_mpl-gallery-nogrid')
np.random.seed(1)
x = np.random.uniform(-3, 3, 256)
y = np.random.uniform(-3, 3, 256)
z = (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
(fig, ax) = plt.subplots()
ax.triplot(x, y)
ax.set(xlim=(-3, 3), ylim=(-3, 3))
plt.show()

# File: matplotlib-main/galleries/tutorials/artists.py
""""""
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
fig.subplots_adjust(top=0.8)
ax1 = fig.add_subplot(211)
ax1.set_ylabel('Voltage [V]')
ax1.set_title('A sine wave')
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2 * np.pi * t)
(line,) = ax1.plot(t, s, color='blue', lw=2)
np.random.seed(19680801)
ax2 = fig.add_axes([0.15, 0.1, 0.7, 0.3])
(n, bins, patches) = ax2.hist(np.random.randn(1000), 50, facecolor='yellow', edgecolor='yellow')
ax2.set_xlabel('Time [s]')
plt.show()
import matplotlib.lines as lines
fig = plt.figure()
l1 = lines.Line2D([0, 1], [0, 1], transform=fig.transFigure, figure=fig)
l2 = lines.Line2D([0, 1], [1, 0], transform=fig.transFigure, figure=fig)
fig.lines.extend([l1, l2])
plt.show()
(fig, ax) = plt.subplots()
axis = ax.xaxis
axis.get_ticklocs()
axis.get_ticklabels()
axis.get_ticklines()
axis.get_ticklabels(minor=True)
axis.get_ticklines(minor=True)
fig = plt.figure()
rect = fig.patch
rect.set_facecolor('lightgoldenrodyellow')
ax1 = fig.add_axes([0.1, 0.3, 0.4, 0.4])
rect = ax1.patch
rect.set_facecolor('lightslategray')
for label in ax1.xaxis.get_ticklabels():
    label.set_color('red')
    label.set_rotation(45)
    label.set_fontsize(16)
for line in ax1.yaxis.get_ticklines():
    line.set_color('green')
    line.set_markersize(25)
    line.set_markeredgewidth(3)
plt.show()

# File: matplotlib-main/galleries/tutorials/images.py
""""""
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
img = np.asarray(Image.open('../../doc/_static/stinkbug.png'))
print(repr(img))
imgplot = plt.imshow(img)
lum_img = img[:, :, 0]
plt.imshow(lum_img)
plt.imshow(lum_img, cmap='hot')
imgplot = plt.imshow(lum_img)
imgplot.set_cmap('nipy_spectral')
imgplot = plt.imshow(lum_img)
plt.colorbar()
plt.hist(lum_img.ravel(), bins=range(256), fc='k', ec='k')
plt.imshow(lum_img, clim=(0, 175))
imgplot = plt.imshow(lum_img)
imgplot.set_clim(0, 175)
img = Image.open('../../doc/_static/stinkbug.png')
img.thumbnail((64, 64))
imgplot = plt.imshow(img)
imgplot = plt.imshow(img, interpolation='bilinear')
imgplot = plt.imshow(img, interpolation='bicubic')

# File: matplotlib-main/galleries/tutorials/lifecycle.py
""""""
import matplotlib.pyplot as plt
import numpy as np
data = {'Barton LLC': 109438.5, 'Frami, Hills and Schmidt': 103569.59, 'Fritsch, Russel and Anderson': 112214.71, 'Jerde-Hilpert': 112591.43, 'Keeling LLC': 100934.3, 'Koepp Ltd': 103660.54, 'Kulas Inc': 137351.96, 'Trantow-Barrows': 123381.38, 'White-Trantow': 135841.99, 'Will LLC': 104437.6}
group_data = list(data.values())
group_names = list(data.keys())
group_mean = np.mean(group_data)
(fig, ax) = plt.subplots()
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
print(plt.style.available)
plt.style.use('fivethirtyeight')
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
plt.rcParams.update({'figure.autolayout': True})
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
(fig, ax) = plt.subplots()
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company', title='Company Revenue')
(fig, ax) = plt.subplots(figsize=(8, 4))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company', title='Company Revenue')

def currency(x, pos):
    if x >= 1000000.0:
        s = f'${x * 1e-06:1.1f}M'
    else:
        s = f'${x * 0.001:1.0f}K'
    return s
(fig, ax) = plt.subplots(figsize=(6, 8))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company', title='Company Revenue')
ax.xaxis.set_major_formatter(currency)
(fig, ax) = plt.subplots(figsize=(8, 8))
ax.barh(group_names, group_data)
labels = ax.get_xticklabels()
plt.setp(labels, rotation=45, horizontalalignment='right')
ax.axvline(group_mean, ls='--', color='r')
for group in [3, 5, 8]:
    ax.text(145000, group, 'New Company', fontsize=10, verticalalignment='center')
ax.title.set(y=1.05)
ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company', title='Company Revenue')
ax.xaxis.set_major_formatter(currency)
ax.set_xticks([0, 25000.0, 50000.0, 75000.0, 100000.0, 125000.0])
fig.subplots_adjust(right=0.1)
plt.show()
print(fig.canvas.get_supported_filetypes())

# File: matplotlib-main/galleries/tutorials/pyplot.py
""""""
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis((0, 6, 0, 20))
plt.show()
import numpy as np
t = np.arange(0.0, 5.0, 0.2)
plt.plot(t, t, 'r--', t, t ** 2, 'bs', t, t ** 3, 'g^')
plt.show()
data = {'a': np.arange(50), 'c': np.random.randint(0, 50, 50), 'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100
plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()
names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]
plt.figure(figsize=(9, 3))
plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

def f(t):
    return np.exp(-t) * np.cos(2 * np.pi * t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2 * np.pi * t2), 'r--')
plt.show()
(mu, sigma) = (100, 15)
x = mu + sigma * np.random.randn(10000)
(n, bins, patches) = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)
plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, 0.025, '$\\mu=100,\\ \\sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()
ax = plt.subplot()
t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
(line,) = plt.plot(t, s, lw=2)
plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5), arrowprops=dict(facecolor='black', shrink=0.05))
plt.ylim(-2, 2)
plt.show()
np.random.seed(19680801)
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))
plt.figure()
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.01)
plt.title('symlog')
plt.grid(True)
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.1, right=0.95, hspace=0.25, wspace=0.35)
plt.show()

# File: matplotlib-main/galleries/users_explain/animations/animations.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation
(fig, ax) = plt.subplots()
t = np.linspace(0, 3, 40)
g = -9.81
v0 = 12
z = g * t ** 2 / 2 + v0 * t
v02 = 5
z2 = g * t ** 2 / 2 + v02 * t
scat = ax.scatter(t[0], z[0], c='b', s=5, label=f'v0 = {v0} m/s')
line2 = ax.plot(t[0], z2[0], label=f'v0 = {v02} m/s')[0]
ax.set(xlim=[0, 3], ylim=[-4, 10], xlabel='Time [s]', ylabel='Z [m]')
ax.legend()

def update(frame):
    x = t[:frame]
    y = z[:frame]
    data = np.stack([x, y]).T
    scat.set_offsets(data)
    line2.set_xdata(t[:frame])
    line2.set_ydata(z2[:frame])
    return (scat, line2)
ani = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30)
plt.show()
(fig, ax) = plt.subplots()
rng = np.random.default_rng(19680801)
data = np.array([20, 20, 20, 20])
x = np.array([1, 2, 3, 4])
artists = []
colors = ['tab:blue', 'tab:red', 'tab:green', 'tab:purple']
for i in range(20):
    data += rng.integers(low=0, high=10, size=data.shape)
    container = ax.barh(x, data, color=colors)
    artists.append(container)
ani = animation.ArtistAnimation(fig=fig, artists=artists, interval=400)
plt.show()

# File: matplotlib-main/galleries/users_explain/animations/blitting.py
""""""
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
(fig, ax) = plt.subplots()
(ln,) = ax.plot(x, np.sin(x), animated=True)
plt.show(block=False)
plt.pause(0.1)
bg = fig.canvas.copy_from_bbox(fig.bbox)
ax.draw_artist(ln)
fig.canvas.blit(fig.bbox)
for j in range(100):
    fig.canvas.restore_region(bg)
    ln.set_ydata(np.sin(x + j / 100 * np.pi))
    ax.draw_artist(ln)
    fig.canvas.blit(fig.bbox)
    fig.canvas.flush_events()

class BlitManager:

    def __init__(self, canvas, animated_artists=()):
        self.canvas = canvas
        self._bg = None
        self._artists = []
        for a in animated_artists:
            self.add_artist(a)
        self.cid = canvas.mpl_connect('draw_event', self.on_draw)

    def on_draw(self, event):
        cv = self.canvas
        if event is not None:
            if event.canvas != cv:
                raise RuntimeError
        self._bg = cv.copy_from_bbox(cv.figure.bbox)
        self._draw_animated()

    def add_artist(self, art):
        if art.figure != self.canvas.figure:
            raise RuntimeError
        art.set_animated(True)
        self._artists.append(art)

    def _draw_animated(self):
        fig = self.canvas.figure
        for a in self._artists:
            fig.draw_artist(a)

    def update(self):
        cv = self.canvas
        fig = cv.figure
        if self._bg is None:
            self.on_draw(None)
        else:
            cv.restore_region(self._bg)
            self._draw_animated()
            cv.blit(fig.bbox)
        cv.flush_events()
(fig, ax) = plt.subplots()
(ln,) = ax.plot(x, np.sin(x), animated=True)
fr_number = ax.annotate('0', (0, 1), xycoords='axes fraction', xytext=(10, -10), textcoords='offset points', ha='left', va='top', animated=True)
bm = BlitManager(fig.canvas, [ln, fr_number])
plt.show(block=False)
plt.pause(0.1)
for j in range(100):
    ln.set_ydata(np.sin(x + j / 100 * np.pi))
    fr_number.set_text(f'frame: {j}')
    bm.update()

# File: matplotlib-main/galleries/users_explain/artists/color_cycle.py
""""""
from cycler import cycler
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 50)
offsets = np.linspace(0, 2 * np.pi, 4, endpoint=False)
yy = np.transpose([np.sin(x + phi) for phi in offsets])
print(yy.shape)
default_cycler = cycler(color=['r', 'g', 'b', 'y']) + cycler(linestyle=['-', '--', ':', '-.'])
plt.rc('lines', linewidth=4)
plt.rc('axes', prop_cycle=default_cycler)
custom_cycler = cycler(color=['c', 'm', 'y', 'k']) + cycler(lw=[1, 2, 3, 4])
(fig, (ax0, ax1)) = plt.subplots(nrows=2)
ax0.plot(yy)
ax0.set_title('Set default color cycle to rgby')
ax1.set_prop_cycle(custom_cycler)
ax1.plot(yy)
ax1.set_title('Set axes color cycle to cmyk')
fig.subplots_adjust(hspace=0.3)
plt.show()

# File: matplotlib-main/galleries/users_explain/artists/imshow_extent.py
""""""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.gridspec import GridSpec

def index_to_coordinate(index, extent, origin):
    (left, right, bottom, top) = extent
    hshift = 0.5 * np.sign(right - left)
    (left, right) = (left + hshift, right - hshift)
    vshift = 0.5 * np.sign(top - bottom)
    (bottom, top) = (bottom + vshift, top - vshift)
    if origin == 'upper':
        (bottom, top) = (top, bottom)
    return {'[0, 0]': (left, bottom), "[M', 0]": (left, top), "[0, N']": (right, bottom), "[M', N']": (right, top)}[index]

def get_index_label_pos(index, extent, origin, inverted_xindex):
    if extent is None:
        extent = lookup_extent(origin)
    (left, right, bottom, top) = extent
    (x, y) = index_to_coordinate(index, extent, origin)
    is_x0 = index[-2:] == '0]'
    halign = 'left' if is_x0 ^ inverted_xindex else 'right'
    hshift = 0.5 * np.sign(left - right)
    x += hshift * (1 if is_x0 else -1)
    return (x, y, halign)

def get_color(index, data, cmap):
    val = {'[0, 0]': data[0, 0], "[0, N']": data[0, -1], "[M', 0]": data[-1, 0], "[M', N']": data[-1, -1]}[index]
    return cmap(val / data.max())

def lookup_extent(origin):
    if origin == 'lower':
        return (-0.5, 6.5, -0.5, 5.5)
    else:
        return (-0.5, 6.5, 5.5, -0.5)

def set_extent_None_text(ax):
    ax.text(3, 2.5, 'equals\nextent=None', size='large', ha='center', va='center', color='w')

def plot_imshow_with_labels(ax, data, extent, origin, xlim, ylim):
    im = ax.imshow(data, origin=origin, extent=extent)
    (left, right, bottom, top) = im.get_extent()
    if xlim is None or top > bottom:
        (upper_string, lower_string) = ('top', 'bottom')
    else:
        (upper_string, lower_string) = ('bottom', 'top')
    if ylim is None or left < right:
        (port_string, starboard_string) = ('left', 'right')
        inverted_xindex = False
    else:
        (port_string, starboard_string) = ('right', 'left')
        inverted_xindex = True
    bbox_kwargs = {'fc': 'w', 'alpha': 0.75, 'boxstyle': 'round4'}
    ann_kwargs = {'xycoords': 'axes fraction', 'textcoords': 'offset points', 'bbox': bbox_kwargs}
    ax.annotate(upper_string, xy=(0.5, 1), xytext=(0, -1), ha='center', va='top', **ann_kwargs)
    ax.annotate(lower_string, xy=(0.5, 0), xytext=(0, 1), ha='center', va='bottom', **ann_kwargs)
    ax.annotate(port_string, xy=(0, 0.5), xytext=(1, 0), ha='left', va='center', rotation=90, **ann_kwargs)
    ax.annotate(starboard_string, xy=(1, 0.5), xytext=(-1, 0), ha='right', va='center', rotation=-90, **ann_kwargs)
    ax.set_title(f'origin: {origin}')
    for index in ['[0, 0]', "[0, N']", "[M', 0]", "[M', N']"]:
        (tx, ty, halign) = get_index_label_pos(index, extent, origin, inverted_xindex)
        facecolor = get_color(index, data, im.get_cmap())
        ax.text(tx, ty, index, color='white', ha=halign, va='center', bbox={'boxstyle': 'square', 'facecolor': facecolor})
    if xlim:
        ax.set_xlim(*xlim)
    if ylim:
        ax.set_ylim(*ylim)

def generate_imshow_demo_grid(extents, xlim=None, ylim=None):
    N = len(extents)
    fig = plt.figure(tight_layout=True)
    fig.set_size_inches(6, N * 11.25 / 5)
    gs = GridSpec(N, 5, figure=fig)
    columns = {'label': [fig.add_subplot(gs[j, 0]) for j in range(N)], 'upper': [fig.add_subplot(gs[j, 1:3]) for j in range(N)], 'lower': [fig.add_subplot(gs[j, 3:5]) for j in range(N)]}
    (x, y) = np.ogrid[0:6, 0:7]
    data = x + y
    for origin in ['upper', 'lower']:
        for (ax, extent) in zip(columns[origin], extents):
            plot_imshow_with_labels(ax, data, extent, origin, xlim, ylim)
    columns['label'][0].set_title('extent=')
    for (ax, extent) in zip(columns['label'], extents):
        if extent is None:
            text = 'None'
        else:
            (left, right, bottom, top) = extent
            text = f'left: {left:0.1f}\nright: {right:0.1f}\nbottom: {bottom:0.1f}\ntop: {top:0.1f}\n'
        ax.text(1.0, 0.5, text, transform=ax.transAxes, ha='right', va='center')
        ax.axis('off')
    return columns
generate_imshow_demo_grid(extents=[None])
extents = [(-0.5, 6.5, -0.5, 5.5), (-0.5, 6.5, 5.5, -0.5), (6.5, -0.5, -0.5, 5.5), (6.5, -0.5, 5.5, -0.5)]
columns = generate_imshow_demo_grid(extents)
set_extent_None_text(columns['upper'][1])
set_extent_None_text(columns['lower'][0])
generate_imshow_demo_grid(extents=[None] + extents, xlim=(-2, 8), ylim=(-1, 6))
plt.show()

# File: matplotlib-main/galleries/users_explain/artists/patheffects_guide.py
""""""
import matplotlib.pyplot as plt
import matplotlib.patheffects as path_effects
fig = plt.figure(figsize=(5, 1.5))
text = fig.text(0.5, 0.5, 'Hello path effects world!\nThis is the normal path effect.\nPretty dull, huh?', ha='center', va='center', size=20)
text.set_path_effects([path_effects.Normal()])
plt.show()
import matplotlib.patheffects as path_effects
text = plt.text(0.5, 0.5, 'Hello path effects world!', path_effects=[path_effects.withSimplePatchShadow()])
plt.plot([0, 3, 2, 5], linewidth=5, color='blue', path_effects=[path_effects.SimpleLineShadow(), path_effects.Normal()])
plt.show()
fig = plt.figure(figsize=(7, 1))
text = fig.text(0.5, 0.5, 'This text stands out because of\nits black border.', color='white', ha='center', va='center', size=30)
text.set_path_effects([path_effects.Stroke(linewidth=3, foreground='black'), path_effects.Normal()])
plt.show()
fig = plt.figure(figsize=(8.5, 1))
t = fig.text(0.02, 0.5, 'Hatch shadow', fontsize=75, weight=1000, va='center')
t.set_path_effects([path_effects.PathPatchEffect(offset=(4, -4), hatch='xxxx', facecolor='gray'), path_effects.PathPatchEffect(edgecolor='white', linewidth=1.1, facecolor='black')])
plt.show()

# File: matplotlib-main/galleries/users_explain/artists/paths.py
""""""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from matplotlib.path import Path
verts = [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)]
codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
path = Path(verts, codes)
(fig, ax) = plt.subplots()
patch = patches.PathPatch(path, facecolor='orange', lw=2)
ax.add_patch(patch)
ax.set_xlim(-2, 2)
ax.set_ylim(-2, 2)
plt.show()
verts = [(0.0, 0.0), (0.2, 1.0), (1.0, 0.8), (0.8, 0.0)]
codes = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
path = Path(verts, codes)
(fig, ax) = plt.subplots()
patch = patches.PathPatch(path, facecolor='none', lw=2)
ax.add_patch(patch)
(xs, ys) = zip(*verts)
ax.plot(xs, ys, 'x--', lw=2, color='black', ms=10)
ax.text(-0.05, -0.05, 'P0')
ax.text(0.15, 1.05, 'P1')
ax.text(1.05, 0.85, 'P2')
ax.text(0.85, -0.05, 'P3')
ax.set_xlim(-0.1, 1.1)
ax.set_ylim(-0.1, 1.1)
plt.show()
(fig, ax) = plt.subplots()
np.random.seed(19680801)
data = np.random.randn(1000)
(n, bins) = np.histogram(data, 100)
left = np.array(bins[:-1])
right = np.array(bins[1:])
bottom = np.zeros(len(left))
top = bottom + n
nrects = len(left)
nverts = nrects * (1 + 3 + 1)
verts = np.zeros((nverts, 2))
codes = np.full(nverts, Path.LINETO, dtype=int)
codes[0::5] = Path.MOVETO
codes[4::5] = Path.CLOSEPOLY
verts[0::5, 0] = left
verts[0::5, 1] = bottom
verts[1::5, 0] = left
verts[1::5, 1] = top
verts[2::5, 0] = right
verts[2::5, 1] = top
verts[3::5, 0] = right
verts[3::5, 1] = bottom
barpath = Path(verts, codes)
patch = patches.PathPatch(barpath, facecolor='green', edgecolor='yellow', alpha=0.5)
ax.add_patch(patch)
ax.set_xlim(left[0], right[-1])
ax.set_ylim(bottom.min(), top.max())
plt.show()

# File: matplotlib-main/galleries/users_explain/artists/transforms_tutorial.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.patches as mpatches
x = np.arange(0, 10, 0.005)
y = np.exp(-x / 2.0) * np.sin(2 * np.pi * x)
(fig, ax) = plt.subplots()
ax.plot(x, y)
ax.set_xlim(0, 10)
ax.set_ylim(-1, 1)
plt.show()
x = np.arange(0, 10, 0.005)
y = np.exp(-x / 2.0) * np.sin(2 * np.pi * x)
(fig, ax) = plt.subplots()
ax.plot(x, y)
ax.set_xlim(0, 10)
ax.set_ylim(-1, 1)
(xdata, ydata) = (5, 0)
(xdisplay, ydisplay) = ax.transData.transform((xdata, ydata))
bbox = dict(boxstyle='round', fc='0.8')
arrowprops = dict(arrowstyle='->', connectionstyle='angle,angleA=0,angleB=90,rad=10')
offset = 72
ax.annotate(f'data = ({xdata:.1f}, {ydata:.1f})', (xdata, ydata), xytext=(-2 * offset, offset), textcoords='offset points', bbox=bbox, arrowprops=arrowprops)
disp = ax.annotate(f'display = ({xdisplay:.1f}, {ydisplay:.1f})', (xdisplay, ydisplay), xytext=(0.5 * offset, -offset), xycoords='figure pixels', textcoords='offset points', bbox=bbox, arrowprops=arrowprops)
plt.show()
fig = plt.figure()
for (i, label) in enumerate(('A', 'B', 'C', 'D')):
    ax = fig.add_subplot(2, 2, i + 1)
    ax.text(0.05, 0.95, label, transform=ax.transAxes, fontsize=16, fontweight='bold', va='top')
plt.show()
(fig, ax) = plt.subplots()
(x, y) = 10 * np.random.rand(2, 1000)
ax.plot(x, y, 'go', alpha=0.2)
circ = mpatches.Circle((0.5, 0.5), 0.25, transform=ax.transAxes, facecolor='blue', alpha=0.75)
ax.add_patch(circ)
plt.show()
import matplotlib.transforms as transforms
(fig, ax) = plt.subplots()
x = np.random.randn(1000)
ax.hist(x, 30)
ax.set_title('$\\sigma=1 \\/ \\dots \\/ \\sigma=2$', fontsize=16)
trans = transforms.blended_transform_factory(ax.transData, ax.transAxes)
rect = mpatches.Rectangle((1, 0), width=1, height=1, transform=trans, color='yellow', alpha=0.5)
ax.add_patch(rect)
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 4))
(x, y) = 10 * np.random.rand(2, 1000)
ax.plot(x, y * 10.0, 'go', alpha=0.2)
circ = mpatches.Circle((2.5, 2), 1.0, transform=fig.dpi_scale_trans, facecolor='blue', alpha=0.75)
ax.add_patch(circ)
plt.show()
(fig, ax) = plt.subplots(figsize=(7, 2))
(x, y) = 10 * np.random.rand(2, 1000)
ax.plot(x, y * 10.0, 'go', alpha=0.2)
circ = mpatches.Circle((2.5, 2), 1.0, transform=fig.dpi_scale_trans, facecolor='blue', alpha=0.75)
ax.add_patch(circ)
plt.show()
(fig, ax) = plt.subplots()
(xdata, ydata) = ((0.2, 0.7), (0.5, 0.5))
ax.plot(xdata, ydata, 'o')
ax.set_xlim((0, 1))
trans = fig.dpi_scale_trans + transforms.ScaledTranslation(xdata[0], ydata[0], ax.transData)
circle = mpatches.Ellipse((0, 0), 150 / 72, 130 / 72, angle=40, fill=None, transform=trans)
ax.add_patch(circle)
plt.show()
(fig, ax) = plt.subplots()
x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2 * np.pi * x)
(line,) = ax.plot(x, y, lw=3, color='blue')
(dx, dy) = (2 / 72.0, -2 / 72.0)
offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
shadow_transform = ax.transData + offset
ax.plot(x, y, lw=3, color='gray', transform=shadow_transform, zorder=0.5 * line.get_zorder())
ax.set_title('creating a shadow effect with an offset transform')
plt.show()

# File: matplotlib-main/galleries/users_explain/axes/arranging_axes.py
""""""
import matplotlib.pyplot as plt
import numpy as np
(w, h) = (4, 3)
margin = 0.5
fig = plt.figure(figsize=(w, h), facecolor='lightblue')
ax = fig.add_axes([margin / w, margin / h, (w - 2 * margin) / w, (h - 2 * margin) / h])
(fig, axs) = plt.subplots(ncols=2, nrows=2, figsize=(5.5, 3.5), layout='constrained')
for row in range(2):
    for col in range(2):
        axs[row, col].annotate(f'axs[{row}, {col}]', (0.5, 0.5), transform=axs[row, col].transAxes, ha='center', va='center', fontsize=18, color='darkgrey')
fig.suptitle('plt.subplots()')

def annotate_axes(ax, text, fontsize=18):
    ax.text(0.5, 0.5, text, transform=ax.transAxes, ha='center', va='center', fontsize=fontsize, color='darkgrey')
(fig, axd) = plt.subplot_mosaic([['upper left', 'upper right'], ['lower left', 'lower right']], figsize=(5.5, 3.5), layout='constrained')
for (k, ax) in axd.items():
    annotate_axes(ax, f'axd[{k!r}]', fontsize=14)
fig.suptitle('plt.subplot_mosaic()')
(fig, axs) = plt.subplots(2, 2, layout='constrained', figsize=(5.5, 3.5), facecolor='lightblue')
for ax in axs.flat:
    ax.set_aspect(1)
fig.suptitle('Fixed aspect Axes')
(fig, axs) = plt.subplots(2, 2, layout='compressed', figsize=(5.5, 3.5), facecolor='lightblue')
for ax in axs.flat:
    ax.set_aspect(1)
fig.suptitle('Fixed aspect Axes: compressed')
(fig, axd) = plt.subplot_mosaic([['upper left', 'right'], ['lower left', 'right']], figsize=(5.5, 3.5), layout='constrained')
for (k, ax) in axd.items():
    annotate_axes(ax, f'axd[{k!r}]', fontsize=14)
fig.suptitle('plt.subplot_mosaic()')
gs_kw = dict(width_ratios=[1.4, 1], height_ratios=[1, 2])
(fig, axd) = plt.subplot_mosaic([['upper left', 'right'], ['lower left', 'right']], gridspec_kw=gs_kw, figsize=(5.5, 3.5), layout='constrained')
for (k, ax) in axd.items():
    annotate_axes(ax, f'axd[{k!r}]', fontsize=14)
fig.suptitle('plt.subplot_mosaic()')
fig = plt.figure(layout='constrained')
subfigs = fig.subfigures(1, 2, wspace=0.07, width_ratios=[1.5, 1.0])
axs0 = subfigs[0].subplots(2, 2)
subfigs[0].set_facecolor('lightblue')
subfigs[0].suptitle('subfigs[0]\nLeft side')
subfigs[0].supxlabel('xlabel for subfigs[0]')
axs1 = subfigs[1].subplots(3, 1)
subfigs[1].suptitle('subfigs[1]')
subfigs[1].supylabel('ylabel for subfigs[1]')
inner = [['innerA'], ['innerB']]
outer = [['upper left', inner], ['lower left', 'lower right']]
(fig, axd) = plt.subplot_mosaic(outer, layout='constrained')
for (k, ax) in axd.items():
    annotate_axes(ax, f'axd[{k!r}]')
fig = plt.figure(figsize=(5.5, 3.5), layout='constrained')
spec = fig.add_gridspec(ncols=2, nrows=2)
ax0 = fig.add_subplot(spec[0, 0])
annotate_axes(ax0, 'ax0')
ax1 = fig.add_subplot(spec[0, 1])
annotate_axes(ax1, 'ax1')
ax2 = fig.add_subplot(spec[1, 0])
annotate_axes(ax2, 'ax2')
ax3 = fig.add_subplot(spec[1, 1])
annotate_axes(ax3, 'ax3')
fig.suptitle('Manually added subplots using add_gridspec')
fig = plt.figure(figsize=(5.5, 3.5), layout='constrained')
spec = fig.add_gridspec(2, 2)
ax0 = fig.add_subplot(spec[0, :])
annotate_axes(ax0, 'ax0')
ax10 = fig.add_subplot(spec[1, 0])
annotate_axes(ax10, 'ax10')
ax11 = fig.add_subplot(spec[1, 1])
annotate_axes(ax11, 'ax11')
fig.suptitle('Manually added subplots, spanning a column')
fig = plt.figure(layout=None, facecolor='lightblue')
gs = fig.add_gridspec(nrows=3, ncols=3, left=0.05, right=0.75, hspace=0.1, wspace=0.05)
ax0 = fig.add_subplot(gs[:-1, :])
annotate_axes(ax0, 'ax0')
ax1 = fig.add_subplot(gs[-1, :-1])
annotate_axes(ax1, 'ax1')
ax2 = fig.add_subplot(gs[-1, -1])
annotate_axes(ax2, 'ax2')
fig.suptitle('Manual gridspec with right=0.75')
fig = plt.figure(layout='constrained')
gs0 = fig.add_gridspec(1, 2)
gs00 = gs0[0].subgridspec(2, 2)
gs01 = gs0[1].subgridspec(3, 1)
for a in range(2):
    for b in range(2):
        ax = fig.add_subplot(gs00[a, b])
        annotate_axes(ax, f'axLeft[{a}, {b}]', fontsize=10)
        if a == 1 and b == 1:
            ax.set_xlabel('xlabel')
for a in range(3):
    ax = fig.add_subplot(gs01[a])
    annotate_axes(ax, f'axRight[{a}, {b}]')
    if a == 2:
        ax.set_ylabel('ylabel')
fig.suptitle('nested gridspecs')

def squiggle_xy(a, b, c, d, i=np.arange(0.0, 2 * np.pi, 0.05)):
    return (np.sin(i * a) * np.cos(i * b), np.sin(i * c) * np.cos(i * d))
fig = plt.figure(figsize=(8, 8), layout='constrained')
outer_grid = fig.add_gridspec(4, 4, wspace=0, hspace=0)
for a in range(4):
    for b in range(4):
        inner_grid = outer_grid[a, b].subgridspec(3, 3, wspace=0, hspace=0)
        axs = inner_grid.subplots()
        for ((c, d), ax) in np.ndenumerate(axs):
            ax.plot(*squiggle_xy(a + 1, b + 1, c + 1, d + 1))
            ax.set(xticks=[], yticks=[])
for ax in fig.get_axes():
    ss = ax.get_subplotspec()
    ax.spines.top.set_visible(ss.is_first_row())
    ax.spines.bottom.set_visible(ss.is_last_row())
    ax.spines.left.set_visible(ss.is_first_col())
    ax.spines.right.set_visible(ss.is_last_col())
plt.show()

# File: matplotlib-main/galleries/users_explain/axes/autoscale.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sinc(x)
(fig, ax) = plt.subplots()
ax.plot(x, y)
print(ax.margins())
(fig, ax) = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)
(fig, ax) = plt.subplots()
ax.plot(x, y)
ax.margins(y=-0.2)
(xx, yy) = np.meshgrid(x, x)
zz = np.sinc(np.sqrt((xx - 1) ** 2 + (yy - 1) ** 2))
(fig, ax) = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].imshow(zz)
ax[0].set_title('default margins')
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].set_title('margins(0.2)')
(fig, ax) = plt.subplots(ncols=3, figsize=(16, 10))
ax[0].imshow(zz)
ax[0].margins(0.2)
ax[0].set_title('default use_sticky_edges\nmargins(0.2)')
ax[1].imshow(zz)
ax[1].margins(0.2)
ax[1].use_sticky_edges = False
ax[1].set_title('use_sticky_edges=False\nmargins(0.2)')
ax[2].imshow(zz)
ax[2].margins(-0.2)
ax[2].set_title('default use_sticky_edges\nmargins(-0.2)')
(fig, ax) = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_title('Single curve')
ax[1].plot(x, y)
ax[1].plot(x * 2.0, y)
ax[1].set_title('Two curves')
(fig, ax) = plt.subplots(ncols=2, figsize=(12, 8))
ax[0].plot(x, y)
ax[0].set_xlim(left=-1, right=1)
ax[0].plot(x + np.pi * 0.5, y)
ax[0].set_title('set_xlim(left=-1, right=1)\n')
ax[1].plot(x, y)
ax[1].set_xlim(left=-1, right=1)
ax[1].plot(x + np.pi * 0.5, y)
ax[1].autoscale()
ax[1].set_title('set_xlim(left=-1, right=1)\nautoscale()')
print(ax[0].get_autoscale_on())
print(ax[1].get_autoscale_on())
(fig, ax) = plt.subplots()
ax.plot(x, y)
ax.margins(0.2, 0.2)
ax.autoscale(enable=None, axis='x', tight=True)
print(ax.margins())
(fig, ax) = plt.subplots()
collection = mpl.collections.StarPolygonCollection(5, rotation=0, sizes=(250,), offsets=np.column_stack([x, y]), offset_transform=ax.transData)
ax.add_collection(collection)
ax.autoscale_view()

# File: matplotlib-main/galleries/users_explain/axes/axes_scales.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.scale as mscale
from matplotlib.ticker import FixedLocator, NullFormatter
(fig, axs) = plt.subplot_mosaic([['linear', 'linear-log'], ['log-linear', 'log-log']], layout='constrained')
x = np.arange(0, 3 * np.pi, 0.1)
y = 2 * np.sin(x) + 3
ax = axs['linear']
ax.plot(x, y)
ax.set_xlabel('linear')
ax.set_ylabel('linear')
ax = axs['linear-log']
ax.plot(x, y)
ax.set_yscale('log')
ax.set_xlabel('linear')
ax.set_ylabel('log')
ax = axs['log-linear']
ax.plot(x, y)
ax.set_xscale('log')
ax.set_xlabel('log')
ax.set_ylabel('linear')
ax = axs['log-log']
ax.plot(x, y)
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('log')
ax.set_ylabel('log')
(fig, axs) = plt.subplot_mosaic([['linear', 'linear-log'], ['log-linear', 'log-log']], layout='constrained')
x = np.arange(0, 3 * np.pi, 0.1)
y = 2 * np.sin(x) + 3
ax = axs['linear']
ax.plot(x, y)
ax.set_xlabel('linear')
ax.set_ylabel('linear')
ax.set_title('plot(x, y)')
ax = axs['linear-log']
ax.semilogy(x, y)
ax.set_xlabel('linear')
ax.set_ylabel('log')
ax.set_title('semilogy(x, y)')
ax = axs['log-linear']
ax.semilogx(x, y)
ax.set_xlabel('log')
ax.set_ylabel('linear')
ax.set_title('semilogx(x, y)')
ax = axs['log-log']
ax.loglog(x, y)
ax.set_xlabel('log')
ax.set_ylabel('log')
ax.set_title('loglog(x, y)')
print(mscale.get_scale_names())
(fig, axs) = plt.subplot_mosaic([['asinh', 'symlog'], ['log', 'logit']], layout='constrained')
x = np.arange(0, 1000)
for (name, ax) in axs.items():
    if name in ['asinh', 'symlog']:
        yy = x - np.mean(x)
    elif name in ['logit']:
        yy = x - np.min(x)
        yy = yy / np.max(np.abs(yy))
    else:
        yy = x
    ax.plot(yy, yy)
    ax.set_yscale(name)
    ax.set_title(name)
(fig, axs) = plt.subplot_mosaic([['log', 'symlog']], layout='constrained', figsize=(6.4, 3))
for (name, ax) in axs.items():
    if name in ['log']:
        ax.plot(x, x)
        ax.set_yscale('log', base=2)
        ax.set_title('log base=2')
    else:
        ax.plot(x - np.mean(x), x - np.mean(x))
        ax.set_yscale('symlog', linthresh=100)
        ax.set_title('symlog linthresh=100')

def forward(a):
    a = np.deg2rad(a)
    return np.rad2deg(np.log(np.abs(np.tan(a) + 1.0 / np.cos(a))))

def inverse(a):
    a = np.deg2rad(a)
    return np.rad2deg(np.arctan(np.sinh(a)))
t = np.arange(0, 170.0, 0.1)
s = t / 2.0
(fig, ax) = plt.subplots(layout='constrained')
ax.plot(t, s, '-', lw=2)
ax.set_yscale('function', functions=(forward, inverse))
ax.set_title('function: Mercator')
ax.grid(True)
ax.set_xlim([0, 180])
ax.yaxis.set_minor_formatter(NullFormatter())
ax.yaxis.set_major_locator(FixedLocator(np.arange(0, 90, 10)))
(fig, ax) = plt.subplots(layout='constrained', figsize=(3.2, 3))
ax.semilogy(x, x)
print(ax.xaxis.get_scale())
print(ax.yaxis.get_scale())
print(ax.yaxis.get_transform())
print('X axis')
print(ax.xaxis.get_major_locator())
print(ax.xaxis.get_major_formatter())
print('Y axis')
print(ax.yaxis.get_major_locator())
print(ax.yaxis.get_major_formatter())

# File: matplotlib-main/galleries/users_explain/axes/axes_ticks.py
""""""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
(fig, axs) = plt.subplots(2, 1, figsize=(5.4, 5.4), layout='constrained')
x = np.arange(100)
for (nn, ax) in enumerate(axs):
    ax.plot(x, x)
    if nn == 1:
        ax.set_title('Manual ticks')
        ax.set_yticks(np.arange(0, 100.1, 100 / 3))
        xticks = np.arange(0.5, 101, 20)
        xlabels = [f'\\${x:1.2f}' for x in xticks]
        ax.set_xticks(xticks, labels=xlabels)
    else:
        ax.set_title('Automatic ticks')
(fig, axs) = plt.subplots(2, 1, figsize=(5.4, 5.4), layout='constrained')
x = np.arange(100)
for (nn, ax) in enumerate(axs):
    ax.plot(x, x)
    if nn == 1:
        ax.set_title('Manual ticks')
        ax.set_yticks(np.arange(0, 100.1, 100 / 3))
        ax.set_yticks(np.arange(0, 100.1, 100 / 30), minor=True)
    else:
        ax.set_title('Automatic ticks')

def setup(ax, title):
    ax.yaxis.set_major_locator(ticker.NullLocator())
    ax.spines[['left', 'right', 'top']].set_visible(False)
    ax.xaxis.set_ticks_position('bottom')
    ax.tick_params(which='major', width=1.0, length=5)
    ax.tick_params(which='minor', width=0.75, length=2.5)
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 1)
    ax.text(0.0, 0.2, title, transform=ax.transAxes, fontsize=14, fontname='Monospace', color='tab:blue')
(fig, axs) = plt.subplots(8, 1, layout='constrained')
setup(axs[0], title='NullLocator()')
axs[0].xaxis.set_major_locator(ticker.NullLocator())
axs[0].xaxis.set_minor_locator(ticker.NullLocator())
setup(axs[1], title='MultipleLocator(0.5)')
axs[1].xaxis.set_major_locator(ticker.MultipleLocator(0.5))
axs[1].xaxis.set_minor_locator(ticker.MultipleLocator(0.1))
setup(axs[2], title='FixedLocator([0, 1, 5])')
axs[2].xaxis.set_major_locator(ticker.FixedLocator([0, 1, 5]))
axs[2].xaxis.set_minor_locator(ticker.FixedLocator(np.linspace(0.2, 0.8, 4)))
setup(axs[3], title='LinearLocator(numticks=3)')
axs[3].xaxis.set_major_locator(ticker.LinearLocator(3))
axs[3].xaxis.set_minor_locator(ticker.LinearLocator(31))
setup(axs[4], title='IndexLocator(base=0.5, offset=0.25)')
axs[4].plot(range(0, 5), [0] * 5, color='white')
axs[4].xaxis.set_major_locator(ticker.IndexLocator(base=0.5, offset=0.25))
setup(axs[5], title='AutoLocator()')
axs[5].xaxis.set_major_locator(ticker.AutoLocator())
axs[5].xaxis.set_minor_locator(ticker.AutoMinorLocator())
setup(axs[6], title='MaxNLocator(n=4)')
axs[6].xaxis.set_major_locator(ticker.MaxNLocator(4))
axs[6].xaxis.set_minor_locator(ticker.MaxNLocator(40))
setup(axs[7], title='LogLocator(base=10, numticks=15)')
axs[7].set_xlim(10 ** 3, 10 ** 10)
axs[7].set_xscale('log')
axs[7].xaxis.set_major_locator(ticker.LogLocator(base=10, numticks=15))
plt.show()

def setup(ax, title):
    ax.yaxis.set_major_locator(ticker.NullLocator())
    ax.spines[['left', 'right', 'top']].set_visible(False)
    ax.xaxis.set_major_locator(ticker.MultipleLocator(1.0))
    ax.xaxis.set_minor_locator(ticker.MultipleLocator(0.25))
    ax.xaxis.set_ticks_position('bottom')
    ax.tick_params(which='major', width=1.0, length=5)
    ax.tick_params(which='minor', width=0.75, length=2.5, labelsize=10)
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 1)
    ax.text(0.0, 0.2, title, transform=ax.transAxes, fontsize=14, fontname='Monospace', color='tab:blue')
fig = plt.figure(figsize=(8, 8), layout='constrained')
(fig0, fig1, fig2) = fig.subfigures(3, height_ratios=[1.5, 1.5, 7.5])
fig0.suptitle('String Formatting', fontsize=16, x=0, ha='left')
ax0 = fig0.subplots()
setup(ax0, title="'{x} km'")
ax0.xaxis.set_major_formatter('{x} km')
fig1.suptitle('Function Formatting', fontsize=16, x=0, ha='left')
ax1 = fig1.subplots()
setup(ax1, title='def(x, pos): return str(x-5)')
ax1.xaxis.set_major_formatter(lambda x, pos: str(x - 5))
fig2.suptitle('Formatter Object Formatting', fontsize=16, x=0, ha='left')
axs2 = fig2.subplots(7, 1)
setup(axs2[0], title='NullFormatter()')
axs2[0].xaxis.set_major_formatter(ticker.NullFormatter())
setup(axs2[1], title="StrMethodFormatter('{x:.3f}')")
axs2[1].xaxis.set_major_formatter(ticker.StrMethodFormatter('{x:.3f}'))
setup(axs2[2], title="FormatStrFormatter('#%d')")
axs2[2].xaxis.set_major_formatter(ticker.FormatStrFormatter('#%d'))

def fmt_two_digits(x, pos):
    return f'[{x:.2f}]'
setup(axs2[3], title='FuncFormatter("[{:.2f}]".format)')
axs2[3].xaxis.set_major_formatter(ticker.FuncFormatter(fmt_two_digits))
setup(axs2[4], title="FixedFormatter(['A', 'B', 'C', 'D', 'E', 'F'])")
positions = [0, 1, 2, 3, 4, 5]
labels = ['A', 'B', 'C', 'D', 'E', 'F']
axs2[4].xaxis.set_major_locator(ticker.FixedLocator(positions))
axs2[4].xaxis.set_major_formatter(ticker.FixedFormatter(labels))
setup(axs2[5], title='ScalarFormatter()')
axs2[5].xaxis.set_major_formatter(ticker.ScalarFormatter(useMathText=True))
setup(axs2[6], title='PercentFormatter(xmax=5)')
axs2[6].xaxis.set_major_formatter(ticker.PercentFormatter(xmax=5))
(fig, axs) = plt.subplots(1, 2, figsize=(6.4, 3.2), layout='constrained')
for (nn, ax) in enumerate(axs):
    ax.plot(np.arange(100))
    if nn == 1:
        ax.grid('on')
        ax.tick_params(right=True, left=False, axis='y', color='r', length=16, grid_color='none')
        ax.tick_params(axis='x', color='m', length=4, direction='in', width=4, labelcolor='g', grid_color='b')

# File: matplotlib-main/galleries/users_explain/axes/axes_units.py
""""""
import numpy as np
import matplotlib.dates as mdates
import matplotlib.units as munits
import matplotlib.pyplot as plt
(fig, ax) = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
(fig, ax) = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
ax.plot(0, 0, 'd')
ax.text(0, 0, ' Float x=0', rotation=45)
(fig, ax) = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
ax.xaxis.set_major_locator(mdates.MonthLocator(bymonth=np.arange(1, 13, 2)))
ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
ax.set_xlabel('1980')
plt.rcParams['date.converter'] = 'concise'
(fig, ax) = plt.subplots(figsize=(5.4, 2), layout='constrained')
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
(fig, axs) = plt.subplots(2, 1, figsize=(5.4, 3), layout='constrained')
for ax in axs.flat:
    time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
    x = np.arange(len(time))
    ax.plot(time, x)
axs[0].set_xlim(np.datetime64('1980-02-01'), np.datetime64('1980-04-01'))
axs[1].set_xlim(3683, 3683 + 60)
data = {'apple': 10, 'orange': 15, 'lemon': 5, 'lime': 20}
names = list(data.keys())
values = list(data.values())
(fig, axs) = plt.subplots(1, 3, figsize=(7, 3), sharey=True, layout='constrained')
axs[0].bar(names, values)
axs[1].scatter(names, values)
axs[2].plot(names, values)
fig.suptitle('Categorical Plotting')
(fig, ax) = plt.subplots(figsize=(5, 3), layout='constrained')
ax.bar(names, values)
ax.scatter(['lemon', 'apple'], [7, 12])
ax.plot(['pear', 'orange', 'apple', 'lemon'], [13, 10, 7, 12], color='C1')
(fig, ax) = plt.subplots(figsize=(5, 3), layout='constrained')
ax.bar(names, values)
args = {'rotation': 70, 'color': 'C1', 'bbox': {'color': 'white', 'alpha': 0.7, 'boxstyle': 'round'}}
ax.plot(0, 2, 'd', color='C1')
ax.text(0, 3, 'Float x=0', **args)
ax.plot(2, 2, 'd', color='C1')
ax.text(2, 3, 'Float x=2', **args)
ax.plot(4, 2, 'd', color='C1')
ax.text(4, 3, 'Float x=4', **args)
ax.plot(2.5, 2, 'd', color='C1')
ax.text(2.5, 3, 'Float x=2.5', **args)
(fig, axs) = plt.subplots(2, 1, figsize=(5, 5), layout='constrained')
ax = axs[0]
ax.bar(names, values)
ax.set_xlim('orange', 'lemon')
ax.set_xlabel('limits set with categories')
ax = axs[1]
ax.bar(names, values)
ax.set_xlim(0.5, 2.5)
ax.set_xlabel('limits set with floats')
(fig, ax) = plt.subplots(figsize=(5.4, 2.5), layout='constrained')
x = [str(xx) for xx in np.arange(100)]
ax.plot(x, np.arange(100))
ax.set_xlabel('x is list of strings')
(fig, ax) = plt.subplots(figsize=(5.4, 2.5), layout='constrained')
x = np.asarray(x, dtype='float')
ax.plot(x, np.arange(100))
ax.set_xlabel('x is array of floats')
(fig, axs) = plt.subplots(3, 1, figsize=(6.4, 7), layout='constrained')
x = np.arange(100)
ax = axs[0]
ax.plot(x, x)
label = f'Converter: {ax.xaxis.converter}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)
ax = axs[1]
time = np.arange('1980-01-01', '1980-06-25', dtype='datetime64[D]')
x = np.arange(len(time))
ax.plot(time, x)
label = f'Converter: {ax.xaxis.converter}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)
ax = axs[2]
data = {'apple': 10, 'orange': 15, 'lemon': 5, 'lime': 20}
names = list(data.keys())
values = list(data.values())
ax.plot(names, values)
label = f'Converter: {ax.xaxis.converter}\n '
label += f'Locator: {ax.xaxis.get_major_locator()}\n'
label += f'Formatter: {ax.xaxis.get_major_formatter()}\n'
ax.set_xlabel(label)
for (k, v) in munits.registry.items():
    print(f'type: {k};\n    converter: {type(v)}')

# File: matplotlib-main/galleries/users_explain/axes/colorbar_placement.py
""""""
import matplotlib.pyplot as plt
import numpy as np
np.random.seed(19680801)
(fig, axs) = plt.subplots(2, 2)
cmaps = ['RdBu_r', 'viridis']
for col in range(2):
    for row in range(2):
        ax = axs[row, col]
        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1), cmap=cmaps[col])
        fig.colorbar(pcm, ax=ax)
(fig, axs) = plt.subplots(2, 2)
cmaps = ['RdBu_r', 'viridis']
for col in range(2):
    for row in range(2):
        ax = axs[row, col]
        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1), cmap=cmaps[col])
    fig.colorbar(pcm, ax=axs[:, col], shrink=0.6)
(fig, axs) = plt.subplots(2, 1, figsize=(4, 5), sharex=True)
X = np.random.randn(20, 20)
axs[0].plot(np.sum(X, axis=0))
pcm = axs[1].pcolormesh(X)
fig.colorbar(pcm, ax=axs[1], shrink=0.6)
(fig, axs) = plt.subplots(2, 1, figsize=(4, 5), sharex=True, layout='constrained')
axs[0].plot(np.sum(X, axis=0))
pcm = axs[1].pcolormesh(X)
fig.colorbar(pcm, ax=axs[1], shrink=0.6)
(fig, axs) = plt.subplots(3, 3, layout='constrained')
for ax in axs.flat:
    pcm = ax.pcolormesh(np.random.random((20, 20)))
fig.colorbar(pcm, ax=axs[0, :2], shrink=0.6, location='bottom')
fig.colorbar(pcm, ax=[axs[0, 2]], location='bottom')
fig.colorbar(pcm, ax=axs[1:, :], location='right', shrink=0.6)
fig.colorbar(pcm, ax=[axs[2, 1]], location='left')
(fig, axs) = plt.subplots(3, 1, layout='constrained', figsize=(5, 5))
for (ax, pad) in zip(axs, [0.025, 0.05, 0.1]):
    pcm = ax.pcolormesh(np.random.randn(20, 20), cmap='viridis')
    fig.colorbar(pcm, ax=ax, pad=pad, label=f'pad: {pad}')
fig.suptitle("layout='constrained'")
(fig, axs) = plt.subplots(3, 1, figsize=(5, 5))
for (ax, pad) in zip(axs, [0.025, 0.05, 0.1]):
    pcm = ax.pcolormesh(np.random.randn(20, 20), cmap='viridis')
    fig.colorbar(pcm, ax=ax, pad=pad, label=f'pad: {pad}')
fig.suptitle('No layout manager')
(fig, ax) = plt.subplots(layout='constrained', figsize=(4, 4))
pcm = ax.pcolormesh(np.random.randn(20, 20), cmap='viridis')
ax.set_ylim([-4, 20])
cax = ax.inset_axes([0.3, 0.07, 0.4, 0.04])
fig.colorbar(pcm, cax=cax, orientation='horizontal')
(fig, ax) = plt.subplots(layout='constrained', figsize=(4, 4))
pcm = ax.pcolormesh(np.random.randn(20, 20), cmap='viridis')
ax.set_ylim([-4, 20])
cax = ax.inset_axes([7.5, -1.7, 5, 1.2], transform=ax.transData)
fig.colorbar(pcm, cax=cax, orientation='horizontal')
(fig, axs) = plt.subplots(2, 2, layout='constrained')
cmaps = ['RdBu_r', 'viridis']
for col in range(2):
    for row in range(2):
        ax = axs[row, col]
        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1), cmap=cmaps[col])
        if col == 0:
            ax.set_aspect(2)
        else:
            ax.set_aspect(1 / 2)
        if row == 1:
            fig.colorbar(pcm, ax=ax, shrink=0.6)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
cmaps = ['RdBu_r', 'viridis']
for col in range(2):
    for row in range(2):
        ax = axs[row, col]
        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1), cmap=cmaps[col])
        if col == 0:
            ax.set_aspect(2)
        else:
            ax.set_aspect(1 / 2)
        if row == 1:
            cax = ax.inset_axes([1.04, 0.2, 0.05, 0.6])
            fig.colorbar(pcm, cax=cax)

# File: matplotlib-main/galleries/users_explain/axes/constrainedlayout_guide.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.colors as mcolors
import matplotlib.gridspec as gridspec
plt.rcParams['savefig.facecolor'] = '0.8'
plt.rcParams['figure.figsize'] = (4.5, 4.0)
plt.rcParams['figure.max_open_warning'] = 50

def example_plot(ax, fontsize=12, hide_labels=False):
    ax.plot([1, 2])
    ax.locator_params(nbins=3)
    if hide_labels:
        ax.set_xticklabels([])
        ax.set_yticklabels([])
    else:
        ax.set_xlabel('x-label', fontsize=fontsize)
        ax.set_ylabel('y-label', fontsize=fontsize)
        ax.set_title('Title', fontsize=fontsize)
(fig, ax) = plt.subplots(layout=None)
example_plot(ax, fontsize=24)
(fig, ax) = plt.subplots(layout='constrained')
example_plot(ax, fontsize=24)
(fig, axs) = plt.subplots(2, 2, layout=None)
for ax in axs.flat:
    example_plot(ax)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
for ax in axs.flat:
    example_plot(ax)
arr = np.arange(100).reshape((10, 10))
norm = mcolors.Normalize(vmin=0.0, vmax=100.0)
pc_kwargs = {'rasterized': True, 'cmap': 'viridis', 'norm': norm}
(fig, ax) = plt.subplots(figsize=(4, 4), layout='constrained')
im = ax.pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=ax, shrink=0.6)
(fig, axs) = plt.subplots(2, 2, figsize=(4, 4), layout='constrained')
for ax in axs.flat:
    im = ax.pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=axs, shrink=0.6)
(fig, axs) = plt.subplots(3, 3, figsize=(4, 4), layout='constrained')
for ax in axs.flat:
    im = ax.pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=axs[1:, 1], shrink=0.8)
fig.colorbar(im, ax=axs[:, -1], shrink=0.6)
(fig, axs) = plt.subplots(2, 2, figsize=(4, 4), layout='constrained')
for ax in axs.flat:
    im = ax.pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=axs, shrink=0.6)
fig.suptitle('Big Suptitle')
(fig, ax) = plt.subplots(layout='constrained')
ax.plot(np.arange(10), label='This is a plot')
ax.legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
(fig, axs) = plt.subplots(1, 2, figsize=(4, 2), layout='constrained')
axs[0].plot(np.arange(10))
axs[1].plot(np.arange(10), label='This is a plot')
axs[1].legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
(fig, axs) = plt.subplots(1, 2, figsize=(4, 2), layout='constrained')
axs[0].plot(np.arange(10))
axs[1].plot(np.arange(10), label='This is a plot')
leg = axs[1].legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
leg.set_in_layout(False)
fig.canvas.draw()
leg.set_in_layout(True)
fig.set_layout_engine('none')
try:
    fig.savefig('../../../doc/_static/constrained_layout_1b.png', bbox_inches='tight', dpi=100)
except FileNotFoundError:
    pass
(fig, axs) = plt.subplots(1, 2, figsize=(4, 2), layout='constrained')
axs[0].plot(np.arange(10))
lines = axs[1].plot(np.arange(10), label='This is a plot')
labels = [l.get_label() for l in lines]
leg = fig.legend(lines, labels, loc='center left', bbox_to_anchor=(0.8, 0.5), bbox_transform=axs[1].transAxes)
try:
    fig.savefig('../../../doc/_static/constrained_layout_2b.png', bbox_inches='tight', dpi=100)
except FileNotFoundError:
    pass
(fig, axs) = plt.subplots(2, 2, layout='constrained')
for ax in axs.flat:
    example_plot(ax, hide_labels=True)
fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0, wspace=0)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
for ax in axs.flat:
    example_plot(ax, hide_labels=True)
fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.2, wspace=0.2)
(fig, axs) = plt.subplots(2, 3, layout='constrained')
for ax in axs.flat:
    example_plot(ax, hide_labels=True)
fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.2, wspace=0.2)
(fig, axs) = plt.subplots(2, 2, layout='constrained', gridspec_kw={'wspace': 0.3, 'hspace': 0.2})
for ax in axs.flat:
    example_plot(ax, hide_labels=True)
fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.0, wspace=0.0)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
pads = [0, 0.05, 0.1, 0.2]
for (pad, ax) in zip(pads, axs.flat):
    pc = ax.pcolormesh(arr, **pc_kwargs)
    fig.colorbar(pc, ax=ax, shrink=0.6, pad=pad)
    ax.set_xticklabels([])
    ax.set_yticklabels([])
    ax.set_title(f'pad: {pad}')
fig.get_layout_engine().set(w_pad=2 / 72, h_pad=2 / 72, hspace=0.2, wspace=0.2)
plt.rcParams['figure.constrained_layout.use'] = True
(fig, axs) = plt.subplots(2, 2, figsize=(3, 3))
for ax in axs.flat:
    example_plot(ax)
plt.rcParams['figure.constrained_layout.use'] = False
fig = plt.figure(layout='constrained')
gs1 = gridspec.GridSpec(2, 1, figure=fig)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])
example_plot(ax1)
example_plot(ax2)
fig = plt.figure(layout='constrained')
gs0 = fig.add_gridspec(1, 2)
gs1 = gs0[0].subgridspec(2, 1)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])
example_plot(ax1)
example_plot(ax2)
gs2 = gs0[1].subgridspec(3, 1)
for ss in gs2:
    ax = fig.add_subplot(ss)
    example_plot(ax)
    ax.set_title('')
    ax.set_xlabel('')
ax.set_xlabel('x-label', fontsize=12)
fig = plt.figure(figsize=(4, 6), layout='constrained')
gs0 = fig.add_gridspec(6, 2)
ax1 = fig.add_subplot(gs0[:3, 0])
ax2 = fig.add_subplot(gs0[3:, 0])
example_plot(ax1)
example_plot(ax2)
ax = fig.add_subplot(gs0[0:2, 1])
example_plot(ax, hide_labels=True)
ax = fig.add_subplot(gs0[2:4, 1])
example_plot(ax, hide_labels=True)
ax = fig.add_subplot(gs0[4:, 1])
example_plot(ax, hide_labels=True)
fig.suptitle('Overlapping Gridspecs')
fig = plt.figure(layout='constrained')
gs0 = fig.add_gridspec(1, 2, figure=fig, width_ratios=[1, 2])
gs_left = gs0[0].subgridspec(2, 1)
gs_right = gs0[1].subgridspec(2, 2)
for gs in gs_left:
    ax = fig.add_subplot(gs)
    example_plot(ax)
axs = []
for gs in gs_right:
    ax = fig.add_subplot(gs)
    pcm = ax.pcolormesh(arr, **pc_kwargs)
    ax.set_xlabel('x-label')
    ax.set_ylabel('y-label')
    ax.set_title('title')
    axs += [ax]
fig.suptitle('Nested plots using subgridspec')
fig.colorbar(pcm, ax=axs)
fig = plt.figure(layout='constrained')
sfigs = fig.subfigures(1, 2, width_ratios=[1, 2])
axs_left = sfigs[0].subplots(2, 1)
for ax in axs_left.flat:
    example_plot(ax)
axs_right = sfigs[1].subplots(2, 2)
for ax in axs_right.flat:
    pcm = ax.pcolormesh(arr, **pc_kwargs)
    ax.set_xlabel('x-label')
    ax.set_ylabel('y-label')
    ax.set_title('title')
fig.colorbar(pcm, ax=axs_right)
fig.suptitle('Nested plots using subfigures')
(fig, axs) = plt.subplots(1, 2, layout='constrained')
example_plot(axs[0], fontsize=12)
axs[1].set_position([0.2, 0.2, 0.4, 0.4])
(fig, axs) = plt.subplots(2, 2, figsize=(5, 3), sharex=True, sharey=True, layout='constrained')
for ax in axs.flat:
    ax.imshow(arr)
fig.suptitle("fixed-aspect plots, layout='constrained'")
(fig, axs) = plt.subplots(2, 2, figsize=(5, 3), sharex=True, sharey=True, layout='compressed')
for ax in axs.flat:
    ax.imshow(arr)
fig.suptitle("fixed-aspect plots, layout='compressed'")
fig = plt.figure(layout='constrained')
ax1 = plt.subplot(2, 2, 1)
ax2 = plt.subplot(2, 2, 3)
ax3 = plt.subplot(2, 2, (2, 4))
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
plt.suptitle('Homogenous nrows, ncols')
fig = plt.figure(layout='constrained')
ax1 = plt.subplot(2, 2, 1)
ax2 = plt.subplot(2, 2, 3)
ax3 = plt.subplot(1, 2, 2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
plt.suptitle('Mixed nrows, ncols')
fig = plt.figure(layout='constrained')
ax1 = plt.subplot2grid((3, 3), (0, 0))
ax2 = plt.subplot2grid((3, 3), (0, 1), colspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
ax4 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
fig.suptitle('subplot2grid')
from matplotlib._layoutgrid import plot_children
(fig, ax) = plt.subplots(layout='constrained')
example_plot(ax, fontsize=24)
plot_children(fig)
(fig, ax) = plt.subplots(1, 2, layout='constrained')
example_plot(ax[0], fontsize=32)
example_plot(ax[1], fontsize=8)
plot_children(fig)
(fig, ax) = plt.subplots(1, 2, layout='constrained')
im = ax[0].pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=ax[0], shrink=0.6)
im = ax[1].pcolormesh(arr, **pc_kwargs)
plot_children(fig)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
for ax in axs.flat:
    im = ax.pcolormesh(arr, **pc_kwargs)
fig.colorbar(im, ax=axs, shrink=0.6)
plot_children(fig)
fig = plt.figure(layout='constrained')
gs = gridspec.GridSpec(2, 2, figure=fig)
ax = fig.add_subplot(gs[:, 0])
im = ax.pcolormesh(arr, **pc_kwargs)
ax = fig.add_subplot(gs[0, 1])
im = ax.pcolormesh(arr, **pc_kwargs)
ax = fig.add_subplot(gs[1, 1])
im = ax.pcolormesh(arr, **pc_kwargs)
plot_children(fig)
fig = plt.figure(layout='constrained')
gs = fig.add_gridspec(2, 4)
ax00 = fig.add_subplot(gs[0, 0:2])
ax01 = fig.add_subplot(gs[0, 2:])
ax10 = fig.add_subplot(gs[1, 1:3])
example_plot(ax10, fontsize=14)
plot_children(fig)
plt.show()

# File: matplotlib-main/galleries/users_explain/axes/legend_guide.py
""""""
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
(fig, ax) = plt.subplots()
red_patch = mpatches.Patch(color='red', label='The red data')
ax.legend(handles=[red_patch])
plt.show()
import matplotlib.lines as mlines
(fig, ax) = plt.subplots()
blue_line = mlines.Line2D([], [], color='blue', marker='*', markersize=15, label='Blue stars')
ax.legend(handles=[blue_line])
plt.show()
(fig, ax_dict) = plt.subplot_mosaic([['top', 'top'], ['bottom', 'BLANK']], empty_sentinel='BLANK')
ax_dict['top'].plot([1, 2, 3], label='test1')
ax_dict['top'].plot([3, 2, 1], label='test2')
ax_dict['top'].legend(bbox_to_anchor=(0.0, 1.02, 1.0, 0.102), loc='lower left', ncols=2, mode='expand', borderaxespad=0.0)
ax_dict['bottom'].plot([1, 2, 3], label='test1')
ax_dict['bottom'].plot([3, 2, 1], label='test2')
ax_dict['bottom'].legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.0)
(fig, axs) = plt.subplot_mosaic([['left', 'right']], layout='constrained')
axs['left'].plot([1, 2, 3], label='test1')
axs['left'].plot([3, 2, 1], label='test2')
axs['right'].plot([1, 2, 3], 'C2', label='test3')
axs['right'].plot([3, 2, 1], 'C3', label='test4')
fig.legend(loc='outside upper right')
ucl = ['upper', 'center', 'lower']
lcr = ['left', 'center', 'right']
(fig, ax) = plt.subplots(figsize=(6, 4), layout='constrained', facecolor='0.7')
ax.plot([1, 2], [1, 2], label='TEST')
for loc in ['outside upper left', 'outside upper center', 'outside upper right', 'outside lower left', 'outside lower center', 'outside lower right']:
    fig.legend(loc=loc, title=loc)
(fig, ax) = plt.subplots(figsize=(6, 4), layout='constrained', facecolor='0.7')
ax.plot([1, 2], [1, 2], label='test')
for loc in ['outside left upper', 'outside right upper', 'outside left lower', 'outside right lower']:
    fig.legend(loc=loc, title=loc)
(fig, ax) = plt.subplots()
(line1,) = ax.plot([1, 2, 3], label='Line 1', linestyle='--')
(line2,) = ax.plot([3, 2, 1], label='Line 2', linewidth=4)
first_legend = ax.legend(handles=[line1], loc='upper right')
ax.add_artist(first_legend)
ax.legend(handles=[line2], loc='lower right')
plt.show()
from matplotlib.legend_handler import HandlerLine2D
(fig, ax) = plt.subplots()
(line1,) = ax.plot([3, 2, 1], marker='o', label='Line 1')
(line2,) = ax.plot([1, 2, 3], marker='o', label='Line 2')
ax.legend(handler_map={line1: HandlerLine2D(numpoints=4)}, handlelength=4)
from numpy.random import randn
z = randn(10)
(fig, ax) = plt.subplots()
(red_dot,) = ax.plot(z, 'ro', markersize=15)
(white_cross,) = ax.plot(z[:5], 'w+', markeredgewidth=3, markersize=15)
ax.legend([red_dot, (red_dot, white_cross)], ['Attr A', 'Attr A+B'])
from matplotlib.legend_handler import HandlerLine2D, HandlerTuple
(fig, ax) = plt.subplots()
(p1,) = ax.plot([1, 2.5, 3], 'r-d')
(p2,) = ax.plot([3, 2, 1], 'k-o')
l = ax.legend([(p1, p2)], ['Two keys'], numpoints=1, handler_map={tuple: HandlerTuple(ndivide=None)})
import matplotlib.patches as mpatches

class AnyObject:
    pass

class AnyObjectHandler:

    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
        (x0, y0) = (handlebox.xdescent, handlebox.ydescent)
        (width, height) = (handlebox.width, handlebox.height)
        patch = mpatches.Rectangle([x0, y0], width, height, facecolor='red', edgecolor='black', hatch='xx', lw=3, transform=handlebox.get_transform())
        handlebox.add_artist(patch)
        return patch
(fig, ax) = plt.subplots()
ax.legend([AnyObject()], ['My first handler'], handler_map={AnyObject: AnyObjectHandler()})
from matplotlib.legend_handler import HandlerPatch

class HandlerEllipse(HandlerPatch):

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        center = (0.5 * width - 0.5 * xdescent, 0.5 * height - 0.5 * ydescent)
        p = mpatches.Ellipse(xy=center, width=width + xdescent, height=height + ydescent)
        self.update_prop(p, orig_handle, legend)
        p.set_transform(trans)
        return [p]
c = mpatches.Circle((0.5, 0.5), 0.25, facecolor='green', edgecolor='red', linewidth=3)
(fig, ax) = plt.subplots()
ax.add_patch(c)
ax.legend([c], ['An ellipse, not a rectangle'], handler_map={mpatches.Circle: HandlerEllipse()})

# File: matplotlib-main/galleries/users_explain/axes/mosaic.py
""""""
import matplotlib.pyplot as plt
import numpy as np

def identify_axes(ax_dict, fontsize=48):
    kw = dict(ha='center', va='center', fontsize=fontsize, color='darkgrey')
    for (k, ax) in ax_dict.items():
        ax.text(0.5, 0.5, k, transform=ax.transAxes, **kw)
np.random.seed(19680801)
hist_data = np.random.randn(1500)
fig = plt.figure(layout='constrained')
ax_array = fig.subplots(2, 2, squeeze=False)
ax_array[0, 0].bar(['a', 'b', 'c'], [5, 7, 9])
ax_array[0, 1].plot([1, 2, 3])
ax_array[1, 0].hist(hist_data, bins='auto')
ax_array[1, 1].imshow([[1, 2], [2, 1]])
identify_axes({(j, k): a for (j, r) in enumerate(ax_array) for (k, a) in enumerate(r)})
fig = plt.figure(layout='constrained')
ax_dict = fig.subplot_mosaic([['bar', 'plot'], ['hist', 'image']])
ax_dict['bar'].bar(['a', 'b', 'c'], [5, 7, 9])
ax_dict['plot'].plot([1, 2, 3])
ax_dict['hist'].hist(hist_data)
ax_dict['image'].imshow([[1, 2], [2, 1]])
identify_axes(ax_dict)
print(ax_dict)
mosaic = '\n    AB\n    CD\n    '
fig = plt.figure(layout='constrained')
ax_dict = fig.subplot_mosaic(mosaic)
identify_axes(ax_dict)
mosaic = 'AB;CD'
fig = plt.figure(layout='constrained')
ax_dict = fig.subplot_mosaic(mosaic)
identify_axes(ax_dict)
axd = plt.figure(layout='constrained').subplot_mosaic('\n    ABD\n    CCD\n    ')
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('\n    A.C\n    BBB\n    .D.\n    ')
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('\n    aX\n    Xb\n    ', empty_sentinel='X')
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('αб\n       ℝ☢')
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('\n    .a.\n    bAc\n    .d.\n    ', height_ratios=[1, 3.5, 1], width_ratios=[1, 3.5, 1])
identify_axes(axd)
mosaic = 'AA\n            BC'
fig = plt.figure()
axd = fig.subplot_mosaic(mosaic, gridspec_kw={'bottom': 0.25, 'top': 0.95, 'left': 0.1, 'right': 0.5, 'wspace': 0.5, 'hspace': 0.5})
identify_axes(axd)
axd = fig.subplot_mosaic(mosaic, gridspec_kw={'bottom': 0.05, 'top': 0.75, 'left': 0.6, 'right': 0.95, 'wspace': 0.5, 'hspace': 0.5})
identify_axes(axd)
mosaic = 'AA\n            BC'
fig = plt.figure(layout='constrained')
(left, right) = fig.subfigures(nrows=1, ncols=2)
axd = left.subplot_mosaic(mosaic)
identify_axes(axd)
axd = right.subplot_mosaic(mosaic)
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('AB', subplot_kw={'projection': 'polar'})
identify_axes(axd)
(fig, axd) = plt.subplot_mosaic('AB;CD', per_subplot_kw={'A': {'projection': 'polar'}, ('C', 'D'): {'xscale': 'log'}})
identify_axes(axd)
(fig, axd) = plt.subplot_mosaic('AB;CD', per_subplot_kw={'AD': {'projection': 'polar'}, 'BC': {'facecolor': '.9'}})
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic('AB;CD', subplot_kw={'facecolor': 'xkcd:tangerine'}, per_subplot_kw={'B': {'facecolor': 'xkcd:water blue'}, 'D': {'projection': 'polar', 'facecolor': 'w'}})
identify_axes(axd)
axd = plt.figure(layout='constrained').subplot_mosaic([['main', 'zoom'], ['main', 'BLANK']], empty_sentinel='BLANK', width_ratios=[2, 1])
identify_axes(axd)
inner = [['inner A'], ['inner B']]
outer_nested_mosaic = [['main', inner], ['bottom', 'bottom']]
axd = plt.figure(layout='constrained').subplot_mosaic(outer_nested_mosaic, empty_sentinel=None)
identify_axes(axd, fontsize=36)
mosaic = np.zeros((4, 4), dtype=int)
for j in range(4):
    mosaic[j, j] = j + 1
axd = plt.figure(layout='constrained').subplot_mosaic(mosaic, empty_sentinel=0)
identify_axes(axd)

# File: matplotlib-main/galleries/users_explain/axes/tight_layout_guide.py
""""""
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['savefig.facecolor'] = '0.8'

def example_plot(ax, fontsize=12):
    ax.plot([1, 2])
    ax.locator_params(nbins=3)
    ax.set_xlabel('x-label', fontsize=fontsize)
    ax.set_ylabel('y-label', fontsize=fontsize)
    ax.set_title('Title', fontsize=fontsize)
plt.close('all')
(fig, ax) = plt.subplots()
example_plot(ax, fontsize=24)
(fig, ax) = plt.subplots()
example_plot(ax, fontsize=24)
plt.tight_layout()
plt.close('all')
(fig, ((ax1, ax2), (ax3, ax4))) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
(fig, ((ax1, ax2), (ax3, ax4))) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
plt.tight_layout()
(fig, ((ax1, ax2), (ax3, ax4))) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)
plt.close('all')
fig = plt.figure()
ax1 = plt.subplot(221)
ax2 = plt.subplot(223)
ax3 = plt.subplot(122)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
plt.tight_layout()
plt.close('all')
fig = plt.figure()
ax1 = plt.subplot2grid((3, 3), (0, 0))
ax2 = plt.subplot2grid((3, 3), (0, 1), colspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
ax4 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
plt.tight_layout()
arr = np.arange(100).reshape((10, 10))
plt.close('all')
fig = plt.figure(figsize=(5, 4))
ax = plt.subplot()
im = ax.imshow(arr, interpolation='none')
plt.tight_layout()
import matplotlib.gridspec as gridspec
plt.close('all')
fig = plt.figure()
gs1 = gridspec.GridSpec(2, 1)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])
example_plot(ax1)
example_plot(ax2)
gs1.tight_layout(fig)
fig = plt.figure()
gs1 = gridspec.GridSpec(2, 1)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])
example_plot(ax1)
example_plot(ax2)
gs1.tight_layout(fig, rect=[0, 0, 0.5, 1.0])
(fig, ax) = plt.subplots(figsize=(4, 3))
lines = ax.plot(range(10), label='A simple plot')
ax.legend(bbox_to_anchor=(0.7, 0.5), loc='center left')
fig.tight_layout()
plt.show()
(fig, ax) = plt.subplots(figsize=(4, 3))
lines = ax.plot(range(10), label='B simple plot')
leg = ax.legend(bbox_to_anchor=(0.7, 0.5), loc='center left')
leg.set_in_layout(False)
fig.tight_layout()
plt.show()
from mpl_toolkits.axes_grid1 import Grid
plt.close('all')
fig = plt.figure()
grid = Grid(fig, rect=111, nrows_ncols=(2, 2), axes_pad=0.25, label_mode='L')
for ax in grid:
    example_plot(ax)
ax.title.set_visible(False)
plt.tight_layout()
plt.close('all')
arr = np.arange(100).reshape((10, 10))
fig = plt.figure(figsize=(4, 4))
im = plt.imshow(arr, interpolation='none')
plt.colorbar(im)
plt.tight_layout()
from mpl_toolkits.axes_grid1 import make_axes_locatable
plt.close('all')
arr = np.arange(100).reshape((10, 10))
fig = plt.figure(figsize=(4, 4))
im = plt.imshow(arr, interpolation='none')
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', '5%', pad='3%')
plt.colorbar(im, cax=cax)
plt.tight_layout()

# File: matplotlib-main/galleries/users_explain/colors/colorbar_only.py
""""""
import matplotlib.pyplot as plt
import matplotlib as mpl
(fig, ax) = plt.subplots(figsize=(6, 1), layout='constrained')
cmap = mpl.cm.cool
norm = mpl.colors.Normalize(vmin=5, vmax=10)
fig.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap), cax=ax, orientation='horizontal', label='Some Units')
(fig, ax) = plt.subplots(layout='constrained')
fig.colorbar(mpl.cm.ScalarMappable(norm=mpl.colors.Normalize(0, 1), cmap='magma'), ax=ax, orientation='vertical', label='a colorbar label')
(fig, ax) = plt.subplots(figsize=(6, 1), layout='constrained')
cmap = mpl.cm.viridis
bounds = [-1, 2, 5, 7, 12, 15]
norm = mpl.colors.BoundaryNorm(bounds, cmap.N, extend='both')
fig.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap), cax=ax, orientation='horizontal', label="Discrete intervals with extend='both' keyword")
(fig, ax) = plt.subplots(figsize=(6, 1), layout='constrained')
cmap = mpl.colors.ListedColormap(['red', 'green', 'blue', 'cyan']).with_extremes(under='yellow', over='magenta')
bounds = [1, 2, 4, 7, 8]
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
fig.colorbar(mpl.cm.ScalarMappable(cmap=cmap, norm=norm), cax=ax, orientation='horizontal', extend='both', spacing='proportional', label='Discrete intervals, some other units')
(fig, ax) = plt.subplots(figsize=(6, 1), layout='constrained')
cmap = mpl.colors.ListedColormap(['royalblue', 'cyan', 'yellow', 'orange']).with_extremes(over='red', under='blue')
bounds = [-1.0, -0.5, 0.0, 0.5, 1.0]
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
fig.colorbar(mpl.cm.ScalarMappable(cmap=cmap, norm=norm), cax=ax, orientation='horizontal', extend='both', extendfrac='auto', spacing='uniform', label='Custom extension lengths, some other units')
plt.show()

# File: matplotlib-main/galleries/users_explain/colors/colormap-manipulation.py
""""""
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
from matplotlib.colors import LinearSegmentedColormap, ListedColormap
viridis = mpl.colormaps['viridis'].resampled(8)
print(viridis(0.56))
print('viridis.colors', viridis.colors)
print('viridis(range(8))', viridis(range(8)))
print('viridis(np.linspace(0, 1, 8))', viridis(np.linspace(0, 1, 8)))
print('viridis(np.linspace(0, 1, 12))', viridis(np.linspace(0, 1, 12)))
copper = mpl.colormaps['copper'].resampled(8)
print('copper(range(8))', copper(range(8)))
print('copper(np.linspace(0, 1, 8))', copper(np.linspace(0, 1, 8)))

def plot_examples(colormaps):
    np.random.seed(19680801)
    data = np.random.randn(30, 30)
    n = len(colormaps)
    (fig, axs) = plt.subplots(1, n, figsize=(n * 2 + 2, 3), layout='constrained', squeeze=False)
    for [ax, cmap] in zip(axs.flat, colormaps):
        psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)
        fig.colorbar(psm, ax=ax)
    plt.show()
cmap = ListedColormap(['darkorange', 'gold', 'lawngreen', 'lightseagreen'])
plot_examples([cmap])
viridis = mpl.colormaps['viridis'].resampled(256)
newcolors = viridis(np.linspace(0, 1, 256))
pink = np.array([248 / 256, 24 / 256, 148 / 256, 1])
newcolors[:25, :] = pink
newcmp = ListedColormap(newcolors)
plot_examples([viridis, newcmp])
viridis_big = mpl.colormaps['viridis']
newcmp = ListedColormap(viridis_big(np.linspace(0.25, 0.75, 128)))
plot_examples([viridis, newcmp])
top = mpl.colormaps['Oranges_r'].resampled(128)
bottom = mpl.colormaps['Blues'].resampled(128)
newcolors = np.vstack((top(np.linspace(0, 1, 128)), bottom(np.linspace(0, 1, 128))))
newcmp = ListedColormap(newcolors, name='OrangeBlue')
plot_examples([viridis, newcmp])
N = 256
vals = np.ones((N, 4))
vals[:, 0] = np.linspace(90 / 256, 1, N)
vals[:, 1] = np.linspace(40 / 256, 1, N)
vals[:, 2] = np.linspace(40 / 256, 1, N)
newcmp = ListedColormap(vals)
plot_examples([viridis, newcmp])
cdict = {'red': [[0.0, 0.0, 0.0], [0.5, 1.0, 1.0], [1.0, 1.0, 1.0]], 'green': [[0.0, 0.0, 0.0], [0.25, 0.0, 0.0], [0.75, 1.0, 1.0], [1.0, 1.0, 1.0]], 'blue': [[0.0, 0.0, 0.0], [0.5, 0.0, 0.0], [1.0, 1.0, 1.0]]}

def plot_linearmap(cdict):
    newcmp = LinearSegmentedColormap('testCmap', segmentdata=cdict, N=256)
    rgba = newcmp(np.linspace(0, 1, 256))
    (fig, ax) = plt.subplots(figsize=(4, 3), layout='constrained')
    col = ['r', 'g', 'b']
    for xx in [0.25, 0.5, 0.75]:
        ax.axvline(xx, color='0.7', linestyle='--')
    for i in range(3):
        ax.plot(np.arange(256) / 256, rgba[:, i], color=col[i])
    ax.set_xlabel('index')
    ax.set_ylabel('RGB')
    plt.show()
plot_linearmap(cdict)
cdict['red'] = [[0.0, 0.0, 0.3], [0.5, 1.0, 0.9], [1.0, 1.0, 1.0]]
plot_linearmap(cdict)
colors = ['darkorange', 'gold', 'lawngreen', 'lightseagreen']
cmap1 = LinearSegmentedColormap.from_list('mycmap', colors)
nodes = [0.0, 0.4, 0.8, 1.0]
cmap2 = LinearSegmentedColormap.from_list('mycmap', list(zip(nodes, colors)))
plot_examples([cmap1, cmap2])
colors = ['#ffffcc', '#a1dab4', '#41b6c4', '#2c7fb8', '#253494']
my_cmap = ListedColormap(colors, name='my_cmap')
my_cmap_r = my_cmap.reversed()
plot_examples([my_cmap, my_cmap_r])
mpl.colormaps.register(cmap=my_cmap)
mpl.colormaps.register(cmap=my_cmap_r)
data = [[1, 2, 3, 4, 5]]
(fig, (ax1, ax2)) = plt.subplots(nrows=2)
ax1.imshow(data, cmap='my_cmap')
ax2.imshow(data, cmap='my_cmap_r')
plt.show()

# File: matplotlib-main/galleries/users_explain/colors/colormapnorms.py
""""""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm
import matplotlib.cbook as cbook
import matplotlib.colors as colors
N = 100
(X, Y) = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X ** 2 - Y ** 2)
Z2 = np.exp(-(X * 10) ** 2 - (Y * 10) ** 2)
Z = Z1 + 50 * Z2
(fig, ax) = plt.subplots(2, 1)
pcm = ax[0].pcolor(X, Y, Z, norm=colors.LogNorm(vmin=Z.min(), vmax=Z.max()), cmap='PuBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolor(X, Y, Z, cmap='PuBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[1], extend='max')
plt.show()
delta = 0.1
x = np.arange(-3.0, 4.001, delta)
y = np.arange(-4.0, 3.001, delta)
(X, Y) = np.meshgrid(x, y)
Z1 = np.exp(-X ** 2 - Y ** 2)
Z2 = np.exp(-(X - 1) ** 2 - (Y - 1) ** 2)
Z = (0.9 * Z1 - 0.5 * Z2) * 2
cmap = cm.coolwarm
(fig, (ax1, ax2)) = plt.subplots(ncols=2)
pc = ax1.pcolormesh(Z, cmap=cmap)
fig.colorbar(pc, ax=ax1)
ax1.set_title('Normalize()')
pc = ax2.pcolormesh(Z, norm=colors.CenteredNorm(), cmap=cmap)
fig.colorbar(pc, ax=ax2)
ax2.set_title('CenteredNorm()')
plt.show()
N = 100
(X, Y) = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X ** 2 - Y ** 2)
Z2 = np.exp(-(X - 1) ** 2 - (Y - 1) ** 2)
Z = (Z1 - Z2) * 2
(fig, ax) = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X, Y, Z, norm=colors.SymLogNorm(linthresh=0.03, linscale=0.03, vmin=-1.0, vmax=1.0, base=10), cmap='RdBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[0], extend='both')
pcm = ax[1].pcolormesh(X, Y, Z, cmap='RdBu_r', vmin=-np.max(Z), shading='auto')
fig.colorbar(pcm, ax=ax[1], extend='both')
plt.show()
N = 100
(X, Y) = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.0)) * X ** 2
(fig, ax) = plt.subplots(2, 1, layout='constrained')
pcm = ax[0].pcolormesh(X, Y, Z1, norm=colors.PowerNorm(gamma=0.5), cmap='PuBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[0], extend='max')
ax[0].set_title('PowerNorm()')
pcm = ax[1].pcolormesh(X, Y, Z1, cmap='PuBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[1], extend='max')
ax[1].set_title('Normalize()')
plt.show()
N = 100
(X, Y) = np.meshgrid(np.linspace(-3, 3, N), np.linspace(-2, 2, N))
Z1 = np.exp(-X ** 2 - Y ** 2)
Z2 = np.exp(-(X - 1) ** 2 - (Y - 1) ** 2)
Z = ((Z1 - Z2) * 2)[:-1, :-1]
(fig, ax) = plt.subplots(2, 2, figsize=(8, 6), layout='constrained')
ax = ax.flatten()
pcm = ax[0].pcolormesh(X, Y, Z, cmap='RdBu_r')
fig.colorbar(pcm, ax=ax[0], orientation='vertical')
ax[0].set_title('Default norm')
bounds = np.linspace(-1.5, 1.5, 7)
norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)
pcm = ax[1].pcolormesh(X, Y, Z, norm=norm, cmap='RdBu_r')
fig.colorbar(pcm, ax=ax[1], extend='both', orientation='vertical')
ax[1].set_title('BoundaryNorm: 7 boundaries')
bounds = np.array([-0.2, -0.1, 0, 0.5, 1])
norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)
pcm = ax[2].pcolormesh(X, Y, Z, norm=norm, cmap='RdBu_r')
fig.colorbar(pcm, ax=ax[2], extend='both', orientation='vertical')
ax[2].set_title('BoundaryNorm: nonuniform')
bounds = np.linspace(-1.5, 1.5, 7)
norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256, extend='both')
pcm = ax[3].pcolormesh(X, Y, Z, norm=norm, cmap='RdBu_r')
fig.colorbar(pcm, ax=ax[3], orientation='vertical')
ax[3].set_title('BoundaryNorm: extend="both"')
plt.show()
dem = cbook.get_sample_data('topobathy.npz')
topo = dem['topo']
longitude = dem['longitude']
latitude = dem['latitude']
(fig, ax) = plt.subplots()
colors_undersea = plt.cm.terrain(np.linspace(0, 0.17, 256))
colors_land = plt.cm.terrain(np.linspace(0.25, 1, 256))
all_colors = np.vstack((colors_undersea, colors_land))
terrain_map = colors.LinearSegmentedColormap.from_list('terrain_map', all_colors)
divnorm = colors.TwoSlopeNorm(vmin=-500.0, vcenter=0, vmax=4000)
pcm = ax.pcolormesh(longitude, latitude, topo, rasterized=True, norm=divnorm, cmap=terrain_map, shading='auto')
ax.set_aspect(1 / np.cos(np.deg2rad(49)))
ax.set_title('TwoSlopeNorm(x)')
cb = fig.colorbar(pcm, shrink=0.6)
cb.set_ticks([-500, 0, 1000, 2000, 3000, 4000])
plt.show()

def _forward(x):
    return np.sqrt(x)

def _inverse(x):
    return x ** 2
N = 100
(X, Y) = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.0)) * X ** 2
(fig, ax) = plt.subplots()
norm = colors.FuncNorm((_forward, _inverse), vmin=0, vmax=20)
pcm = ax.pcolormesh(X, Y, Z1, norm=norm, cmap='PuBu_r', shading='auto')
ax.set_title('FuncNorm(x)')
fig.colorbar(pcm, shrink=0.6)
plt.show()

class MidpointNormalize(colors.Normalize):

    def __init__(self, vmin=None, vmax=None, vcenter=None, clip=False):
        self.vcenter = vcenter
        super().__init__(vmin, vmax, clip)

    def __call__(self, value, clip=None):
        (x, y) = ([self.vmin, self.vcenter, self.vmax], [0, 0.5, 1.0])
        return np.ma.masked_array(np.interp(value, x, y, left=-np.inf, right=np.inf))

    def inverse(self, value):
        (y, x) = ([self.vmin, self.vcenter, self.vmax], [0, 0.5, 1])
        return np.interp(value, x, y, left=-np.inf, right=np.inf)
(fig, ax) = plt.subplots()
midnorm = MidpointNormalize(vmin=-500.0, vcenter=0, vmax=4000)
pcm = ax.pcolormesh(longitude, latitude, topo, rasterized=True, norm=midnorm, cmap=terrain_map, shading='auto')
ax.set_aspect(1 / np.cos(np.deg2rad(49)))
ax.set_title('Custom norm')
cb = fig.colorbar(pcm, shrink=0.6, extend='both')
cb.set_ticks([-500, 0, 1000, 2000, 3000, 4000])
plt.show()

# File: matplotlib-main/galleries/users_explain/colors/colormaps.py
""""""
from colorspacious import cspace_converter
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
cmaps = {}
gradient = np.linspace(0, 1, 256)
gradient = np.vstack((gradient, gradient))

def plot_color_gradients(category, cmap_list):
    nrows = len(cmap_list)
    figh = 0.35 + 0.15 + (nrows + (nrows - 1) * 0.1) * 0.22
    (fig, axs) = plt.subplots(nrows=nrows + 1, figsize=(6.4, figh))
    fig.subplots_adjust(top=1 - 0.35 / figh, bottom=0.15 / figh, left=0.2, right=0.99)
    axs[0].set_title(f'{category} colormaps', fontsize=14)
    for (ax, name) in zip(axs, cmap_list):
        ax.imshow(gradient, aspect='auto', cmap=mpl.colormaps[name])
        ax.text(-0.01, 0.5, name, va='center', ha='right', fontsize=10, transform=ax.transAxes)
    for ax in axs:
        ax.set_axis_off()
    cmaps[category] = cmap_list
plot_color_gradients('Perceptually Uniform Sequential', ['viridis', 'plasma', 'inferno', 'magma', 'cividis'])
plot_color_gradients('Sequential', ['Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds', 'YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu', 'GnBu', 'PuBu', 'YlGnBu', 'PuBuGn', 'BuGn', 'YlGn'])
plot_color_gradients('Sequential (2)', ['binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink', 'spring', 'summer', 'autumn', 'winter', 'cool', 'Wistia', 'hot', 'afmhot', 'gist_heat', 'copper'])
plot_color_gradients('Diverging', ['PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu', 'RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic', 'berlin', 'managua', 'vanimo'])
plot_color_gradients('Cyclic', ['twilight', 'twilight_shifted', 'hsv'])
plot_color_gradients('Qualitative', ['Pastel1', 'Pastel2', 'Paired', 'Accent', 'Dark2', 'Set1', 'Set2', 'Set3', 'tab10', 'tab20', 'tab20b', 'tab20c'])
plot_color_gradients('Miscellaneous', ['flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern', 'gnuplot', 'gnuplot2', 'CMRmap', 'cubehelix', 'brg', 'gist_rainbow', 'rainbow', 'jet', 'turbo', 'nipy_spectral', 'gist_ncar'])
plt.show()
mpl.rcParams.update({'font.size': 12})
_DSUBS = {'Perceptually Uniform Sequential': 5, 'Sequential': 6, 'Sequential (2)': 6, 'Diverging': 6, 'Cyclic': 3, 'Qualitative': 4, 'Miscellaneous': 6}
_DC = {'Perceptually Uniform Sequential': 1.4, 'Sequential': 0.7, 'Sequential (2)': 1.4, 'Diverging': 1.4, 'Cyclic': 1.4, 'Qualitative': 1.4, 'Miscellaneous': 1.4}
x = np.linspace(0.0, 1.0, 100)
for (cmap_category, cmap_list) in cmaps.items():
    dsub = _DSUBS.get(cmap_category, 6)
    nsubplots = int(np.ceil(len(cmap_list) / dsub))
    (fig, axs) = plt.subplots(nrows=nsubplots, squeeze=False, figsize=(7, 2.6 * nsubplots))
    for (i, ax) in enumerate(axs.flat):
        locs = []
        for (j, cmap) in enumerate(cmap_list[i * dsub:(i + 1) * dsub]):
            rgb = mpl.colormaps[cmap](x)[np.newaxis, :, :3]
            lab = cspace_converter('sRGB1', 'CAM02-UCS')(rgb)
            if cmap_category == 'Sequential':
                y_ = lab[0, ::-1, 0]
                c_ = x[::-1]
            else:
                y_ = lab[0, :, 0]
                c_ = x
            dc = _DC.get(cmap_category, 1.4)
            ax.scatter(x + j * dc, y_, c=c_, cmap=cmap, s=300, linewidths=0.0)
            if cmap_category in ('Perceptually Uniform Sequential', 'Sequential'):
                locs.append(x[-1] + j * dc)
            elif cmap_category in ('Diverging', 'Qualitative', 'Cyclic', 'Miscellaneous', 'Sequential (2)'):
                locs.append(x[int(x.size / 2.0)] + j * dc)
        ax.set_xlim(axs[0, 0].get_xlim())
        ax.set_ylim(0.0, 100.0)
        ax.xaxis.set_ticks_position('top')
        ticker = mpl.ticker.FixedLocator(locs)
        ax.xaxis.set_major_locator(ticker)
        formatter = mpl.ticker.FixedFormatter(cmap_list[i * dsub:(i + 1) * dsub])
        ax.xaxis.set_major_formatter(formatter)
        ax.xaxis.set_tick_params(rotation=50)
        ax.set_ylabel('Lightness $L^*$', fontsize=12)
    ax.set_xlabel(cmap_category + ' colormaps', fontsize=14)
    fig.tight_layout(h_pad=0.0, pad=1.5)
    plt.show()
mpl.rcParams.update({'font.size': 14})
x = np.linspace(0.0, 1.0, 100)
gradient = np.linspace(0, 1, 256)
gradient = np.vstack((gradient, gradient))

def plot_color_gradients(cmap_category, cmap_list):
    (fig, axs) = plt.subplots(nrows=len(cmap_list), ncols=2)
    fig.subplots_adjust(top=0.95, bottom=0.01, left=0.2, right=0.99, wspace=0.05)
    fig.suptitle(cmap_category + ' colormaps', fontsize=14, y=1.0, x=0.6)
    for (ax, name) in zip(axs, cmap_list):
        rgb = mpl.colormaps[name](x)[np.newaxis, :, :3]
        lab = cspace_converter('sRGB1', 'CAM02-UCS')(rgb)
        L = lab[0, :, 0]
        L = np.float32(np.vstack((L, L, L)))
        ax[0].imshow(gradient, aspect='auto', cmap=mpl.colormaps[name])
        ax[1].imshow(L, aspect='auto', cmap='binary_r', vmin=0.0, vmax=100.0)
        pos = list(ax[0].get_position().bounds)
        x_text = pos[0] - 0.01
        y_text = pos[1] + pos[3] / 2.0
        fig.text(x_text, y_text, name, va='center', ha='right', fontsize=10)
    for ax in axs.flat:
        ax.set_axis_off()
    plt.show()
for (cmap_category, cmap_list) in cmaps.items():
    plot_color_gradients(cmap_category, cmap_list)

# File: matplotlib-main/galleries/users_explain/colors/colors.py
""""""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Rectangle
(fig, ax) = plt.subplots(figsize=(6.5, 1.65), layout='constrained')
ax.add_patch(Rectangle((-0.2, -0.35), 11.2, 0.7, color='C1', alpha=0.8))
for (i, alpha) in enumerate(np.linspace(0, 1, 11)):
    ax.add_patch(Rectangle((i, 0.05), 0.8, 0.6, alpha=alpha, zorder=0))
    ax.text(i + 0.4, 0.85, f'{alpha:.1f}', ha='center')
    ax.add_patch(Rectangle((i, -0.05), 0.8, -0.6, alpha=alpha, zorder=2))
ax.set_xlim(-0.2, 13)
ax.set_ylim(-1, 1)
ax.set_title('alpha values')
ax.text(11.3, 0.6, 'zorder=1', va='center', color='C0')
ax.text(11.3, 0, 'zorder=2\nalpha=0.8', va='center', color='C1')
ax.text(11.3, -0.6, 'zorder=3', va='center', color='C0')
ax.axis('off')
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
th = np.linspace(0, 2 * np.pi, 128)

def demo(sty):
    mpl.style.use(sty)
    (fig, ax) = plt.subplots(figsize=(3, 3))
    ax.set_title(f'style: {sty!r}', color='C0')
    ax.plot(th, np.cos(th), 'C1', label='C1')
    ax.plot(th, np.sin(th), 'C2', label='C2')
    ax.legend()
demo('default')
demo('seaborn-v0_8')
import matplotlib.colors as mcolors
import matplotlib.patches as mpatch
overlap = {name for name in mcolors.CSS4_COLORS if f'xkcd:{name}' in mcolors.XKCD_COLORS}
fig = plt.figure(figsize=[9, 5])
ax = fig.add_axes([0, 0, 1, 1])
n_groups = 3
n_rows = len(overlap) // n_groups + 1
for (j, color_name) in enumerate(sorted(overlap)):
    css4 = mcolors.CSS4_COLORS[color_name]
    xkcd = mcolors.XKCD_COLORS[f'xkcd:{color_name}'].upper()
    rgba = mcolors.to_rgba_array([css4, xkcd])
    luma = 0.299 * rgba[:, 0] + 0.587 * rgba[:, 1] + 0.114 * rgba[:, 2]
    css4_text_color = 'k' if luma[0] > 0.5 else 'w'
    xkcd_text_color = 'k' if luma[1] > 0.5 else 'w'
    col_shift = j // n_rows * 3
    y_pos = j % n_rows
    text_args = dict(fontsize=10, weight='bold' if css4 == xkcd else None)
    ax.add_patch(mpatch.Rectangle((0 + col_shift, y_pos), 1, 1, color=css4))
    ax.add_patch(mpatch.Rectangle((1 + col_shift, y_pos), 1, 1, color=xkcd))
    ax.text(0.5 + col_shift, y_pos + 0.7, css4, color=css4_text_color, ha='center', **text_args)
    ax.text(1.5 + col_shift, y_pos + 0.7, xkcd, color=xkcd_text_color, ha='center', **text_args)
    ax.text(2 + col_shift, y_pos + 0.7, f'  {color_name}', **text_args)
for g in range(n_groups):
    ax.hlines(range(n_rows), 3 * g, 3 * g + 2.8, color='0.7', linewidth=1)
    ax.text(0.5 + 3 * g, -0.3, 'X11/CSS4', ha='center')
    ax.text(1.5 + 3 * g, -0.3, 'xkcd', ha='center')
ax.set_xlim(0, 3 * n_groups)
ax.set_ylim(n_rows, -1)
ax.axis('off')
plt.show()

# File: matplotlib-main/galleries/users_explain/customizing.py
""""""
from cycler import cycler
import matplotlib.pyplot as plt
import numpy as np
import matplotlib as mpl
mpl.rcParams['lines.linewidth'] = 2
mpl.rcParams['lines.linestyle'] = '--'
data = np.random.randn(50)
plt.plot(data)
mpl.rcParams['axes.prop_cycle'] = cycler(color=['r', 'g', 'b', 'y'])
plt.plot(data)
mpl.rc('lines', linewidth=4, linestyle='-.')
plt.plot(data)
with mpl.rc_context({'lines.linewidth': 2, 'lines.linestyle': ':'}):
    plt.plot(data)

@mpl.rc_context({'lines.linewidth': 3, 'lines.linestyle': '-'})
def plotting_function():
    plt.plot(data)
plotting_function()
plt.style.use('ggplot')
print(plt.style.available)
with plt.style.context('dark_background'):
    plt.plot(np.sin(np.linspace(0, 2 * np.pi)), 'r-o')
plt.show()

# File: matplotlib-main/galleries/users_explain/quick_start.py
""""""
import matplotlib.pyplot as plt
import numpy as np
(fig, ax) = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.show()
np.random.seed(19680801)
data = {'a': np.arange(50), 'c': np.random.randint(0, 50, 50), 'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100
(fig, ax) = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.scatter('a', 'b', c='c', s='d', data=data)
ax.set_xlabel('entry a')
ax.set_ylabel('entry b')
x = np.linspace(0, 2, 100)
(fig, ax) = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.plot(x, x, label='linear')
ax.plot(x, x ** 2, label='quadratic')
ax.plot(x, x ** 3, label='cubic')
ax.set_xlabel('x label')
ax.set_ylabel('y label')
ax.set_title('Simple Plot')
ax.legend()
x = np.linspace(0, 2, 100)
plt.figure(figsize=(5, 2.7), layout='constrained')
plt.plot(x, x, label='linear')
plt.plot(x, x ** 2, label='quadratic')
plt.plot(x, x ** 3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title('Simple Plot')
plt.legend()

def my_plotter(ax, data1, data2, param_dict):
    out = ax.plot(data1, data2, **param_dict)
    return out
(data1, data2, data3, data4) = np.random.randn(4, 100)
(fig, (ax1, ax2)) = plt.subplots(1, 2, figsize=(5, 2.7))
my_plotter(ax1, data1, data2, {'marker': 'x'})
my_plotter(ax2, data3, data4, {'marker': 'o'})
(fig, ax) = plt.subplots(figsize=(5, 2.7))
x = np.arange(len(data1))
ax.plot(x, np.cumsum(data1), color='blue', linewidth=3, linestyle='--')
(l,) = ax.plot(x, np.cumsum(data2), color='orange', linewidth=2)
l.set_linestyle(':')
(fig, ax) = plt.subplots(figsize=(5, 2.7))
ax.scatter(data1, data2, s=50, facecolor='C0', edgecolor='k')
(fig, ax) = plt.subplots(figsize=(5, 2.7))
ax.plot(data1, 'o', label='data1')
ax.plot(data2, 'd', label='data2')
ax.plot(data3, 'v', label='data3')
ax.plot(data4, 's', label='data4')
ax.legend()
(mu, sigma) = (115, 15)
x = mu + sigma * np.random.randn(10000)
(fig, ax) = plt.subplots(figsize=(5, 2.7), layout='constrained')
(n, bins, patches) = ax.hist(x, 50, density=True, facecolor='C0', alpha=0.75)
ax.set_xlabel('Length [cm]')
ax.set_ylabel('Probability')
ax.set_title('Aardvark lengths\n (not really)')
ax.text(75, 0.025, '$\\mu=115,\\ \\sigma=15$')
ax.axis([55, 175, 0, 0.03])
ax.grid(True)
(fig, ax) = plt.subplots(figsize=(5, 2.7))
t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
(line,) = ax.plot(t, s, lw=2)
ax.annotate('local max', xy=(2, 1), xytext=(3, 1.5), arrowprops=dict(facecolor='black', shrink=0.05))
ax.set_ylim(-2, 2)
(fig, ax) = plt.subplots(figsize=(5, 2.7))
ax.plot(np.arange(len(data1)), data1, label='data1')
ax.plot(np.arange(len(data2)), data2, label='data2')
ax.plot(np.arange(len(data3)), data3, 'd', label='data3')
ax.legend()
(fig, axs) = plt.subplots(1, 2, figsize=(5, 2.7), layout='constrained')
xdata = np.arange(len(data1))
data = 10 ** data1
axs[0].plot(xdata, data)
axs[1].set_yscale('log')
axs[1].plot(xdata, data)
(fig, axs) = plt.subplots(2, 1, layout='constrained')
axs[0].plot(xdata, data1)
axs[0].set_title('Automatic ticks')
axs[1].plot(xdata, data1)
axs[1].set_xticks(np.arange(0, 100, 30), ['zero', '30', 'sixty', '90'])
axs[1].set_yticks([-1.5, 0, 1.5])
axs[1].set_title('Manual ticks')
from matplotlib.dates import ConciseDateFormatter
(fig, ax) = plt.subplots(figsize=(5, 2.7), layout='constrained')
dates = np.arange(np.datetime64('2021-11-15'), np.datetime64('2021-12-25'), np.timedelta64(1, 'h'))
data = np.cumsum(np.random.randn(len(dates)))
ax.plot(dates, data)
ax.xaxis.set_major_formatter(ConciseDateFormatter(ax.xaxis.get_major_locator()))
(fig, ax) = plt.subplots(figsize=(5, 2.7), layout='constrained')
categories = ['turnips', 'rutabaga', 'cucumber', 'pumpkins']
ax.bar(categories, np.random.rand(len(categories)))
(fig, (ax1, ax3)) = plt.subplots(1, 2, figsize=(7, 2.7), layout='constrained')
(l1,) = ax1.plot(t, s)
ax2 = ax1.twinx()
(l2,) = ax2.plot(t, range(len(t)), 'C1')
ax2.legend([l1, l2], ['Sine (left)', 'Straight (right)'])
ax3.plot(t, s)
ax3.set_xlabel('Angle [rad]')
ax4 = ax3.secondary_xaxis('top', (np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')
from matplotlib.colors import LogNorm
(X, Y) = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))
Z = (1 - X / 2 + X ** 5 + Y ** 3) * np.exp(-X ** 2 - Y ** 2)
(fig, axs) = plt.subplots(2, 2, layout='constrained')
pc = axs[0, 0].pcolormesh(X, Y, Z, vmin=-1, vmax=1, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[0, 0])
axs[0, 0].set_title('pcolormesh()')
co = axs[0, 1].contourf(X, Y, Z, levels=np.linspace(-1.25, 1.25, 11))
fig.colorbar(co, ax=axs[0, 1])
axs[0, 1].set_title('contourf()')
pc = axs[1, 0].imshow(Z ** 2 * 100, cmap='plasma', norm=LogNorm(vmin=0.01, vmax=100))
fig.colorbar(pc, ax=axs[1, 0], extend='both')
axs[1, 0].set_title('imshow() with LogNorm()')
pc = axs[1, 1].scatter(data1, data2, c=data3, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[1, 1], extend='both')
axs[1, 1].set_title('scatter()')
(fig, axd) = plt.subplot_mosaic([['upleft', 'right'], ['lowleft', 'right']], layout='constrained')
axd['upleft'].set_title('upleft')
axd['lowleft'].set_title('lowleft')
axd['right'].set_title('right')

# File: matplotlib-main/galleries/users_explain/text/annotations.py
""""""
import matplotlib.pyplot as plt
import numpy as np
(fig, ax) = plt.subplots(figsize=(3, 3))
t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
(line,) = ax.plot(t, s, lw=2)
ax.annotate('local max', xy=(2, 1), xytext=(3, 1.5), arrowprops=dict(facecolor='black', shrink=0.05))
ax.set_ylim(-2, 2)
(fig, ax) = plt.subplots(figsize=(3, 3))
t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
(line,) = ax.plot(t, s, lw=2)
ax.annotate('local max', xy=(2, 1), xycoords='data', xytext=(0.01, 0.99), textcoords='axes fraction', va='top', ha='left', arrowprops=dict(facecolor='black', shrink=0.05))
ax.set_ylim(-2, 2)
import matplotlib.patches as mpatches
(fig, ax) = plt.subplots(figsize=(3, 3))
arr = mpatches.FancyArrowPatch((1.25, 1.5), (1.75, 1.5), arrowstyle='->,head_width=.15', mutation_scale=20)
ax.add_patch(arr)
ax.annotate('label', (0.5, 0.5), xycoords=arr, ha='center', va='bottom')
ax.set(xlim=(1, 2), ylim=(1, 2))
fig = plt.figure()
ax = fig.add_subplot(projection='polar')
r = np.arange(0, 1, 0.001)
theta = 2 * 2 * np.pi * r
(line,) = ax.plot(theta, r, color='#ee8d18', lw=3)
ind = 800
(thisr, thistheta) = (r[ind], theta[ind])
ax.plot([thistheta], [thisr], 'o')
ax.annotate('a polar annotation', xy=(thistheta, thisr), xytext=(0.05, 0.05), textcoords='figure fraction', arrowprops=dict(facecolor='black', shrink=0.05), horizontalalignment='left', verticalalignment='bottom')
(fig, ax) = plt.subplots(figsize=(3, 3))
x = [1, 3, 5, 7, 9]
y = [2, 4, 6, 8, 10]
annotations = ['A', 'B', 'C', 'D', 'E']
ax.scatter(x, y, s=20)
for (xi, yi, text) in zip(x, y, annotations):
    ax.annotate(text, xy=(xi, yi), xycoords='data', xytext=(1.5, 1.5), textcoords='offset points')
(fig, ax) = plt.subplots(figsize=(5, 5))
t = ax.text(0.5, 0.5, 'Direction', ha='center', va='center', rotation=45, size=15, bbox=dict(boxstyle='rarrow,pad=0.3', fc='lightblue', ec='steelblue', lw=2))
from matplotlib.path import Path

def custom_box_style(x0, y0, width, height, mutation_size):
    mypad = 0.3
    pad = mutation_size * mypad
    width = width + 2 * pad
    height = height + 2 * pad
    (x0, y0) = (x0 - pad, y0 - pad)
    (x1, y1) = (x0 + width, y0 + height)
    return Path([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0 - pad, (y0 + y1) / 2), (x0, y0), (x0, y0)], closed=True)
(fig, ax) = plt.subplots(figsize=(3, 3))
ax.text(0.5, 0.5, 'Test', size=30, va='center', ha='center', rotation=30, bbox=dict(boxstyle=custom_box_style, alpha=0.2))
from matplotlib.patches import BoxStyle

class MyStyle:

    def __init__(self, pad=0.3):
        self.pad = pad
        super().__init__()

    def __call__(self, x0, y0, width, height, mutation_size):
        pad = mutation_size * self.pad
        width = width + 2 * pad
        height = height + 2 * pad
        (x0, y0) = (x0 - pad, y0 - pad)
        (x1, y1) = (x0 + width, y0 + height)
        return Path([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0 - pad, (y0 + y1) / 2), (x0, y0), (x0, y0)], closed=True)
BoxStyle._style_list['angled'] = MyStyle
(fig, ax) = plt.subplots(figsize=(3, 3))
ax.text(0.5, 0.5, 'Test', size=30, va='center', ha='center', rotation=30, bbox=dict(boxstyle='angled,pad=0.5', alpha=0.2))
del BoxStyle._style_list['angled']
(fig, ax) = plt.subplots(figsize=(3, 3))
ax.annotate('', xy=(0.2, 0.2), xycoords='data', xytext=(0.8, 0.8), textcoords='data', arrowprops=dict(arrowstyle='->', connectionstyle='arc3'))
(fig, ax) = plt.subplots(figsize=(3, 3))
ax.annotate('Test', xy=(0.2, 0.2), xycoords='data', xytext=(0.8, 0.8), textcoords='data', size=20, va='center', ha='center', arrowprops=dict(arrowstyle='simple', connectionstyle='arc3,rad=-0.2'))
(fig, ax) = plt.subplots(figsize=(3, 3))
ann = ax.annotate('Test', xy=(0.2, 0.2), xycoords='data', xytext=(0.8, 0.8), textcoords='data', size=20, va='center', ha='center', bbox=dict(boxstyle='round4', fc='w'), arrowprops=dict(arrowstyle='-|>', connectionstyle='arc3,rad=-0.2', fc='w'))
(fig, ax) = plt.subplots(figsize=(3, 3))
ann = ax.annotate('Test', xy=(0.2, 0.2), xycoords='data', xytext=(0.8, 0.8), textcoords='data', size=20, va='center', ha='center', bbox=dict(boxstyle='round4', fc='w'), arrowprops=dict(arrowstyle='-|>', connectionstyle='arc3,rad=0.2', relpos=(0.0, 0.0), fc='w'))
ann = ax.annotate('Test', xy=(0.2, 0.2), xycoords='data', xytext=(0.8, 0.8), textcoords='data', size=20, va='center', ha='center', bbox=dict(boxstyle='round4', fc='w'), arrowprops=dict(arrowstyle='-|>', connectionstyle='arc3,rad=-0.2', relpos=(1.0, 0.0), fc='w'))
from matplotlib.offsetbox import AnchoredText
(fig, ax) = plt.subplots(figsize=(3, 3))
at = AnchoredText('Figure 1a', prop=dict(size=15), frameon=True, loc='upper left')
at.patch.set_boxstyle('round,pad=0.,rounding_size=0.2')
ax.add_artist(at)
from matplotlib.patches import Circle
from mpl_toolkits.axes_grid1.anchored_artists import AnchoredDrawingArea
(fig, ax) = plt.subplots(figsize=(3, 3))
ada = AnchoredDrawingArea(40, 20, 0, 0, loc='upper right', pad=0.0, frameon=False)
p1 = Circle((10, 10), 10)
ada.drawing_area.add_artist(p1)
p2 = Circle((30, 10), 5, fc='r')
ada.drawing_area.add_artist(p2)
ax.add_artist(ada)
from matplotlib.patches import Ellipse
from mpl_toolkits.axes_grid1.anchored_artists import AnchoredAuxTransformBox
(fig, ax) = plt.subplots(figsize=(3, 3))
box = AnchoredAuxTransformBox(ax.transData, loc='upper left')
el = Ellipse((0, 0), width=0.1, height=0.4, angle=30)
box.drawing_area.add_artist(el)
ax.add_artist(box)
from matplotlib.offsetbox import AnchoredOffsetbox, DrawingArea, HPacker, TextArea
(fig, ax) = plt.subplots(figsize=(3, 3))
box1 = TextArea(' Test: ', textprops=dict(color='k'))
box2 = DrawingArea(60, 20, 0, 0)
el1 = Ellipse((10, 10), width=16, height=5, angle=30, fc='r')
el2 = Ellipse((30, 10), width=16, height=5, angle=170, fc='g')
el3 = Ellipse((50, 10), width=16, height=5, angle=230, fc='b')
box2.add_artist(el1)
box2.add_artist(el2)
box2.add_artist(el3)
box = HPacker(children=[box1, box2], align='center', pad=0, sep=5)
anchored_box = AnchoredOffsetbox(loc='lower left', child=box, pad=0.0, frameon=True, bbox_to_anchor=(0.0, 1.02), bbox_transform=ax.transAxes, borderpad=0.0)
ax.add_artist(anchored_box)
fig.subplots_adjust(top=0.8)
(fig, (ax1, ax2)) = plt.subplots(nrows=1, ncols=2, figsize=(6, 3))
ax1.annotate('Test', xy=(0.2, 0.2), xycoords=ax1.transAxes)
ax2.annotate('Test', xy=(0.2, 0.2), xycoords='axes fraction')
x = np.linspace(-1, 1)
(fig, (ax1, ax2)) = plt.subplots(nrows=1, ncols=2, figsize=(6, 3))
ax1.plot(x, -x ** 3)
ax2.plot(x, -3 * x ** 2)
ax2.annotate('', xy=(0, 0), xycoords=ax1.transData, xytext=(0, 0), textcoords=ax2.transData, arrowprops=dict(arrowstyle='<->'))
(fig, ax) = plt.subplots(nrows=1, ncols=1, figsize=(3, 3))
an1 = ax.annotate('Test 1', xy=(0.5, 0.5), xycoords='data', va='center', ha='center', bbox=dict(boxstyle='round', fc='w'))
an2 = ax.annotate('Test 2', xy=(1, 0.5), xycoords=an1, xytext=(30, 0), textcoords='offset points', va='center', ha='left', bbox=dict(boxstyle='round', fc='w'), arrowprops=dict(arrowstyle='->'))
(fig, ax) = plt.subplots(nrows=1, ncols=1, figsize=(3, 3))
an1 = ax.annotate('Test 1', xy=(0.5, 0.5), xycoords='data', va='center', ha='center', bbox=dict(boxstyle='round', fc='w'))
an2 = ax.annotate('Test 2', xy=(1, 0.5), xycoords=an1.get_window_extent, xytext=(30, 0), textcoords='offset points', va='center', ha='left', bbox=dict(boxstyle='round', fc='w'), arrowprops=dict(arrowstyle='->'))
(fig, (ax1, ax2)) = plt.subplots(nrows=1, ncols=2, figsize=(6, 3))
an1 = ax1.annotate('Test1', xy=(0.5, 0.5), xycoords='axes fraction')
an2 = ax2.annotate('Test 2', xy=(0.5, 0.5), xycoords=ax2.get_window_extent)
(fig, ax) = plt.subplots(figsize=(3, 3))
ax.annotate('Test', xy=(0.5, 1), xycoords=('data', 'axes fraction'))
ax.axvline(x=0.5, color='lightgray')
ax.set(xlim=(0, 2), ylim=(1, 2))
(fig, ax) = plt.subplots(figsize=(3, 3))
t1 = ax.text(0.05, 0.05, 'Text 1', va='bottom', ha='left')
t2 = ax.text(0.9, 0.9, 'Text 2', ha='right')
t3 = ax.annotate('Anchored to 1 & 2', xy=(0, 0), xycoords=(t1, t2), va='bottom', color='tab:orange')
from matplotlib.text import OffsetFrom
(fig, ax) = plt.subplots(figsize=(3, 3))
an1 = ax.annotate('Test 1', xy=(0.5, 0.5), xycoords='data', va='center', ha='center', bbox=dict(boxstyle='round', fc='w'))
offset_from = OffsetFrom(an1, (0.5, 0))
an2 = ax.annotate('Test 2', xy=(0.1, 0.1), xycoords='data', xytext=(0, -10), textcoords=offset_from, va='top', ha='center', bbox=dict(boxstyle='round', fc='w'), arrowprops=dict(arrowstyle='->'))
from matplotlib.patches import ConnectionPatch
(fig, (ax1, ax2)) = plt.subplots(nrows=1, ncols=2, figsize=(6, 3))
xy = (0.3, 0.2)
con = ConnectionPatch(xyA=xy, coordsA=ax1.transData, xyB=xy, coordsB=ax2.transData)
fig.add_artist(con)

# File: matplotlib-main/galleries/users_explain/text/fonts.py
""""""

# File: matplotlib-main/galleries/users_explain/text/mathtext.py
""""""
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(3, 3), linewidth=1, edgecolor='black')
fig.text(0.2, 0.7, 'plain text: alpha > beta')
fig.text(0.2, 0.5, 'Mathtext: $\\alpha > \\beta$')
fig.text(0.2, 0.3, 'raw string Mathtext: $\\alpha > \\beta$')
fig = plt.figure(figsize=(3, 3), linewidth=1, edgecolor='black')
fig.suptitle('Number of unescaped $')
fig.text(0.1, 0.7, 'odd: $ \\alpha $ = $1')
fig.text(0.1, 0.5, 'even: $ \\beta $= $ 2 $')
fig.text(0.1, 0.3, 'odd: $ \\gamma $= \\$3 $')
fig.text(0.1, 0.1, 'even: $ \\delta $ = $ \\$4 $')

# File: matplotlib-main/galleries/users_explain/text/pgf.py
""""""

# File: matplotlib-main/galleries/users_explain/text/text_intro.py
""""""
import matplotlib.pyplot as plt
import matplotlib
fig = plt.figure()
ax = fig.add_subplot()
fig.subplots_adjust(top=0.85)
fig.suptitle('bold figure suptitle', fontsize=14, fontweight='bold')
ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.axis([0, 10, 0, 10])
ax.text(3, 8, 'boxed italics text in data coords', style='italic', bbox={'facecolor': 'red', 'alpha': 0.5, 'pad': 10})
ax.text(2, 6, 'an equation: $E=mc^2$', fontsize=15)
ax.text(3, 2, 'Unicode: Institut für Festkörperphysik')
ax.text(0.95, 0.01, 'colored text in axes coords', verticalalignment='bottom', horizontalalignment='right', transform=ax.transAxes, color='green', fontsize=15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy=(2, 1), xytext=(3, 4), arrowprops=dict(facecolor='black', shrink=0.05))
plt.show()
import matplotlib.pyplot as plt
import numpy as np
x1 = np.linspace(0.0, 5.0, 100)
y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('Time [s]')
ax.set_ylabel('Damped oscillation [V]')
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1 * 10000)
ax.set_xlabel('Time [s]')
ax.set_ylabel('Damped oscillation [V]')
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1 * 10000)
ax.set_xlabel('Time [s]')
ax.set_ylabel('Damped oscillation [V]', labelpad=18)
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('Time [s]', position=(0.0, 1000000.0), horizontalalignment='left')
ax.set_ylabel('Damped oscillation [V]')
plt.show()
from matplotlib.font_manager import FontProperties
font = FontProperties()
font.set_family('serif')
font.set_name('Times New Roman')
font.set_style('italic')
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.15, left=0.2)
ax.plot(x1, y1)
ax.set_xlabel('Time [s]', fontsize='large', fontweight='bold')
ax.set_ylabel('Damped oscillation [V]', fontproperties=font)
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(bottom=0.2, left=0.2)
ax.plot(x1, np.cumsum(y1 ** 2))
ax.set_xlabel('Time [s] \n This was a long experiment')
ax.set_ylabel('$\\int\\ Y^2\\ dt\\ \\ [V^2 s]$')
plt.show()
(fig, axs) = plt.subplots(3, 1, figsize=(5, 6), tight_layout=True)
locs = ['center', 'left', 'right']
for (ax, loc) in zip(axs, locs):
    ax.plot(x1, y1)
    ax.set_title('Title with loc at ' + loc, loc=loc)
plt.show()
(fig, ax) = plt.subplots(figsize=(5, 3))
fig.subplots_adjust(top=0.8)
ax.plot(x1, y1)
ax.set_title('Vertically offset title', pad=30)
plt.show()
(fig, axs) = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
axs[1].xaxis.set_ticks(np.arange(0.0, 8.1, 2.0))
plt.show()
(fig, axs) = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
ticks = np.arange(0.0, 8.1, 2.0)
tickla = [f'{tick:1.2f}' for tick in ticks]
axs[1].xaxis.set_ticks(ticks)
axs[1].xaxis.set_ticklabels(tickla)
axs[1].set_xlim(axs[0].get_xlim())
plt.show()
(fig, axs) = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
ticks = np.arange(0.0, 8.1, 2.0)
axs[1].xaxis.set_ticks(ticks)
axs[1].xaxis.set_major_formatter('{x:1.1f}')
axs[1].set_xlim(axs[0].get_xlim())
plt.show()
(fig, axs) = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
axs[0].plot(x1, y1)
axs[1].plot(x1, y1)
locator = matplotlib.ticker.FixedLocator(ticks)
axs[1].xaxis.set_major_locator(locator)
axs[1].xaxis.set_major_formatter('±{x}°')
plt.show()
(fig, axs) = plt.subplots(2, 2, figsize=(8, 5), tight_layout=True)
for (n, ax) in enumerate(axs.flat):
    ax.plot(x1 * 10.0, y1)
formatter = matplotlib.ticker.FormatStrFormatter('%1.1f')
locator = matplotlib.ticker.MaxNLocator(nbins='auto', steps=[1, 4, 10])
axs[0, 1].xaxis.set_major_locator(locator)
axs[0, 1].xaxis.set_major_formatter(formatter)
formatter = matplotlib.ticker.FormatStrFormatter('%1.5f')
locator = matplotlib.ticker.AutoLocator()
axs[1, 0].xaxis.set_major_formatter(formatter)
axs[1, 0].xaxis.set_major_locator(locator)
formatter = matplotlib.ticker.FormatStrFormatter('%1.5f')
locator = matplotlib.ticker.MaxNLocator(nbins=4)
axs[1, 1].xaxis.set_major_formatter(formatter)
axs[1, 1].xaxis.set_major_locator(locator)
plt.show()

def formatoddticks(x, pos):
    if x % 2:
        return f'{x:1.2f}'
    else:
        return ''
(fig, ax) = plt.subplots(figsize=(5, 3), tight_layout=True)
ax.plot(x1, y1)
locator = matplotlib.ticker.MaxNLocator(nbins=6)
ax.xaxis.set_major_formatter(formatoddticks)
ax.xaxis.set_major_locator(locator)
plt.show()
import datetime
(fig, ax) = plt.subplots(figsize=(5, 3), tight_layout=True)
base = datetime.datetime(2017, 1, 1, 0, 0, 1)
time = [base + datetime.timedelta(days=x) for x in range(len(x1))]
ax.plot(time, y1)
ax.tick_params(axis='x', rotation=70)
plt.show()
import matplotlib.dates as mdates
locator = mdates.DayLocator(bymonthday=[1, 15])
formatter = mdates.DateFormatter('%b %d')
(fig, ax) = plt.subplots(figsize=(5, 3), tight_layout=True)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.plot(time, y1)
ax.tick_params(axis='x', rotation=70)
plt.show()

# File: matplotlib-main/galleries/users_explain/text/text_props.py
""""""
import matplotlib.pyplot as plt
import matplotlib.patches as patches
(left, width) = (0.25, 0.5)
(bottom, height) = (0.25, 0.5)
right = left + width
top = bottom + height
fig = plt.figure()
ax = fig.add_axes([0, 0, 1, 1])
p = patches.Rectangle((left, bottom), width, height, fill=False, transform=ax.transAxes, clip_on=False)
ax.add_patch(p)
ax.text(left, bottom, 'left top', horizontalalignment='left', verticalalignment='top', transform=ax.transAxes)
ax.text(left, bottom, 'left bottom', horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes)
ax.text(right, top, 'right bottom', horizontalalignment='right', verticalalignment='bottom', transform=ax.transAxes)
ax.text(right, top, 'right top', horizontalalignment='right', verticalalignment='top', transform=ax.transAxes)
ax.text(right, bottom, 'center top', horizontalalignment='center', verticalalignment='top', transform=ax.transAxes)
ax.text(left, 0.5 * (bottom + top), 'right center', horizontalalignment='right', verticalalignment='center', rotation='vertical', transform=ax.transAxes)
ax.text(left, 0.5 * (bottom + top), 'left center', horizontalalignment='left', verticalalignment='center', rotation='vertical', transform=ax.transAxes)
ax.text(0.5 * (left + right), 0.5 * (bottom + top), 'middle', horizontalalignment='center', verticalalignment='center', fontsize=20, color='red', transform=ax.transAxes)
ax.text(right, 0.5 * (bottom + top), 'centered', horizontalalignment='center', verticalalignment='center', rotation='vertical', transform=ax.transAxes)
ax.text(left, top, 'rotated\nwith newlines', horizontalalignment='center', verticalalignment='center', rotation=45, transform=ax.transAxes)
ax.set_axis_off()
plt.show()

# File: matplotlib-main/galleries/users_explain/text/usetex.py
""""""

# File: matplotlib-main/lib/matplotlib/__init__.py
""""""
__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
from . import _api, _version, cbook, _docstring, rcsetup
from matplotlib._api import MatplotlibDeprecationWarning
from matplotlib.rcsetup import cycler
_log = logging.getLogger(__name__)
__bibtex__ = '@Article{Hunter:2007,\n  Author    = {Hunter, J. D.},\n  Title     = {Matplotlib: A 2D graphics environment},\n  Journal   = {Computing in Science \\& Engineering},\n  Volume    = {9},\n  Number    = {3},\n  Pages     = {90--95},\n  abstract  = {Matplotlib is a 2D graphics package used for Python\n  for application development, interactive scripting, and\n  publication-quality image generation across user\n  interfaces and operating systems.},\n  publisher = {IEEE COMPUTER SOC},\n  year      = 2007\n}'
_VersionInfo = namedtuple('_VersionInfo', 'major, minor, micro, releaselevel, serial')

def _parse_to_version_info(version_str):
    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:
        return _VersionInfo(v.major, v.minor, v.micro + 1, 'alpha', v.post)

def _get_version():
    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)
    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():
    from . import ft2font
    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}; you have {module.__version__}')
_check_versions()

@functools.cache
def _ensure_handler():
    handler = logging.StreamHandler()
    handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
    _log.addHandler(handler)
    return handler

def set_loglevel(level):
    _log.setLevel(level.upper())
    _ensure_handler().setLevel(level.upper())

def _logged_cached(fmt, func=None):
    if func is None:
        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):
    pass

@functools.cache
def _get_executable_info(name):

    def impl(args, regex, min_ver=None, ignore_exit_code=False):
        try:
            output = subprocess.check_output(args, stderr=subprocess.STDOUT, text=True, errors='replace')
        except subprocess.CalledProcessError as _cpe:
            if ignore_exit_code:
                output = _cpe.output
            else:
                raise ExecutableNotFoundError(str(_cpe)) from _cpe
        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 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 {' '.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'] 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:
            return impl(['inkscape', '--without-gui', '-V'], 'Inkscape ([^ ]*)')
        except ExecutableNotFoundError:
            pass
        return impl(['inkscape', '-V'], 'Inkscape ([^ ]*)')
    elif name == 'magick':
        if sys.platform == 'win32':
            import winreg
            binpath = ''
            for flag in [0, winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY]:
                try:
                    with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, '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'], '^Version: ImageMagick (\\S*)')
        if info.raw_version == '7.0.10-34':
            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 parse_version('0.9') <= info.version < parse_version('1.0'))):
            raise ExecutableNotFoundError(f'You have pdftops version {info.version} but the minimum version supported by Matplotlib is 3.0')
        return info
    else:
        raise ValueError(f'Unknown executable: {name!r}')

def _get_xdg_config_dir():
    return os.environ.get('XDG_CONFIG_HOME') or str(Path.home() / '.config')

def _get_xdg_cache_dir():
    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).resolve()
    elif sys.platform.startswith(('linux', 'freebsd')):
        configdir = Path(xdg_base_getter(), 'matplotlib')
    else:
        configdir = Path.home() / '.matplotlib'
    try:
        configdir.mkdir(parents=True, exist_ok=True)
    except OSError:
        pass
    else:
        if os.access(str(configdir), os.W_OK) and configdir.is_dir():
            return str(configdir)
    try:
        tmpdir = tempfile.mkdtemp(prefix='matplotlib-')
    except OSError as exc:
        raise OSError(f'Matplotlib requires access to a writable cache directory, but the default path ({configdir}) is not a writable directory, and a temporary directory could not be created; set the MPLCONFIGDIR environment 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 the default path (%s) is not a writable directory; 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 _get_config_or_cache_dir(_get_xdg_config_dir)

@_logged_cached('CACHEDIR=%s')
def get_cachedir():
    return _get_config_or_cache_dir(_get_xdg_cache_dir)

@_logged_cached('matplotlib data path: %s')
def get_data_path():
    return str(Path(__file__).with_name('mpl-data'))

def matplotlib_fname():

    def gen_candidates():
        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')
_deprecated_map = {}
_deprecated_ignore_map = {}
_deprecated_remain_as_none = {}

@_docstring.Substitution('\n'.join(map('- {}'.format, sorted(rcsetup._validators, key=str.lower))))
class RcParams(MutableMapping, dict):
    validate = rcsetup._validators

    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    def _set(self, key, val):
        dict.__setitem__(self, key, val)

    def _get(self, key):
        return dict.__getitem__(self, key)

    def _update_raw(self, other_params):
        if isinstance(other_params, RcParams):
            other_params = dict.items(other_params)
        dict.update(self, other_params)

    def _ensure_has_backend(self):
        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 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
        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):
        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):
        with _api.suppress_matplotlib_deprecation_warning():
            yield from sorted(dict.__iter__(self))

    def __len__(self):
        return dict.__len__(self)

    def find_all(self, pattern):
        pattern_re = re.compile(pattern)
        return RcParams(((key, value) for (key, value) in self.items() if pattern_re.search(key)))

    def copy(self):
        rccopy = RcParams()
        for k in self:
            rccopy._set(k, self._get(k))
        return rccopy

def rc_params(fail_on_error=False):
    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):
    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]
                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
            else:
                try:
                    config[key] = val
                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 = 'main' if '.post' in mpl.__version__ else f'v{mpl.__version__}'
            _log.warning('\nBad key %(key)s in file %(fname)s, line %(line_no)s (%(line)r)\nYou probably need to get an updated matplotlibrc file from\nhttps://github.com/matplotlib/matplotlib/blob/%(version)s/lib/matplotlib/mpl-data/matplotlibrc\nor 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):
    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('\n*****************************************************************\nYou have the following UNSUPPORTED LaTeX preamble customizations:\n%s\nPlease do not ask for support with these customizations active.\n*****************************************************************\n', '\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'), 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()
rcParams._update_raw(rcParamsDefault)
rcParams._update_raw(_rc_params_in_file(matplotlib_fname()))
rcParamsOrig = rcParams.copy()
with _api.suppress_matplotlib_deprecation_warning():
    defaultParams = rcsetup.defaultParams = {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):
    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():
    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():
    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):
    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):
    orig = dict(rcParams.copy())
    del orig['backend']
    try:
        if fname:
            rc_file(fname)
        if rc:
            rcParams.update(rc)
        yield
    finally:
        rcParams._update_raw(orig)

def use(backend, *, force=True):
    name = rcsetup.validate_backend(backend)
    if rcParams._get_backend_or_none() == name:
        pass
    else:
        plt = sys.modules.get('matplotlib.pyplot')
        if plt is not None:
            try:
                plt.switch_backend(name)
            except ImportError:
                if force:
                    raise
        else:
            rcParams['backend'] = backend
    rcParams['backend_fallback'] = False
if os.environ.get('MPLBACKEND'):
    rcParams['backend'] = os.environ.get('MPLBACKEND')

def get_backend():
    return rcParams['backend']

def interactive(b):
    rcParams['interactive'] = b

def is_interactive():
    return rcParams['interactive']

def _val_or_rc(val, rc_name):
    return val if val is not None else rcParams[rc_name]

def _init_tests():
    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):
    try:
        if isinstance(value, str):
            value = data[value]
    except Exception:
        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):
    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\n    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\n    interpreted as ``data[s]`` if ``s`` is a key in ``data``:\n\n    {', '.join(map('*{}*'.format, replace_names))}"
    if _log.level <= logging.DEBUG:
        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):
    if func is None:
        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:]
    assert {*arg_names}.issuperset(replace_names or []) or varkwargs_name, f'Matplotlib internal error: invalid replace_names ({replace_names!r}) for {func.__name__!r}'
    assert label_namer is None or label_namer in arg_names, f'Matplotlib internal error: invalid label_namer ({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))
            elif 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)
from matplotlib.cm import _colormaps as colormaps
from matplotlib.cm import _multivar_colormaps as multivar_colormaps
from matplotlib.cm import _bivar_colormaps as bivar_colormaps
from matplotlib.colors import _color_sequences as color_sequences

# File: matplotlib-main/lib/matplotlib/_afm.py
""""""
from collections import namedtuple
import logging
import re
from ._mathtext_data import uni2type1
_log = logging.getLogger(__name__)

def _to_int(x):
    return int(float(x))

def _to_float(x):
    if isinstance(x, bytes):
        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):
    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, b'Notice': lambda x: x, b'EncodingScheme': _to_str, b'CapHeight': _to_float, b'Capheight': _to_float, 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:
            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__ = '\n    Represents the character metrics of a single character.\n\n    Notes\n    -----\n    The fields do currently only describe a subset of character metrics\n    information defined in the AFM standard.\n    '
CharMetrics.width.__doc__ = 'The character width (WX).'
CharMetrics.name.__doc__ = 'The character name (N).'
CharMetrics.bbox.__doc__ = '\n    The bbox of the character (B) as a tuple (*llx*, *lly*, *urx*, *ury*).'

def _parse_char_metrics(fh):
    required_keys = {'C', 'WX', 'N', 'B'}
    ascii_d = {}
    name_d = {}
    for line in fh:
        line = _to_str(line.rstrip())
        if line.startswith('EndCharMetrics'):
            return (ascii_d, name_d)
        vals = dict((s.strip().split(' ', 1) for s in line.split(';') if s))
        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)
        if name == 'Euro':
            num = 128
        elif name == 'minus':
            num = ord('−')
        if num != -1:
            ascii_d[num] = metrics
        name_d[name] = metrics
    raise RuntimeError('Bad parse')

def _parse_kern_pairs(fh):
    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)
            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__ = '\n    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):
    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):
    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):
        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):
        if not len(s):
            return (0, 0)
        total_width = 0
        namelast = None
        miny = 1000000000.0
        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):
        if not len(s):
            return (0, 0, 0, 0, 0)
        total_width = 0
        namelast = None
        miny = 1000000000.0
        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 self.get_str_bbox_and_descent(s)[:4]

    def get_name_char(self, c, isord=False):
        if not isord:
            c = ord(c)
        return self._metrics[c].name

    def get_width_char(self, c, isord=False):
        if not isord:
            c = ord(c)
        return self._metrics[c].width

    def get_width_from_char_name(self, name):
        return self._metrics_by_name[name].width

    def get_height_char(self, c, isord=False):
        if not isord:
            c = ord(c)
        return self._metrics[c].bbox[-1]

    def get_kern_dist(self, c1, 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 self._kern.get((name1, name2), 0)

    def get_fontname(self):
        return self._header[b'FontName']

    @property
    def postscript_name(self):
        return self.get_fontname()

    def get_fullname(self):
        name = self._header.get(b'FullName')
        if name is None:
            name = self._header[b'FontName']
        return name

    def get_familyname(self):
        name = self._header.get(b'FamilyName')
        if name is not None:
            return name
        name = self.get_fullname()
        extras = '(?i)([ -](regular|plain|italic|oblique|bold|semibold|light|ultralight|extra|condensed))+$'
        return re.sub(extras, '', name)

    @property
    def family_name(self):
        return self.get_familyname()

    def get_weight(self):
        return self._header[b'Weight']

    def get_angle(self):
        return self._header[b'ItalicAngle']

    def get_capheight(self):
        return self._header[b'CapHeight']

    def get_xheight(self):
        return self._header[b'XHeight']

    def get_underline_thickness(self):
        return self._header[b'UnderlineThickness']

    def get_horizontal_stem_width(self):
        return self._header.get(b'StdHW', None)

    def get_vertical_stem_width(self):
        return self._header.get(b'StdVW', None)

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

# File: matplotlib-main/lib/matplotlib/_api/__init__.py
""""""
import functools
import itertools
import pathlib
import re
import sys
import warnings
from .deprecation import deprecated, warn_deprecated, rename_parameter, delete_parameter, make_keyword_only, deprecate_method_override, deprecate_privatize_attribute, suppress_matplotlib_deprecation_warning, MatplotlibDeprecationWarning

class classproperty:

    def __init__(self, fget, fset=None, fdel=None, doc=None):
        self._fget = fget
        if fset is not None or fdel is not None:
            raise ValueError('classproperty only implements fget.')
        self.fset = fset
        self.fdel = fdel
        self._doc = doc

    def __get__(self, instance, owner):
        return self._fget(owner)

    @property
    def fget(self):
        return self._fget

def check_isinstance(types, /, **kwargs):
    none_type = type(None)
    types = (types,) if isinstance(types, type) else (none_type,) if types is None else tuple((none_type if tp is None else tp for tp in types))

    def type_name(tp):
        return 'None' if tp is none_type else tp.__qualname__ if tp.__module__ == 'builtins' else f'{tp.__module__}.{tp.__qualname__}'
    for (k, v) in kwargs.items():
        if not isinstance(v, types):
            names = [*map(type_name, types)]
            if 'None' in names:
                names.remove('None')
                names.append('None')
            raise TypeError('{!r} must be an instance of {}, not a {}'.format(k, ', '.join(names[:-1]) + ' or ' + names[-1] if len(names) > 1 else names[0], type_name(type(v))))

def check_in_list(values, /, *, _print_supported_values=True, **kwargs):
    if not kwargs:
        raise TypeError('No argument to check!')
    for (key, val) in kwargs.items():
        if val not in values:
            msg = f'{val!r} is not a valid value for {key}'
            if _print_supported_values:
                msg += f"; supported values are {', '.join(map(repr, values))}"
            raise ValueError(msg)

def check_shape(shape, /, **kwargs):
    for (k, v) in kwargs.items():
        data_shape = v.shape
        if len(data_shape) != len(shape) or any((s != t and t is not None for (s, t) in zip(data_shape, shape))):
            dim_labels = iter(itertools.chain('NMLKJIH', (f'D{i}' for i in itertools.count())))
            text_shape = ', '.join([str(n) if n is not None else next(dim_labels) for n in shape[::-1]][::-1])
            if len(shape) == 1:
                text_shape += ','
            raise ValueError(f'{k!r} must be {len(shape)}D with shape ({text_shape}), but your input has shape {v.shape}')

def check_getitem(mapping, /, **kwargs):
    if len(kwargs) != 1:
        raise ValueError('check_getitem takes a single keyword argument')
    ((k, v),) = kwargs.items()
    try:
        return mapping[v]
    except KeyError:
        raise ValueError(f"{v!r} is not a valid value for {k}; supported values are {', '.join(map(repr, mapping))}") from None

def caching_module_getattr(cls):
    assert cls.__name__ == '__getattr__'
    props = {name: prop for (name, prop) in vars(cls).items() if isinstance(prop, property)}
    instance = cls()

    @functools.cache
    def __getattr__(name):
        if name in props:
            return props[name].__get__(instance)
        raise AttributeError(f'module {cls.__module__!r} has no attribute {name!r}')
    return __getattr__

def define_aliases(alias_d, cls=None):
    if cls is None:
        return functools.partial(define_aliases, alias_d)

    def make_alias(name):

        @functools.wraps(getattr(cls, name))
        def method(self, *args, **kwargs):
            return getattr(self, name)(*args, **kwargs)
        return method
    for (prop, aliases) in alias_d.items():
        exists = False
        for prefix in ['get_', 'set_']:
            if prefix + prop in vars(cls):
                exists = True
                for alias in aliases:
                    method = make_alias(prefix + prop)
                    method.__name__ = prefix + alias
                    method.__doc__ = f'Alias for `{prefix + prop}`.'
                    setattr(cls, prefix + alias, method)
        if not exists:
            raise ValueError(f'Neither getter nor setter exists for {prop!r}')

    def get_aliased_and_aliases(d):
        return {*d, *(alias for aliases in d.values() for alias in aliases)}
    preexisting_aliases = getattr(cls, '_alias_map', {})
    conflicting = get_aliased_and_aliases(preexisting_aliases) & get_aliased_and_aliases(alias_d)
    if conflicting:
        raise NotImplementedError(f'Parent class already defines conflicting aliases: {conflicting}')
    cls._alias_map = {**preexisting_aliases, **alias_d}
    return cls

def select_matching_signature(funcs, *args, **kwargs):
    for (i, func) in enumerate(funcs):
        try:
            return func(*args, **kwargs)
        except TypeError:
            if i == len(funcs) - 1:
                raise

def nargs_error(name, takes, given):
    return TypeError(f'{name}() takes {takes} positional arguments but {given} were given')

def kwarg_error(name, kw):
    if not isinstance(kw, str):
        kw = next(iter(kw))
    return TypeError(f"{name}() got an unexpected keyword argument '{kw}'")

def recursive_subclasses(cls):
    yield cls
    for subcls in cls.__subclasses__():
        yield from recursive_subclasses(subcls)

def warn_external(message, category=None):
    kwargs = {}
    if sys.version_info[:2] >= (3, 12):
        basedir = pathlib.Path(__file__).parents[2]
        kwargs['skip_file_prefixes'] = (str(basedir / 'matplotlib'), str(basedir / 'mpl_toolkits'))
    else:
        frame = sys._getframe()
        for stacklevel in itertools.count(1):
            if frame is None:
                kwargs['stacklevel'] = stacklevel
                break
            if not re.match('\\A(matplotlib|mpl_toolkits)(\\Z|\\.(?!tests\\.))', frame.f_globals.get('__name__', '')):
                kwargs['stacklevel'] = stacklevel
                break
            frame = frame.f_back
        del frame
    warnings.warn(message, category, **kwargs)

# File: matplotlib-main/lib/matplotlib/_api/deprecation.py
""""""
import contextlib
import functools
import inspect
import math
import warnings

class MatplotlibDeprecationWarning(DeprecationWarning):

def _generate_deprecation_warning(since, message='', name='', alternative='', pending=False, obj_type='', addendum='', *, removal=''):
    if pending:
        if removal:
            raise ValueError('A pending deprecation cannot have a scheduled removal')
    else:
        if not removal:
            (macro, meso, *_) = since.split('.')
            removal = f'{macro}.{int(meso) + 2}'
        removal = f'in {removal}'
    if not message:
        message = ('The %(name)s %(obj_type)s' if obj_type else '%(name)s') + (' will be deprecated in a future version' if pending else ' was deprecated in Matplotlib %(since)s and will be removed %(removal)s') + '.' + (' Use %(alternative)s instead.' if alternative else '') + (' %(addendum)s' if addendum else '')
    warning_cls = PendingDeprecationWarning if pending else MatplotlibDeprecationWarning
    return warning_cls(message % dict(func=name, name=name, obj_type=obj_type, since=since, removal=removal, alternative=alternative, addendum=addendum))

def warn_deprecated(since, *, message='', name='', alternative='', pending=False, obj_type='', addendum='', removal=''):
    warning = _generate_deprecation_warning(since, message, name, alternative, pending, obj_type, addendum, removal=removal)
    from . import warn_external
    warn_external(warning, category=MatplotlibDeprecationWarning)

def deprecated(since, *, message='', name='', alternative='', pending=False, obj_type=None, addendum='', removal=''):

    def deprecate(obj, message=message, name=name, alternative=alternative, pending=pending, obj_type=obj_type, addendum=addendum):
        from matplotlib._api import classproperty
        if isinstance(obj, type):
            if obj_type is None:
                obj_type = 'class'
            func = obj.__init__
            name = name or obj.__name__
            old_doc = obj.__doc__

            def finalize(wrapper, new_doc):
                try:
                    obj.__doc__ = new_doc
                except AttributeError:
                    pass
                obj.__init__ = functools.wraps(obj.__init__)(wrapper)
                return obj
        elif isinstance(obj, (property, classproperty)):
            if obj_type is None:
                obj_type = 'attribute'
            func = None
            name = name or obj.fget.__name__
            old_doc = obj.__doc__

            class _deprecated_property(type(obj)):

                def __get__(self, instance, owner=None):
                    if instance is not None or (owner is not None and isinstance(self, classproperty)):
                        emit_warning()
                    return super().__get__(instance, owner)

                def __set__(self, instance, value):
                    if instance is not None:
                        emit_warning()
                    return super().__set__(instance, value)

                def __delete__(self, instance):
                    if instance is not None:
                        emit_warning()
                    return super().__delete__(instance)

                def __set_name__(self, owner, set_name):
                    nonlocal name
                    if name == '<lambda>':
                        name = set_name

            def finalize(_, new_doc):
                return _deprecated_property(fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc)
        else:
            if obj_type is None:
                obj_type = 'function'
            func = obj
            name = name or obj.__name__
            old_doc = func.__doc__

            def finalize(wrapper, new_doc):
                wrapper = functools.wraps(func)(wrapper)
                wrapper.__doc__ = new_doc
                return wrapper

        def emit_warning():
            warn_deprecated(since, message=message, name=name, alternative=alternative, pending=pending, obj_type=obj_type, addendum=addendum, removal=removal)

        def wrapper(*args, **kwargs):
            emit_warning()
            return func(*args, **kwargs)
        old_doc = inspect.cleandoc(old_doc or '').strip('\n')
        notes_header = '\nNotes\n-----'
        second_arg = ' '.join([t.strip() for t in (message, f'Use {alternative} instead.' if alternative else '', addendum) if t])
        new_doc = f"[*Deprecated*] {old_doc}\n{(notes_header if notes_header not in old_doc else '')}\n.. deprecated:: {since}\n   {second_arg}"
        if not old_doc:
            new_doc += '\\ '
        return finalize(wrapper, new_doc)
    return deprecate

class deprecate_privatize_attribute:

    def __init__(self, *args, **kwargs):
        self.deprecator = deprecated(*args, **kwargs)

    def __set_name__(self, owner, name):
        setattr(owner, name, self.deprecator(property(lambda self: getattr(self, f'_{name}'), lambda self, value: setattr(self, f'_{name}', value)), name=name))
DECORATORS = {}

def rename_parameter(since, old, new, func=None):
    decorator = functools.partial(rename_parameter, since, old, new)
    if func is None:
        return decorator
    signature = inspect.signature(func)
    assert old not in signature.parameters, f'Matplotlib internal error: {old!r} cannot be a parameter for {func.__name__}()'
    assert new in signature.parameters, f'Matplotlib internal error: {new!r} must be a parameter for {func.__name__}()'

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if old in kwargs:
            warn_deprecated(since, message=f'The {old!r} parameter of {func.__name__}() has been renamed {new!r} since Matplotlib {since}; support for the old name will be dropped %(removal)s.')
            kwargs[new] = kwargs.pop(old)
        return func(*args, **kwargs)
    DECORATORS[wrapper] = decorator
    return wrapper

class _deprecated_parameter_class:

    def __repr__(self):
        return '<deprecated parameter>'
_deprecated_parameter = _deprecated_parameter_class()

def delete_parameter(since, name, func=None, **kwargs):
    decorator = functools.partial(delete_parameter, since, name, **kwargs)
    if func is None:
        return decorator
    signature = inspect.signature(func)
    kwargs_name = next((param.name for param in signature.parameters.values() if param.kind == inspect.Parameter.VAR_KEYWORD), None)
    if name in signature.parameters:
        kind = signature.parameters[name].kind
        is_varargs = kind is inspect.Parameter.VAR_POSITIONAL
        is_varkwargs = kind is inspect.Parameter.VAR_KEYWORD
        if not is_varargs and (not is_varkwargs):
            name_idx = math.inf if kind is inspect.Parameter.KEYWORD_ONLY else [*signature.parameters].index(name)
            func.__signature__ = signature = signature.replace(parameters=[param.replace(default=_deprecated_parameter) if param.name == name else param for param in signature.parameters.values()])
        else:
            name_idx = -1
    else:
        is_varargs = is_varkwargs = False
        name_idx = math.inf
        assert kwargs_name, f'Matplotlib internal error: {name!r} must be a parameter for {func.__name__}()'
    addendum = kwargs.pop('addendum', None)

    @functools.wraps(func)
    def wrapper(*inner_args, **inner_kwargs):
        if len(inner_args) <= name_idx and name not in inner_kwargs:
            return func(*inner_args, **inner_kwargs)
        arguments = signature.bind(*inner_args, **inner_kwargs).arguments
        if is_varargs and arguments.get(name):
            warn_deprecated(since, message=f'Additional positional arguments to {func.__name__}() are deprecated since %(since)s and support for them will be removed %(removal)s.')
        elif is_varkwargs and arguments.get(name):
            warn_deprecated(since, message=f'Additional keyword arguments to {func.__name__}() are deprecated since %(since)s and support for them will be removed %(removal)s.')
        elif any((name in d and d[name] != _deprecated_parameter for d in [arguments, arguments.get(kwargs_name, {})])):
            deprecation_addendum = f'If any parameter follows {name!r}, they should be passed as keyword, not positionally.'
            warn_deprecated(since, name=repr(name), obj_type=f'parameter of {func.__name__}()', addendum=addendum + ' ' + deprecation_addendum if addendum else deprecation_addendum, **kwargs)
        return func(*inner_args, **inner_kwargs)
    DECORATORS[wrapper] = decorator
    return wrapper

def make_keyword_only(since, name, func=None):
    decorator = functools.partial(make_keyword_only, since, name)
    if func is None:
        return decorator
    signature = inspect.signature(func)
    POK = inspect.Parameter.POSITIONAL_OR_KEYWORD
    KWO = inspect.Parameter.KEYWORD_ONLY
    assert name in signature.parameters and signature.parameters[name].kind == POK, f'Matplotlib internal error: {name!r} must be a positional-or-keyword parameter for {func.__name__}(). If this error happens on a function with a pyplot wrapper, make sure make_keyword_only() is the outermost decorator.'
    names = [*signature.parameters]
    name_idx = names.index(name)
    kwonly = [name for name in names[name_idx:] if signature.parameters[name].kind == POK]

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if len(args) > name_idx:
            warn_deprecated(since, message='Passing the %(name)s %(obj_type)s positionally is deprecated since Matplotlib %(since)s; the parameter will become keyword-only %(removal)s.', name=name, obj_type=f'parameter of {func.__name__}()')
        return func(*args, **kwargs)
    wrapper.__signature__ = signature.replace(parameters=[param.replace(kind=KWO) if param.name in kwonly else param for param in signature.parameters.values()])
    DECORATORS[wrapper] = decorator
    return wrapper

def deprecate_method_override(method, obj, *, allow_empty=False, **kwargs):

    def empty():
        pass

    def empty_with_docstring():
    name = method.__name__
    bound_child = getattr(obj, name)
    bound_base = method if isinstance(bound_child, type(empty)) and isinstance(obj, type) else method.__get__(obj)
    if bound_child != bound_base and (not allow_empty or getattr(getattr(bound_child, '__code__', None), 'co_code', None) not in [empty.__code__.co_code, empty_with_docstring.__code__.co_code]):
        warn_deprecated(**{'name': name, 'obj_type': 'method', **kwargs})
        return bound_child
    return None

@contextlib.contextmanager
def suppress_matplotlib_deprecation_warning():
    with warnings.catch_warnings():
        warnings.simplefilter('ignore', MatplotlibDeprecationWarning)
        yield

# File: matplotlib-main/lib/matplotlib/_blocking_input.py
def blocking_input_loop(figure, event_names, timeout, handler):
    if figure.canvas.manager:
        figure.show()
    cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]
    try:
        figure.canvas.start_event_loop(timeout)
    finally:
        for cid in cids:
            figure.canvas.mpl_disconnect(cid)

# File: matplotlib-main/lib/matplotlib/_cm.py
""""""
from functools import partial
import numpy as np
_binary_data = {'red': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0)), 'green': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0))}
_autumn_data = {'red': ((0.0, 1.0, 1.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0))}
_bone_data = {'red': ((0.0, 0.0, 0.0), (0.746032, 0.652778, 0.652778), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.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, 0.0), (0.365079, 0.444444, 0.444444), (1.0, 1.0, 1.0))}
_cool_data = {'red': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 1.0, 1.0))}
_copper_data = {'red': ((0.0, 0.0, 0.0), (0.809524, 1.0, 1.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 0.7812, 0.7812)), 'blue': ((0.0, 0.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):
    xg = x ** gamma
    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 {'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))

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.0, (0.2, 0.2, 0.6)), (0.15, (0.0, 0.6, 1.0)), (0.25, (0.0, 0.8, 0.4)), (0.5, (1.0, 1.0, 0.6)), (0.75, (0.5, 0.36, 0.33)), (1.0, (1.0, 1.0, 1.0)))
_gray_data = {'red': ((0.0, 0, 0), (1.0, 1, 1)), 'green': ((0.0, 0, 0), (1.0, 1, 1)), 'blue': ((0.0, 0, 0), (1.0, 1, 1))}
_hot_data = {'red': ((0.0, 0.0416, 0.0416), (0.365079, 1.0, 1.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.365079, 0.0, 0.0), (0.746032, 1.0, 1.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (0.746032, 0.0, 0.0), (1.0, 1.0, 1.0))}
_hsv_data = {'red': ((0.0, 1.0, 1.0), (0.15873, 1.0, 1.0), (0.174603, 0.96875, 0.96875), (0.333333, 0.03125, 0.03125), (0.349206, 0.0, 0.0), (0.666667, 0.0, 0.0), (0.68254, 0.03125, 0.03125), (0.84127, 0.96875, 0.96875), (0.857143, 1.0, 1.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.15873, 0.9375, 0.9375), (0.174603, 1.0, 1.0), (0.507937, 1.0, 1.0), (0.666667, 0.0625, 0.0625), (0.68254, 0.0, 0.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 0.0, 0.0), (0.333333, 0.0, 0.0), (0.349206, 0.0625, 0.0625), (0.507937, 1.0, 1.0), (0.84127, 1.0, 1.0), (0.857143, 0.9375, 0.9375), (1.0, 0.09375, 0.09375))}
_jet_data = {'red': ((0.0, 0, 0), (0.35, 0, 0), (0.66, 1, 1), (0.89, 1, 1), (1.0, 0.5, 0.5)), 'green': ((0.0, 0, 0), (0.125, 0, 0), (0.375, 1, 1), (0.64, 1, 1), (0.91, 0, 0), (1.0, 0, 0)), 'blue': ((0.0, 0.5, 0.5), (0.11, 1, 1), (0.34, 1, 1), (0.65, 0, 0), (1.0, 0, 0))}
_pink_data = {'red': ((0.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.15873, 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.69198, 0.69198), (0.31746, 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.47619, 0.806718, 0.806718), (0.492063, 0.81325, 0.81325), (0.507937, 0.81973, 0.81973), (0.52381, 0.82616, 0.82616), (0.539683, 0.832539, 0.832539), (0.555556, 0.83887, 0.83887), (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.68254, 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.84127, 0.945611, 0.945611), (0.857143, 0.95119, 0.95119), (0.873016, 0.956736, 0.956736), (0.888889, 0.96225, 0.96225), (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, 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.15873, 0.3253, 0.3253), (0.174603, 0.341178, 0.341178), (0.190476, 0.356348, 0.356348), (0.206349, 0.370899, 0.370899), (0.222222, 0.3849, 0.3849), (0.238095, 0.39841, 0.39841), (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.31746, 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.47619, 0.643958, 0.643958), (0.492063, 0.662687, 0.662687), (0.507937, 0.6809, 0.6809), (0.52381, 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.82696, 0.82696), (0.666667, 0.841625, 0.841625), (0.68254, 0.85604, 0.85604), (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.84127, 0.945611, 0.945611), (0.857143, 0.95119, 0.95119), (0.873016, 0.956736, 0.956736), (0.888889, 0.96225, 0.96225), (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, 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.15873, 0.3253, 0.3253), (0.174603, 0.341178, 0.341178), (0.190476, 0.356348, 0.356348), (0.206349, 0.370899, 0.370899), (0.222222, 0.3849, 0.3849), (0.238095, 0.39841, 0.39841), (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.31746, 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.47619, 0.563436, 0.563436), (0.492063, 0.57275, 0.57275), (0.507937, 0.581914, 0.581914), (0.52381, 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.6506, 0.6506), (0.650794, 0.658682, 0.658682), (0.666667, 0.666667, 0.666667), (0.68254, 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.84127, 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.0, 1.0, 1.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0))}
_summer_data = {'red': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.5, 0.5), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.4, 0.4), (1.0, 0.4, 0.4))}
_winter_data = {'red': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 0.5, 0.5))}
_nipy_spectral_data = {'red': [(0.0, 0.0, 0.0), (0.05, 0.4667, 0.4667), (0.1, 0.5333, 0.5333), (0.15, 0.0, 0.0), (0.2, 0.0, 0.0), (0.25, 0.0, 0.0), (0.3, 0.0, 0.0), (0.35, 0.0, 0.0), (0.4, 0.0, 0.0), (0.45, 0.0, 0.0), (0.5, 0.0, 0.0), (0.55, 0.0, 0.0), (0.6, 0.0, 0.0), (0.65, 0.7333, 0.7333), (0.7, 0.9333, 0.9333), (0.75, 1.0, 1.0), (0.8, 1.0, 1.0), (0.85, 1.0, 1.0), (0.9, 0.8667, 0.8667), (0.95, 0.8, 0.8), (1.0, 0.8, 0.8)], 'green': [(0.0, 0.0, 0.0), (0.05, 0.0, 0.0), (0.1, 0.0, 0.0), (0.15, 0.0, 0.0), (0.2, 0.0, 0.0), (0.25, 0.4667, 0.4667), (0.3, 0.6, 0.6), (0.35, 0.6667, 0.6667), (0.4, 0.6667, 0.6667), (0.45, 0.6, 0.6), (0.5, 0.7333, 0.7333), (0.55, 0.8667, 0.8667), (0.6, 1.0, 1.0), (0.65, 1.0, 1.0), (0.7, 0.9333, 0.9333), (0.75, 0.8, 0.8), (0.8, 0.6, 0.6), (0.85, 0.0, 0.0), (0.9, 0.0, 0.0), (0.95, 0.0, 0.0), (1.0, 0.8, 0.8)], 'blue': [(0.0, 0.0, 0.0), (0.05, 0.5333, 0.5333), (0.1, 0.6, 0.6), (0.15, 0.6667, 0.6667), (0.2, 0.8667, 0.8667), (0.25, 0.8667, 0.8667), (0.3, 0.8667, 0.8667), (0.35, 0.6667, 0.6667), (0.4, 0.5333, 0.5333), (0.45, 0.0, 0.0), (0.5, 0.0, 0.0), (0.55, 0.0, 0.0), (0.6, 0.0, 0.0), (0.65, 0.0, 0.0), (0.7, 0.0, 0.0), (0.75, 0.0, 0.0), (0.8, 0.0, 0.0), (0.85, 0.0, 0.0), (0.9, 0.0, 0.0), (0.95, 0.0, 0.0), (1.0, 0.8, 0.8)]}
_Blues_data = ((0.9686274509803922, 0.984313725490196, 1.0), (0.8705882352941177, 0.9215686274509803, 0.9686274509803922), (0.7764705882352941, 0.8588235294117647, 0.9372549019607843), (0.6196078431372549, 0.792156862745098, 0.8823529411764706), (0.4196078431372549, 0.6823529411764706, 0.8392156862745098), (0.25882352941176473, 0.5725490196078431, 0.7764705882352941), (0.12941176470588237, 0.44313725490196076, 0.7098039215686275), (0.03137254901960784, 0.3176470588235294, 0.611764705882353), (0.03137254901960784, 0.18823529411764706, 0.4196078431372549))
_BrBG_data = ((0.32941176470588235, 0.18823529411764706, 0.0196078431372549), (0.5490196078431373, 0.3176470588235294, 0.0392156862745098), (0.7490196078431373, 0.5058823529411764, 0.17647058823529413), (0.8745098039215686, 0.7607843137254902, 0.49019607843137253), (0.9647058823529412, 0.9098039215686274, 0.7647058823529411), (0.9607843137254902, 0.9607843137254902, 0.9607843137254902), (0.7803921568627451, 0.9176470588235294, 0.8980392156862745), (0.5019607843137255, 0.803921568627451, 0.7568627450980392), (0.20784313725490197, 0.592156862745098, 0.5607843137254902), (0.00392156862745098, 0.4, 0.3686274509803922), (0.0, 0.23529411764705882, 0.18823529411764706))
_BuGn_data = ((0.9686274509803922, 0.9882352941176471, 0.9921568627450981), (0.8980392156862745, 0.9607843137254902, 0.9764705882352941), (0.8, 0.9254901960784314, 0.9019607843137255), (0.6, 0.8470588235294118, 0.788235294117647), (0.4, 0.7607843137254902, 0.6431372549019608), (0.2549019607843137, 0.6823529411764706, 0.4627450980392157), (0.13725490196078433, 0.5450980392156862, 0.27058823529411763), (0.0, 0.42745098039215684, 0.17254901960784313), (0.0, 0.26666666666666666, 0.10588235294117647))
_BuPu_data = ((0.9686274509803922, 0.9882352941176471, 0.9921568627450981), (0.8784313725490196, 0.9254901960784314, 0.9568627450980393), (0.7490196078431373, 0.8274509803921568, 0.9019607843137255), (0.6196078431372549, 0.7372549019607844, 0.8549019607843137), (0.5490196078431373, 0.5882352941176471, 0.7764705882352941), (0.5490196078431373, 0.4196078431372549, 0.6941176470588235), (0.5333333333333333, 0.2549019607843137, 0.615686274509804), (0.5058823529411764, 0.05882352941176471, 0.48627450980392156), (0.30196078431372547, 0.0, 0.29411764705882354))
_GnBu_data = ((0.9686274509803922, 0.9882352941176471, 0.9411764705882353), (0.8784313725490196, 0.9529411764705882, 0.8588235294117647), (0.8, 0.9215686274509803, 0.7725490196078432), (0.6588235294117647, 0.8666666666666667, 0.7098039215686275), (0.4823529411764706, 0.8, 0.7686274509803922), (0.3058823529411765, 0.7019607843137254, 0.8274509803921568), (0.16862745098039217, 0.5490196078431373, 0.7450980392156863), (0.03137254901960784, 0.40784313725490196, 0.6745098039215687), (0.03137254901960784, 0.25098039215686274, 0.5058823529411764))
_Greens_data = ((0.9686274509803922, 0.9882352941176471, 0.9607843137254902), (0.8980392156862745, 0.9607843137254902, 0.8784313725490196), (0.7803921568627451, 0.9137254901960784, 0.7529411764705882), (0.6313725490196078, 0.8509803921568627, 0.6078431372549019), (0.4549019607843137, 0.7686274509803922, 0.4627450980392157), (0.2549019607843137, 0.6705882352941176, 0.36470588235294116), (0.13725490196078433, 0.5450980392156862, 0.27058823529411763), (0.0, 0.42745098039215684, 0.17254901960784313), (0.0, 0.26666666666666666, 0.10588235294117647))
_Greys_data = ((1.0, 1.0, 1.0), (0.9411764705882353, 0.9411764705882353, 0.9411764705882353), (0.8509803921568627, 0.8509803921568627, 0.8509803921568627), (0.7411764705882353, 0.7411764705882353, 0.7411764705882353), (0.5882352941176471, 0.5882352941176471, 0.5882352941176471), (0.45098039215686275, 0.45098039215686275, 0.45098039215686275), (0.3215686274509804, 0.3215686274509804, 0.3215686274509804), (0.1450980392156863, 0.1450980392156863, 0.1450980392156863), (0.0, 0.0, 0.0))
_Oranges_data = ((1.0, 0.9607843137254902, 0.9215686274509803), (0.996078431372549, 0.9019607843137255, 0.807843137254902), (0.9921568627450981, 0.8156862745098039, 0.6352941176470588), (0.9921568627450981, 0.6823529411764706, 0.4196078431372549), (0.9921568627450981, 0.5529411764705883, 0.23529411764705882), (0.9450980392156862, 0.4117647058823529, 0.07450980392156863), (0.8509803921568627, 0.2823529411764706, 0.00392156862745098), (0.6509803921568628, 0.21176470588235294, 0.01176470588235294), (0.4980392156862745, 0.15294117647058825, 0.01568627450980392))
_OrRd_data = ((1.0, 0.9686274509803922, 0.9254901960784314), (0.996078431372549, 0.9098039215686274, 0.7843137254901961), (0.9921568627450981, 0.8313725490196079, 0.6196078431372549), (0.9921568627450981, 0.7333333333333333, 0.5176470588235295), (0.9882352941176471, 0.5529411764705883, 0.34901960784313724), (0.9372549019607843, 0.396078431372549, 0.2823529411764706), (0.8431372549019608, 0.18823529411764706, 0.12156862745098039), (0.7019607843137254, 0.0, 0.0), (0.4980392156862745, 0.0, 0.0))
_PiYG_data = ((0.5568627450980392, 0.00392156862745098, 0.3215686274509804), (0.7725490196078432, 0.10588235294117647, 0.49019607843137253), (0.8705882352941177, 0.4666666666666667, 0.6823529411764706), (0.9450980392156862, 0.7137254901960784, 0.8549019607843137), (0.9921568627450981, 0.8784313725490196, 0.9372549019607843), (0.9686274509803922, 0.9686274509803922, 0.9686274509803922), (0.9019607843137255, 0.9607843137254902, 0.8156862745098039), (0.7215686274509804, 0.8823529411764706, 0.5254901960784314), (0.4980392156862745, 0.7372549019607844, 0.2549019607843137), (0.30196078431372547, 0.5725490196078431, 0.12941176470588237), (0.15294117647058825, 0.39215686274509803, 0.09803921568627451))
_PRGn_data = ((0.25098039215686274, 0.0, 0.29411764705882354), (0.4627450980392157, 0.16470588235294117, 0.5137254901960784), (0.6, 0.4392156862745098, 0.6705882352941176), (0.7607843137254902, 0.6470588235294118, 0.8117647058823529), (0.9058823529411765, 0.8313725490196079, 0.9098039215686274), (0.9686274509803922, 0.9686274509803922, 0.9686274509803922), (0.8509803921568627, 0.9411764705882353, 0.8274509803921568), (0.6509803921568628, 0.8588235294117647, 0.6274509803921569), (0.35294117647058826, 0.6823529411764706, 0.3803921568627451), (0.10588235294117647, 0.47058823529411764, 0.21568627450980393), (0.0, 0.26666666666666666, 0.10588235294117647))
_PuBu_data = ((1.0, 0.9686274509803922, 0.984313725490196), (0.9254901960784314, 0.9058823529411765, 0.9490196078431372), (0.8156862745098039, 0.8196078431372549, 0.9019607843137255), (0.6509803921568628, 0.7411764705882353, 0.8588235294117647), (0.4549019607843137, 0.6627450980392157, 0.8117647058823529), (0.21176470588235294, 0.5647058823529412, 0.7529411764705882), (0.0196078431372549, 0.4392156862745098, 0.6901960784313725), (0.01568627450980392, 0.35294117647058826, 0.5529411764705883), (0.00784313725490196, 0.2196078431372549, 0.34509803921568627))
_PuBuGn_data = ((1.0, 0.9686274509803922, 0.984313725490196), (0.9254901960784314, 0.8862745098039215, 0.9411764705882353), (0.8156862745098039, 0.8196078431372549, 0.9019607843137255), (0.6509803921568628, 0.7411764705882353, 0.8588235294117647), (0.403921568627451, 0.6627450980392157, 0.8117647058823529), (0.21176470588235294, 0.5647058823529412, 0.7529411764705882), (0.00784313725490196, 0.5058823529411764, 0.5411764705882353), (0.00392156862745098, 0.4235294117647059, 0.34901960784313724), (0.00392156862745098, 0.27450980392156865, 0.21176470588235294))
_PuOr_data = ((0.4980392156862745, 0.23137254901960785, 0.03137254901960784), (0.7019607843137254, 0.34509803921568627, 0.02352941176470588), (0.8784313725490196, 0.5098039215686274, 0.0784313725490196), (0.9921568627450981, 0.7215686274509804, 0.38823529411764707), (0.996078431372549, 0.8784313725490196, 0.7137254901960784), (0.9686274509803922, 0.9686274509803922, 0.9686274509803922), (0.8470588235294118, 0.8549019607843137, 0.9215686274509803), (0.6980392156862745, 0.6705882352941176, 0.8235294117647058), (0.5019607843137255, 0.45098039215686275, 0.6745098039215687), (0.32941176470588235, 0.15294117647058825, 0.5333333333333333), (0.17647058823529413, 0.0, 0.29411764705882354))
_PuRd_data = ((0.9686274509803922, 0.9568627450980393, 0.9764705882352941), (0.9058823529411765, 0.8823529411764706, 0.9372549019607843), (0.8313725490196079, 0.7254901960784313, 0.8549019607843137), (0.788235294117647, 0.5803921568627451, 0.7803921568627451), (0.8745098039215686, 0.396078431372549, 0.6901960784313725), (0.9058823529411765, 0.1607843137254902, 0.5411764705882353), (0.807843137254902, 0.07058823529411765, 0.33725490196078434), (0.596078431372549, 0.0, 0.2627450980392157), (0.403921568627451, 0.0, 0.12156862745098039))
_Purples_data = ((0.9882352941176471, 0.984313725490196, 0.9921568627450981), (0.9372549019607843, 0.9294117647058824, 0.9607843137254902), (0.8549019607843137, 0.8549019607843137, 0.9215686274509803), (0.7372549019607844, 0.7411764705882353, 0.8627450980392157), (0.6196078431372549, 0.6039215686274509, 0.7843137254901961), (0.5019607843137255, 0.49019607843137253, 0.7294117647058823), (0.41568627450980394, 0.3176470588235294, 0.6392156862745098), (0.32941176470588235, 0.15294117647058825, 0.5607843137254902), (0.24705882352941178, 0.0, 0.49019607843137253))
_RdBu_data = ((0.403921568627451, 0.0, 0.12156862745098039), (0.6980392156862745, 0.09411764705882353, 0.16862745098039217), (0.8392156862745098, 0.3764705882352941, 0.30196078431372547), (0.9568627450980393, 0.6470588235294118, 0.5098039215686274), (0.9921568627450981, 0.8588235294117647, 0.7803921568627451), (0.9686274509803922, 0.9686274509803922, 0.9686274509803922), (0.8196078431372549, 0.8980392156862745, 0.9411764705882353), (0.5725490196078431, 0.7725490196078432, 0.8705882352941177), (0.2627450980392157, 0.5764705882352941, 0.7647058823529411), (0.12941176470588237, 0.4, 0.6745098039215687), (0.0196078431372549, 0.18823529411764706, 0.3803921568627451))
_RdGy_data = ((0.403921568627451, 0.0, 0.12156862745098039), (0.6980392156862745, 0.09411764705882353, 0.16862745098039217), (0.8392156862745098, 0.3764705882352941, 0.30196078431372547), (0.9568627450980393, 0.6470588235294118, 0.5098039215686274), (0.9921568627450981, 0.8588235294117647, 0.7803921568627451), (1.0, 1.0, 1.0), (0.8784313725490196, 0.8784313725490196, 0.8784313725490196), (0.7294117647058823, 0.7294117647058823, 0.7294117647058823), (0.5294117647058824, 0.5294117647058824, 0.5294117647058824), (0.30196078431372547, 0.30196078431372547, 0.30196078431372547), (0.10196078431372549, 0.10196078431372549, 0.10196078431372549))
_RdPu_data = ((1.0, 0.9686274509803922, 0.9529411764705882), (0.9921568627450981, 0.8784313725490196, 0.8666666666666667), (0.9882352941176471, 0.7725490196078432, 0.7529411764705882), (0.9803921568627451, 0.6235294117647059, 0.7098039215686275), (0.9686274509803922, 0.40784313725490196, 0.6313725490196078), (0.8666666666666667, 0.20392156862745098, 0.592156862745098), (0.6823529411764706, 0.00392156862745098, 0.49411764705882355), (0.47843137254901963, 0.00392156862745098, 0.4666666666666667), (0.28627450980392155, 0.0, 0.41568627450980394))
_RdYlBu_data = ((0.6470588235294118, 0.0, 0.14901960784313725), (0.8431372549019608, 0.18823529411764706, 0.15294117647058825), (0.9568627450980393, 0.42745098039215684, 0.2627450980392157), (0.9921568627450981, 0.6823529411764706, 0.3803921568627451), (0.996078431372549, 0.8784313725490196, 0.5647058823529412), (1.0, 1.0, 0.7490196078431373), (0.8784313725490196, 0.9529411764705882, 0.9725490196078431), (0.6705882352941176, 0.8509803921568627, 0.9137254901960784), (0.4549019607843137, 0.6784313725490196, 0.8196078431372549), (0.27058823529411763, 0.4588235294117647, 0.7058823529411765), (0.19215686274509805, 0.21176470588235294, 0.5843137254901961))
_RdYlGn_data = ((0.6470588235294118, 0.0, 0.14901960784313725), (0.8431372549019608, 0.18823529411764706, 0.15294117647058825), (0.9568627450980393, 0.42745098039215684, 0.2627450980392157), (0.9921568627450981, 0.6823529411764706, 0.3803921568627451), (0.996078431372549, 0.8784313725490196, 0.5450980392156862), (1.0, 1.0, 0.7490196078431373), (0.8509803921568627, 0.9372549019607843, 0.5450980392156862), (0.6509803921568628, 0.8509803921568627, 0.41568627450980394), (0.4, 0.7411764705882353, 0.38823529411764707), (0.10196078431372549, 0.596078431372549, 0.3137254901960784), (0.0, 0.40784313725490196, 0.21568627450980393))
_Reds_data = ((1.0, 0.9607843137254902, 0.9411764705882353), (0.996078431372549, 0.8784313725490196, 0.8235294117647058), (0.9882352941176471, 0.7333333333333333, 0.6313725490196078), (0.9882352941176471, 0.5725490196078431, 0.4470588235294118), (0.984313725490196, 0.41568627450980394, 0.2901960784313726), (0.9372549019607843, 0.23137254901960785, 0.17254901960784313), (0.796078431372549, 0.09411764705882353, 0.11372549019607843), (0.6470588235294118, 0.058823529411764705, 0.08235294117647057), (0.403921568627451, 0.0, 0.05098039215686274))
_Spectral_data = ((0.6196078431372549, 0.00392156862745098, 0.25882352941176473), (0.8352941176470589, 0.24313725490196078, 0.30980392156862746), (0.9568627450980393, 0.42745098039215684, 0.2627450980392157), (0.9921568627450981, 0.6823529411764706, 0.3803921568627451), (0.996078431372549, 0.8784313725490196, 0.5450980392156862), (1.0, 1.0, 0.7490196078431373), (0.9019607843137255, 0.9607843137254902, 0.596078431372549), (0.6705882352941176, 0.8666666666666667, 0.6431372549019608), (0.4, 0.7607843137254902, 0.6470588235294118), (0.19607843137254902, 0.5333333333333333, 0.7411764705882353), (0.3686274509803922, 0.30980392156862746, 0.6352941176470588))
_YlGn_data = ((1.0, 1.0, 0.8980392156862745), (0.9686274509803922, 0.9882352941176471, 0.7254901960784313), (0.8509803921568627, 0.9411764705882353, 0.6392156862745098), (0.6784313725490196, 0.8666666666666667, 0.5568627450980392), (0.47058823529411764, 0.7764705882352941, 0.4745098039215686), (0.2549019607843137, 0.6705882352941176, 0.36470588235294116), (0.13725490196078433, 0.5176470588235295, 0.2627450980392157), (0.0, 0.40784313725490196, 0.21568627450980393), (0.0, 0.27058823529411763, 0.1607843137254902))
_YlGnBu_data = ((1.0, 1.0, 0.8509803921568627), (0.9294117647058824, 0.9725490196078431, 0.6941176470588235), (0.7803921568627451, 0.9137254901960784, 0.7058823529411765), (0.4980392156862745, 0.803921568627451, 0.7333333333333333), (0.2549019607843137, 0.7137254901960784, 0.7686274509803922), (0.11372549019607843, 0.5686274509803921, 0.7529411764705882), (0.13333333333333333, 0.3686274509803922, 0.6588235294117647), (0.1450980392156863, 0.20392156862745098, 0.5803921568627451), (0.03137254901960784, 0.11372549019607843, 0.34509803921568627))
_YlOrBr_data = ((1.0, 1.0, 0.8980392156862745), (1.0, 0.9686274509803922, 0.7372549019607844), (0.996078431372549, 0.8901960784313725, 0.5686274509803921), (0.996078431372549, 0.7686274509803922, 0.30980392156862746), (0.996078431372549, 0.6, 0.1607843137254902), (0.9254901960784314, 0.4392156862745098, 0.0784313725490196), (0.8, 0.2980392156862745, 0.00784313725490196), (0.6, 0.20392156862745098, 0.01568627450980392), (0.4, 0.1450980392156863, 0.02352941176470588))
_YlOrRd_data = ((1.0, 1.0, 0.8), (1.0, 0.9294117647058824, 0.6274509803921569), (0.996078431372549, 0.8509803921568627, 0.4627450980392157), (0.996078431372549, 0.6980392156862745, 0.2980392156862745), (0.9921568627450981, 0.5529411764705883, 0.23529411764705882), (0.9882352941176471, 0.3058823529411765, 0.16470588235294117), (0.8901960784313725, 0.10196078431372549, 0.10980392156862745), (0.7411764705882353, 0.0, 0.14901960784313725), (0.5019607843137255, 0.0, 0.14901960784313725))
_Accent_data = ((0.4980392156862745, 0.788235294117647, 0.4980392156862745), (0.7450980392156863, 0.6823529411764706, 0.8313725490196079), (0.9921568627450981, 0.7529411764705882, 0.5254901960784314), (1.0, 1.0, 0.6), (0.2196078431372549, 0.4235294117647059, 0.6901960784313725), (0.9411764705882353, 0.00784313725490196, 0.4980392156862745), (0.7490196078431373, 0.3568627450980392, 0.09019607843137253), (0.4, 0.4, 0.4))
_Dark2_data = ((0.10588235294117647, 0.6196078431372549, 0.4666666666666667), (0.8509803921568627, 0.37254901960784315, 0.00784313725490196), (0.4588235294117647, 0.4392156862745098, 0.7019607843137254), (0.9058823529411765, 0.1607843137254902, 0.5411764705882353), (0.4, 0.6509803921568628, 0.11764705882352941), (0.9019607843137255, 0.6705882352941176, 0.00784313725490196), (0.6509803921568628, 0.4627450980392157, 0.11372549019607843), (0.4, 0.4, 0.4))
_Paired_data = ((0.6509803921568628, 0.807843137254902, 0.8901960784313725), (0.12156862745098039, 0.47058823529411764, 0.7058823529411765), (0.6980392156862745, 0.8745098039215686, 0.5411764705882353), (0.2, 0.6274509803921569, 0.17254901960784313), (0.984313725490196, 0.6039215686274509, 0.6), (0.8901960784313725, 0.10196078431372549, 0.10980392156862745), (0.9921568627450981, 0.7490196078431373, 0.43529411764705883), (1.0, 0.4980392156862745, 0.0), (0.792156862745098, 0.6980392156862745, 0.8392156862745098), (0.41568627450980394, 0.23921568627450981, 0.6039215686274509), (1.0, 1.0, 0.6), (0.6941176470588235, 0.34901960784313724, 0.1568627450980392))
_Pastel1_data = ((0.984313725490196, 0.7058823529411765, 0.6823529411764706), (0.7019607843137254, 0.803921568627451, 0.8901960784313725), (0.8, 0.9215686274509803, 0.7725490196078432), (0.8705882352941177, 0.796078431372549, 0.8941176470588236), (0.996078431372549, 0.8509803921568627, 0.6509803921568628), (1.0, 1.0, 0.8), (0.8980392156862745, 0.8470588235294118, 0.7411764705882353), (0.9921568627450981, 0.8549019607843137, 0.9254901960784314), (0.9490196078431372, 0.9490196078431372, 0.9490196078431372))
_Pastel2_data = ((0.7019607843137254, 0.8862745098039215, 0.803921568627451), (0.9921568627450981, 0.803921568627451, 0.6745098039215687), (0.796078431372549, 0.8352941176470589, 0.9098039215686274), (0.9568627450980393, 0.792156862745098, 0.8941176470588236), (0.9019607843137255, 0.9607843137254902, 0.788235294117647), (1.0, 0.9490196078431372, 0.6823529411764706), (0.9450980392156862, 0.8862745098039215, 0.8), (0.8, 0.8, 0.8))
_Set1_data = ((0.8941176470588236, 0.10196078431372549, 0.10980392156862745), (0.21568627450980393, 0.49411764705882355, 0.7215686274509804), (0.30196078431372547, 0.6862745098039216, 0.2901960784313726), (0.596078431372549, 0.3058823529411765, 0.6392156862745098), (1.0, 0.4980392156862745, 0.0), (1.0, 1.0, 0.2), (0.6509803921568628, 0.33725490196078434, 0.1568627450980392), (0.9686274509803922, 0.5058823529411764, 0.7490196078431373), (0.6, 0.6, 0.6))
_Set2_data = ((0.4, 0.7607843137254902, 0.6470588235294118), (0.9882352941176471, 0.5529411764705883, 0.3843137254901961), (0.5529411764705883, 0.6274509803921569, 0.796078431372549), (0.9058823529411765, 0.5411764705882353, 0.7647058823529411), (0.6509803921568628, 0.8470588235294118, 0.32941176470588235), (1.0, 0.8509803921568627, 0.1843137254901961), (0.8980392156862745, 0.7686274509803922, 0.5803921568627451), (0.7019607843137254, 0.7019607843137254, 0.7019607843137254))
_Set3_data = ((0.5529411764705883, 0.8274509803921568, 0.7803921568627451), (1.0, 1.0, 0.7019607843137254), (0.7450980392156863, 0.7294117647058823, 0.8549019607843137), (0.984313725490196, 0.5019607843137255, 0.4470588235294118), (0.5019607843137255, 0.6941176470588235, 0.8274509803921568), (0.9921568627450981, 0.7058823529411765, 0.3843137254901961), (0.7019607843137254, 0.8705882352941177, 0.4117647058823529), (0.9882352941176471, 0.803921568627451, 0.8980392156862745), (0.8509803921568627, 0.8509803921568627, 0.8509803921568627), (0.7372549019607844, 0.5019607843137255, 0.7411764705882353), (0.8, 0.9215686274509803, 0.7725490196078432), (1.0, 0.9294117647058824, 0.43529411764705883))
_gist_earth_data = {'red': ((0.0, 0.0, 0.0), (0.2824, 0.1882, 0.1882), (0.4588, 0.2714, 0.2714), (0.549, 0.4719, 0.4719), (0.698, 0.7176, 0.7176), (0.7882, 0.7553, 0.7553), (1.0, 0.9922, 0.9922)), 'green': ((0.0, 0.0, 0.0), (0.0275, 0.0, 0.0), (0.1098, 0.1893, 0.1893), (0.1647, 0.3035, 0.3035), (0.2078, 0.3841, 0.3841), (0.2824, 0.502, 0.502), (0.5216, 0.6397, 0.6397), (0.698, 0.7171, 0.7171), (0.7882, 0.6392, 0.6392), (0.7922, 0.6413, 0.6413), (0.8, 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.898, 0.743, 0.743), (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.0, 0.9843, 0.9843)), 'blue': ((0.0, 0.0, 0.0), (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.0, 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.0), (0.3098, 0.0, 0.0), (0.3725, 0.3993, 0.3993), (0.4235, 0.5003, 0.5003), (0.5333, 1.0, 1.0), (0.7922, 1.0, 1.0), (0.8471, 0.6218, 0.6218), (0.898, 0.9235, 0.9235), (1.0, 0.9961, 0.9961)), 'green': ((0.0, 0.0, 0.0), (0.051, 0.3722, 0.3722), (0.1059, 0.0, 0.0), (0.1569, 0.7202, 0.7202), (0.1608, 0.7537, 0.7537), (0.1647, 0.7752, 0.7752), (0.2157, 1.0, 1.0), (0.2588, 0.9804, 0.9804), (0.2706, 0.9804, 0.9804), (0.3176, 1.0, 1.0), (0.3686, 0.8081, 0.8081), (0.4275, 1.0, 1.0), (0.5216, 1.0, 1.0), (0.6314, 0.7292, 0.7292), (0.6863, 0.2796, 0.2796), (0.7451, 0.0, 0.0), (0.7922, 0.0, 0.0), (0.8431, 0.1753, 0.1753), (0.898, 0.5, 0.5), (1.0, 0.9725, 0.9725)), 'blue': ((0.0, 0.502, 0.502), (0.051, 0.0222, 0.0222), (0.1098, 1.0, 1.0), (0.2039, 1.0, 1.0), (0.2627, 0.6145, 0.6145), (0.3216, 0.0, 0.0), (0.4157, 0.0, 0.0), (0.4745, 0.2342, 0.2342), (0.5333, 0.0, 0.0), (0.5804, 0.0, 0.0), (0.6314, 0.0549, 0.0549), (0.6902, 0.0, 0.0), (0.7373, 0.0, 0.0), (0.7922, 0.9738, 0.9738), (0.8, 1.0, 1.0), (0.8431, 1.0, 1.0), (0.898, 0.9341, 0.9341), (1.0, 0.9961, 0.9961))}
_gist_rainbow_data = ((0.0, (1.0, 0.0, 0.16)), (0.03, (1.0, 0.0, 0.0)), (0.215, (1.0, 1.0, 0.0)), (0.4, (0.0, 1.0, 0.0)), (0.586, (0.0, 1.0, 1.0)), (0.77, (0.0, 0.0, 1.0)), (0.954, (1.0, 0.0, 1.0)), (1.0, (1.0, 0.0, 0.75)))
_gist_stern_data = {'red': ((0.0, 0.0, 0.0), (0.0547, 1.0, 1.0), (0.25, 0.027, 0.25), (1.0, 1.0, 1.0)), 'green': ((0, 0, 0), (1, 1, 1)), 'blue': ((0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (0.735, 0.0, 0.0), (1.0, 1.0, 1.0))}

def _gist_yarg(x):
    return 1 - x
_gist_yarg_data = {'red': _gist_yarg, 'green': _gist_yarg, 'blue': _gist_yarg}
_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)]}
_CMRmap_data = {'red': ((0.0, 0.0, 0.0), (0.125, 0.15, 0.15), (0.25, 0.3, 0.3), (0.375, 0.6, 0.6), (0.5, 1.0, 1.0), (0.625, 0.9, 0.9), (0.75, 0.9, 0.9), (0.875, 0.9, 0.9), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.125, 0.15, 0.15), (0.25, 0.15, 0.15), (0.375, 0.2, 0.2), (0.5, 0.25, 0.25), (0.625, 0.5, 0.5), (0.75, 0.75, 0.75), (0.875, 0.9, 0.9), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (0.125, 0.5, 0.5), (0.25, 0.75, 0.75), (0.375, 0.5, 0.5), (0.5, 0.15, 0.15), (0.625, 0.0, 0.0), (0.75, 0.1, 0.1), (0.875, 0.5, 0.5), (1.0, 1.0, 1.0))}
_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)]}
_tab10_data = ((0.12156862745098039, 0.4666666666666667, 0.7058823529411765), (1.0, 0.4980392156862745, 0.054901960784313725), (0.17254901960784313, 0.6274509803921569, 0.17254901960784313), (0.8392156862745098, 0.15294117647058825, 0.1568627450980392), (0.5803921568627451, 0.403921568627451, 0.7411764705882353), (0.5490196078431373, 0.33725490196078434, 0.29411764705882354), (0.8901960784313725, 0.4666666666666667, 0.7607843137254902), (0.4980392156862745, 0.4980392156862745, 0.4980392156862745), (0.7372549019607844, 0.7411764705882353, 0.13333333333333333), (0.09019607843137255, 0.7450980392156863, 0.8117647058823529))
_tab20_data = ((0.12156862745098039, 0.4666666666666667, 0.7058823529411765), (0.6823529411764706, 0.7803921568627451, 0.9098039215686274), (1.0, 0.4980392156862745, 0.054901960784313725), (1.0, 0.7333333333333333, 0.47058823529411764), (0.17254901960784313, 0.6274509803921569, 0.17254901960784313), (0.596078431372549, 0.8745098039215686, 0.5411764705882353), (0.8392156862745098, 0.15294117647058825, 0.1568627450980392), (1.0, 0.596078431372549, 0.5882352941176471), (0.5803921568627451, 0.403921568627451, 0.7411764705882353), (0.7725490196078432, 0.6901960784313725, 0.8352941176470589), (0.5490196078431373, 0.33725490196078434, 0.29411764705882354), (0.7686274509803922, 0.611764705882353, 0.5803921568627451), (0.8901960784313725, 0.4666666666666667, 0.7607843137254902), (0.9686274509803922, 0.7137254901960784, 0.8235294117647058), (0.4980392156862745, 0.4980392156862745, 0.4980392156862745), (0.7803921568627451, 0.7803921568627451, 0.7803921568627451), (0.7372549019607844, 0.7411764705882353, 0.13333333333333333), (0.8588235294117647, 0.8588235294117647, 0.5529411764705883), (0.09019607843137255, 0.7450980392156863, 0.8117647058823529), (0.6196078431372549, 0.8549019607843137, 0.8980392156862745))
_tab20b_data = ((0.2235294117647059, 0.23137254901960785, 0.4745098039215686), (0.3215686274509804, 0.32941176470588235, 0.6392156862745098), (0.4196078431372549, 0.43137254901960786, 0.8117647058823529), (0.611764705882353, 0.6196078431372549, 0.8705882352941177), (0.38823529411764707, 0.4745098039215686, 0.2235294117647059), (0.5490196078431373, 0.6352941176470588, 0.3215686274509804), (0.7098039215686275, 0.8117647058823529, 0.4196078431372549), (0.807843137254902, 0.8588235294117647, 0.611764705882353), (0.5490196078431373, 0.42745098039215684, 0.19215686274509805), (0.7411764705882353, 0.6196078431372549, 0.2235294117647059), (0.9058823529411765, 0.7294117647058823, 0.3215686274509804), (0.9058823529411765, 0.796078431372549, 0.5803921568627451), (0.5176470588235295, 0.23529411764705882, 0.2235294117647059), (0.6784313725490196, 0.28627450980392155, 0.2901960784313726), (0.8392156862745098, 0.3803921568627451, 0.4196078431372549), (0.9058823529411765, 0.5882352941176471, 0.611764705882353), (0.4823529411764706, 0.2549019607843137, 0.45098039215686275), (0.6470588235294118, 0.3176470588235294, 0.5803921568627451), (0.807843137254902, 0.42745098039215684, 0.7411764705882353), (0.8705882352941177, 0.6196078431372549, 0.8392156862745098))
_tab20c_data = ((0.19215686274509805, 0.5098039215686274, 0.7411764705882353), (0.4196078431372549, 0.6823529411764706, 0.8392156862745098), (0.6196078431372549, 0.792156862745098, 0.8823529411764706), (0.7764705882352941, 0.8588235294117647, 0.9372549019607843), (0.9019607843137255, 0.3333333333333333, 0.050980392156862744), (0.9921568627450981, 0.5529411764705883, 0.23529411764705882), (0.9921568627450981, 0.6823529411764706, 0.4196078431372549), (0.9921568627450981, 0.8156862745098039, 0.6352941176470588), (0.19215686274509805, 0.6392156862745098, 0.32941176470588235), (0.4549019607843137, 0.7686274509803922, 0.4627450980392157), (0.6313725490196078, 0.8509803921568627, 0.6078431372549019), (0.7803921568627451, 0.9137254901960784, 0.7529411764705882), (0.4588235294117647, 0.4196078431372549, 0.6941176470588235), (0.6196078431372549, 0.6039215686274509, 0.7843137254901961), (0.7372549019607844, 0.7411764705882353, 0.8627450980392157), (0.8549019607843137, 0.8549019607843137, 0.9215686274509803), (0.38823529411764707, 0.38823529411764707, 0.38823529411764707), (0.5882352941176471, 0.5882352941176471, 0.5882352941176471), (0.7411764705882353, 0.7411764705882353, 0.7411764705882353), (0.8509803921568627, 0.8509803921568627, 0.8509803921568627))
_petroff10_data = ((0.24705882352941178, 0.5647058823529412, 0.8549019607843137), (1.0, 0.6627450980392157, 0.054901960784313725), (0.7411764705882353, 0.12156862745098039, 0.00392156862745098), (0.5803921568627451, 0.6431372549019608, 0.6352941176470588), (0.5137254901960784, 0.17647058823529413, 0.7137254901960784), (0.6627450980392157, 0.4196078431372549, 0.34901960784313724), (0.9058823529411765, 0.38823529411764707, 0.0), (0.7254901960784313, 0.6745098039215687, 0.4392156862745098), (0.44313725490196076, 0.4588235294117647, 0.5058823529411764), (0.5725490196078431, 0.8549019607843137, 0.8666666666666667))
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, '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}}

# File: matplotlib-main/lib/matplotlib/_cm_bivar.py
import numpy as np
from matplotlib.colors import SegmentedBivarColormap
BiPeak = np.array([0.0, 0.674, 0.931, 0.0, 0.68, 0.922, 0.0, 0.685, 0.914, 0.0, 0.691, 0.906, 0.0, 0.696, 0.898, 0.0, 0.701, 0.89, 0.0, 0.706, 0.882, 0.0, 0.711, 0.875, 0.0, 0.715, 0.867, 0.0, 0.72, 0.86, 0.0, 0.725, 0.853, 0.0, 0.729, 0.845, 0.0, 0.733, 0.838, 0.0, 0.737, 0.831, 0.0, 0.741, 0.824, 0.0, 0.745, 0.816, 0.0, 0.749, 0.809, 0.0, 0.752, 0.802, 0.0, 0.756, 0.794, 0.0, 0.759, 0.787, 0.0, 0.762, 0.779, 0.0, 0.765, 0.771, 0.0, 0.767, 0.764, 0.0, 0.77, 0.755, 0.0, 0.772, 0.747, 0.0, 0.774, 0.739, 0.0, 0.776, 0.73, 0.0, 0.777, 0.721, 0.0, 0.779, 0.712, 0.021, 0.78, 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.65, 0.132, 0.782, 0.639, 0.14, 0.781, 0.627, 0.147, 0.781, 0.615, 0.154, 0.78, 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.18, 0.768, 0.52, 0.184, 0.766, 0.505, 0.187, 0.763, 0.49, 0.19, 0.76, 0.474, 0.193, 0.756, 0.458, 0.196, 0.753, 0.442, 0.2, 0.749, 0.425, 0.203, 0.745, 0.408, 0.206, 0.741, 0.391, 0.21, 0.736, 0.373, 0.213, 0.732, 0.355, 0.216, 0.727, 0.337, 0.22, 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.69, 0.19, 0.246, 0.684, 0.165, 0.25, 0.678, 0.136, 0.0, 0.675, 0.934, 0.0, 0.681, 0.925, 0.0, 0.687, 0.917, 0.0, 0.692, 0.909, 0.0, 0.697, 0.901, 0.0, 0.703, 0.894, 0.0, 0.708, 0.886, 0.0, 0.713, 0.879, 0.0, 0.718, 0.872, 0.0, 0.722, 0.864, 0.0, 0.727, 0.857, 0.0, 0.731, 0.85, 0.0, 0.736, 0.843, 0.0, 0.74, 0.836, 0.0, 0.744, 0.829, 0.0, 0.748, 0.822, 0.0, 0.752, 0.815, 0.0, 0.755, 0.808, 0.0, 0.759, 0.8, 0.0, 0.762, 0.793, 0.0, 0.765, 0.786, 0.0, 0.768, 0.778, 0.0, 0.771, 0.77, 0.0, 0.773, 0.762, 0.051, 0.776, 0.754, 0.087, 0.778, 0.746, 0.111, 0.78, 0.737, 0.131, 0.782, 0.728, 0.146, 0.783, 0.719, 0.159, 0.784, 0.71, 0.171, 0.785, 0.7, 0.18, 0.786, 0.69, 0.189, 0.786, 0.68, 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.61, 0.224, 0.782, 0.597, 0.227, 0.781, 0.584, 0.23, 0.779, 0.57, 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.24, 0.766, 0.497, 0.242, 0.763, 0.481, 0.244, 0.76, 0.465, 0.246, 0.756, 0.448, 0.248, 0.752, 0.432, 0.25, 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.73, 0.343, 0.261, 0.725, 0.324, 0.264, 0.72, 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.22, 0.277, 0.692, 0.196, 0.28, 0.686, 0.17, 0.283, 0.68, 0.143, 0.0, 0.676, 0.937, 0.0, 0.682, 0.928, 0.0, 0.688, 0.92, 0.0, 0.694, 0.913, 0.0, 0.699, 0.905, 0.0, 0.704, 0.897, 0.0, 0.71, 0.89, 0.0, 0.715, 0.883, 0.0, 0.72, 0.876, 0.0, 0.724, 0.869, 0.0, 0.729, 0.862, 0.0, 0.734, 0.855, 0.0, 0.738, 0.848, 0.0, 0.743, 0.841, 0.0, 0.747, 0.834, 0.0, 0.751, 0.827, 0.0, 0.755, 0.82, 0.0, 0.759, 0.813, 0.0, 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.17, 0.78, 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.79, 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.79, 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.28, 0.779, 0.549, 0.282, 0.776, 0.535, 0.283, 0.773, 0.519, 0.284, 0.77, 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.31, 0.3, 0.717, 0.29, 0.302, 0.712, 0.269, 0.304, 0.706, 0.247, 0.306, 0.7, 0.225, 0.308, 0.694, 0.201, 0.31, 0.688, 0.176, 0.312, 0.682, 0.149, 0.0, 0.678, 0.939, 0.0, 0.683, 0.931, 0.0, 0.689, 0.923, 0.0, 0.695, 0.916, 0.0, 0.701, 0.908, 0.0, 0.706, 0.901, 0.0, 0.711, 0.894, 0.0, 0.717, 0.887, 0.0, 0.722, 0.88, 0.0, 0.727, 0.873, 0.0, 0.732, 0.866, 0.0, 0.736, 0.859, 0.0, 0.741, 0.853, 0.0, 0.745, 0.846, 0.0, 0.75, 0.839, 0.0, 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.76, 0.257, 0.788, 0.752, 0.266, 0.79, 0.743, 0.273, 0.791, 0.734, 0.28, 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.31, 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.32, 0.783, 0.557, 0.32, 0.78, 0.542, 0.321, 0.777, 0.527, 0.321, 0.774, 0.511, 0.322, 0.77, 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.75, 0.41, 0.325, 0.745, 0.391, 0.326, 0.741, 0.373, 0.327, 0.736, 0.354, 0.328, 0.73, 0.335, 0.329, 0.725, 0.315, 0.33, 0.72, 0.295, 0.331, 0.714, 0.274, 0.333, 0.708, 0.253, 0.334, 0.702, 0.23, 0.336, 0.696, 0.207, 0.337, 0.69, 0.182, 0.339, 0.684, 0.154, 0.0, 0.679, 0.942, 0.0, 0.685, 0.934, 0.0, 0.691, 0.927, 0.0, 0.696, 0.919, 0.0, 0.702, 0.912, 0.0, 0.708, 0.905, 0.0, 0.713, 0.898, 0.0, 0.718, 0.891, 0.0, 0.724, 0.884, 0.0, 0.729, 0.877, 0.0, 0.734, 0.871, 0.0, 0.739, 0.864, 0.0, 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.79, 0.276, 0.785, 0.783, 0.286, 0.788, 0.775, 0.296, 0.79, 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.8, 0.693, 0.344, 0.8, 0.682, 0.347, 0.799, 0.67, 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.77, 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.36, 0.357, 0.733, 0.34, 0.357, 0.728, 0.321, 0.358, 0.722, 0.3, 0.359, 0.716, 0.279, 0.36, 0.71, 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.16, 0.0, 0.68, 0.945, 0.0, 0.686, 0.937, 0.0, 0.692, 0.93, 0.0, 0.698, 0.922, 0.0, 0.703, 0.915, 0.0, 0.709, 0.908, 0.0, 0.715, 0.901, 0.0, 0.72, 0.894, 0.0, 0.726, 0.888, 0.0, 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.85, 0.208, 0.76, 0.843, 0.227, 0.764, 0.837, 0.245, 0.768, 0.83, 0.26, 0.772, 0.824, 0.275, 0.776, 0.817, 0.288, 0.779, 0.811, 0.3, 0.783, 0.804, 0.31, 0.786, 0.797, 0.32, 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.8, 0.749, 0.363, 0.801, 0.74, 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.38, 0.804, 0.69, 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.8, 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.77, 0.475, 0.384, 0.765, 0.457, 0.384, 0.761, 0.44, 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.73, 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.24, 0.386, 0.7, 0.217, 0.386, 0.694, 0.192, 0.387, 0.687, 0.165, 0.0, 0.68, 0.948, 0.0, 0.687, 0.94, 0.0, 0.693, 0.933, 0.0, 0.699, 0.925, 0.0, 0.705, 0.918, 0.0, 0.711, 0.912, 0.0, 0.716, 0.905, 0.0, 0.722, 0.898, 0.05, 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.83, 0.318, 0.779, 0.823, 0.329, 0.783, 0.817, 0.34, 0.787, 0.81, 0.35, 0.79, 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.65, 0.417, 0.804, 0.637, 0.418, 0.802, 0.623, 0.417, 0.8, 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.41, 0.759, 0.428, 0.41, 0.754, 0.409, 0.409, 0.749, 0.39, 0.409, 0.743, 0.371, 0.409, 0.738, 0.351, 0.409, 0.732, 0.331, 0.408, 0.726, 0.31, 0.408, 0.72, 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.17, 0.0, 0.681, 0.95, 0.0, 0.688, 0.943, 0.0, 0.694, 0.936, 0.0, 0.7, 0.929, 0.0, 0.706, 0.922, 0.0, 0.712, 0.915, 0.074, 0.718, 0.908, 0.124, 0.724, 0.902, 0.159, 0.73, 0.896, 0.188, 0.735, 0.89, 0.213, 0.74, 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.86, 0.305, 0.766, 0.854, 0.319, 0.77, 0.848, 0.332, 0.775, 0.842, 0.344, 0.779, 0.836, 0.356, 0.783, 0.83, 0.366, 0.787, 0.823, 0.376, 0.79, 0.817, 0.385, 0.794, 0.81, 0.394, 0.797, 0.803, 0.401, 0.8, 0.796, 0.408, 0.802, 0.789, 0.414, 0.805, 0.781, 0.42, 0.807, 0.773, 0.425, 0.809, 0.765, 0.43, 0.81, 0.756, 0.433, 0.812, 0.747, 0.437, 0.813, 0.738, 0.44, 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.81, 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.44, 0.785, 0.522, 0.439, 0.781, 0.505, 0.438, 0.776, 0.488, 0.437, 0.772, 0.47, 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.74, 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.43, 0.71, 0.25, 0.43, 0.703, 0.226, 0.43, 0.697, 0.201, 0.43, 0.69, 0.175, 0.0, 0.682, 0.953, 0.0, 0.689, 0.946, 0.0, 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.72, 0.912, 0.196, 0.726, 0.906, 0.221, 0.731, 0.9, 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.87, 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.39, 0.786, 0.836, 0.4, 0.79, 0.83, 0.409, 0.794, 0.823, 0.417, 0.798, 0.817, 0.425, 0.801, 0.81, 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.46, 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.61, 0.471, 0.803, 0.594, 0.469, 0.8, 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.78, 0.494, 0.462, 0.775, 0.476, 0.46, 0.77, 0.458, 0.459, 0.765, 0.439, 0.458, 0.759, 0.42, 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.73, 0.32, 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.45, 0.691, 0.179, 0.0, 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.2, 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.32, 0.75, 0.886, 0.335, 0.756, 0.881, 0.35, 0.761, 0.875, 0.363, 0.766, 0.87, 0.376, 0.771, 0.864, 0.388, 0.776, 0.859, 0.4, 0.781, 0.853, 0.411, 0.785, 0.847, 0.421, 0.79, 0.842, 0.43, 0.794, 0.836, 0.439, 0.798, 0.83, 0.448, 0.802, 0.824, 0.455, 0.805, 0.817, 0.462, 0.808, 0.81, 0.469, 0.811, 0.804, 0.475, 0.814, 0.796, 0.48, 0.816, 0.789, 0.484, 0.818, 0.781, 0.488, 0.82, 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.5, 0.823, 0.723, 0.501, 0.823, 0.712, 0.501, 0.822, 0.7, 0.501, 0.821, 0.687, 0.501, 0.819, 0.674, 0.5, 0.818, 0.661, 0.499, 0.815, 0.647, 0.498, 0.813, 0.632, 0.497, 0.81, 0.617, 0.496, 0.807, 0.602, 0.494, 0.804, 0.586, 0.493, 0.8, 0.569, 0.491, 0.796, 0.553, 0.49, 0.792, 0.536, 0.488, 0.787, 0.518, 0.486, 0.783, 0.5, 0.485, 0.778, 0.482, 0.483, 0.773, 0.463, 0.482, 0.767, 0.445, 0.48, 0.762, 0.425, 0.479, 0.756, 0.406, 0.478, 0.75, 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.47, 0.699, 0.21, 0.469, 0.692, 0.184, 0.095, 0.683, 0.958, 0.139, 0.69, 0.951, 0.173, 0.697, 0.944, 0.201, 0.703, 0.938, 0.226, 0.71, 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.88, 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.44, 0.789, 0.853, 0.45, 0.793, 0.848, 0.459, 0.798, 0.842, 0.468, 0.802, 0.836, 0.476, 0.806, 0.83, 0.483, 0.809, 0.824, 0.49, 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.78, 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.72, 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.82, 0.655, 0.523, 0.817, 0.64, 0.522, 0.814, 0.625, 0.52, 0.811, 0.609, 0.518, 0.808, 0.593, 0.516, 0.804, 0.576, 0.515, 0.8, 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.77, 0.45, 0.502, 0.764, 0.431, 0.5, 0.759, 0.411, 0.499, 0.753, 0.391, 0.497, 0.746, 0.371, 0.496, 0.74, 0.35, 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.49, 0.707, 0.239, 0.489, 0.7, 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.73, 0.917, 0.34, 0.736, 0.911, 0.356, 0.743, 0.906, 0.37, 0.749, 0.9, 0.384, 0.755, 0.895, 0.398, 0.76, 0.89, 0.411, 0.766, 0.885, 0.423, 0.772, 0.88, 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.81, 0.837, 0.51, 0.813, 0.831, 0.517, 0.817, 0.825, 0.523, 0.82, 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.78, 0.547, 0.832, 0.771, 0.549, 0.833, 0.761, 0.551, 0.833, 0.751, 0.552, 0.833, 0.74, 0.552, 0.833, 0.729, 0.552, 0.832, 0.717, 0.551, 0.83, 0.704, 0.551, 0.829, 0.691, 0.55, 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.6, 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.51, 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.95, 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.92, 0.37, 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.45, 0.774, 0.884, 0.461, 0.78, 0.879, 0.472, 0.785, 0.875, 0.483, 0.79, 0.87, 0.493, 0.795, 0.865, 0.502, 0.8, 0.86, 0.511, 0.805, 0.855, 0.52, 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.83, 0.812, 0.563, 0.832, 0.805, 0.567, 0.834, 0.797, 0.57, 0.836, 0.788, 0.572, 0.837, 0.779, 0.574, 0.838, 0.77, 0.575, 0.838, 0.76, 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.57, 0.826, 0.656, 0.568, 0.823, 0.64, 0.566, 0.819, 0.624, 0.563, 0.815, 0.607, 0.561, 0.811, 0.59, 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.48, 0.545, 0.775, 0.46, 0.543, 0.769, 0.441, 0.541, 0.763, 0.42, 0.539, 0.756, 0.4, 0.537, 0.75, 0.379, 0.535, 0.743, 0.358, 0.533, 0.737, 0.337, 0.531, 0.73, 0.315, 0.53, 0.723, 0.293, 0.528, 0.716, 0.27, 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.32, 0.706, 0.946, 0.337, 0.713, 0.94, 0.353, 0.72, 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.88, 0.507, 0.793, 0.875, 0.517, 0.799, 0.87, 0.527, 0.804, 0.866, 0.536, 0.809, 0.861, 0.544, 0.813, 0.856, 0.552, 0.818, 0.85, 0.56, 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.82, 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.6, 0.843, 0.758, 0.6, 0.843, 0.746, 0.599, 0.842, 0.734, 0.599, 0.84, 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.59, 0.827, 0.648, 0.587, 0.823, 0.631, 0.585, 0.819, 0.614, 0.582, 0.815, 0.597, 0.58, 0.81, 0.579, 0.577, 0.805, 0.561, 0.575, 0.8, 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.56, 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.55, 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.35, 0.706, 0.949, 0.366, 0.713, 0.943, 0.381, 0.72, 0.938, 0.395, 0.727, 0.932, 0.41, 0.734, 0.927, 0.423, 0.741, 0.922, 0.437, 0.747, 0.917, 0.45, 0.754, 0.912, 0.463, 0.76, 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.52, 0.791, 0.885, 0.531, 0.796, 0.88, 0.54, 0.802, 0.876, 0.55, 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.59, 0.83, 0.847, 0.596, 0.834, 0.841, 0.602, 0.837, 0.835, 0.607, 0.84, 0.828, 0.611, 0.843, 0.821, 0.615, 0.845, 0.814, 0.618, 0.846, 0.805, 0.62, 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.73, 0.62, 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.6, 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.51, 0.586, 0.785, 0.49, 0.584, 0.779, 0.47, 0.581, 0.773, 0.45, 0.579, 0.766, 0.429, 0.576, 0.76, 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.71, 0.252, 0.559, 0.703, 0.227, 0.557, 0.695, 0.201, 0.329, 0.685, 0.97, 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.42, 0.728, 0.935, 0.434, 0.735, 0.93, 0.447, 0.742, 0.925, 0.46, 0.749, 0.92, 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.89, 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.59, 0.821, 0.868, 0.598, 0.826, 0.864, 0.606, 0.83, 0.859, 0.613, 0.834, 0.854, 0.619, 0.838, 0.848, 0.625, 0.842, 0.842, 0.63, 0.845, 0.836, 0.634, 0.848, 0.829, 0.638, 0.85, 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.71, 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.61, 0.62, 0.817, 0.592, 0.617, 0.811, 0.573, 0.614, 0.806, 0.554, 0.611, 0.8, 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.74, 0.347, 0.584, 0.733, 0.325, 0.582, 0.725, 0.302, 0.58, 0.718, 0.279, 0.577, 0.71, 0.255, 0.575, 0.703, 0.23, 0.573, 0.695, 0.204, 0.357, 0.685, 0.972, 0.372, 0.692, 0.966, 0.387, 0.7, 0.96, 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.75, 0.924, 0.494, 0.757, 0.919, 0.507, 0.764, 0.915, 0.519, 0.771, 0.911, 0.53, 0.777, 0.907, 0.542, 0.784, 0.903, 0.553, 0.79, 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.82, 0.879, 0.611, 0.825, 0.875, 0.62, 0.83, 0.87, 0.627, 0.835, 0.866, 0.635, 0.839, 0.861, 0.641, 0.843, 0.856, 0.647, 0.847, 0.85, 0.652, 0.85, 0.844, 0.657, 0.853, 0.838, 0.66, 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.86, 0.795, 0.668, 0.86, 0.784, 0.667, 0.859, 0.773, 0.666, 0.858, 0.76, 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.84, 0.67, 0.649, 0.835, 0.652, 0.646, 0.83, 0.635, 0.642, 0.825, 0.616, 0.639, 0.82, 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.79, 0.499, 0.62, 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.74, 0.35, 0.601, 0.733, 0.328, 0.598, 0.726, 0.305, 0.596, 0.718, 0.282, 0.593, 0.71, 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.41, 0.7, 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.49, 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.55, 0.779, 0.911, 0.562, 0.786, 0.907, 0.573, 0.792, 0.903, 0.584, 0.799, 0.9, 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.69, 0.865, 0.804, 0.69, 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.77, 0.44, 0.628, 0.763, 0.419, 0.625, 0.756, 0.397, 0.623, 0.748, 0.375, 0.62, 0.741, 0.353, 0.617, 0.733, 0.33, 0.614, 0.726, 0.307, 0.612, 0.718, 0.284, 0.609, 0.71, 0.26, 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.73, 0.944, 0.497, 0.737, 0.939, 0.51, 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.82, 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.69, 0.857, 0.866, 0.695, 0.86, 0.86, 0.7, 0.864, 0.855, 0.704, 0.866, 0.848, 0.707, 0.869, 0.841, 0.709, 0.87, 0.833, 0.711, 0.871, 0.824, 0.711, 0.871, 0.814, 0.711, 0.871, 0.803, 0.71, 0.87, 0.791, 0.709, 0.868, 0.778, 0.707, 0.866, 0.765, 0.704, 0.864, 0.75, 0.701, 0.86, 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.68, 0.832, 0.628, 0.676, 0.826, 0.609, 0.673, 0.82, 0.589, 0.669, 0.813, 0.569, 0.665, 0.807, 0.549, 0.662, 0.8, 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.4, 0.639, 0.749, 0.378, 0.636, 0.741, 0.356, 0.633, 0.733, 0.333, 0.63, 0.726, 0.31, 0.627, 0.718, 0.286, 0.624, 0.71, 0.262, 0.621, 0.702, 0.237, 0.619, 0.694, 0.21, 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.73, 0.947, 0.516, 0.738, 0.942, 0.528, 0.745, 0.938, 0.54, 0.753, 0.934, 0.552, 0.76, 0.93, 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.61, 0.797, 0.912, 0.621, 0.803, 0.909, 0.632, 0.81, 0.906, 0.642, 0.817, 0.902, 0.652, 0.823, 0.899, 0.662, 0.83, 0.896, 0.671, 0.836, 0.893, 0.68, 0.842, 0.89, 0.689, 0.847, 0.886, 0.697, 0.853, 0.882, 0.704, 0.857, 0.878, 0.71, 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.85, 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.8, 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.71, 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.69, 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.49, 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.38, 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.73, 0.949, 0.534, 0.738, 0.945, 0.546, 0.746, 0.941, 0.558, 0.753, 0.937, 0.57, 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.91, 0.66, 0.82, 0.907, 0.67, 0.826, 0.904, 0.68, 0.833, 0.902, 0.69, 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.75, 0.88, 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.81, 0.75, 0.88, 0.797, 0.747, 0.877, 0.782, 0.744, 0.874, 0.767, 0.74, 0.87, 0.751, 0.737, 0.866, 0.734, 0.733, 0.861, 0.716, 0.729, 0.855, 0.697, 0.724, 0.85, 0.678, 0.72, 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.81, 0.557, 0.696, 0.803, 0.535, 0.692, 0.795, 0.514, 0.688, 0.788, 0.493, 0.684, 0.78, 0.471, 0.68, 0.772, 0.449, 0.677, 0.765, 0.427, 0.673, 0.757, 0.405, 0.67, 0.749, 0.382, 0.666, 0.741, 0.36, 0.663, 0.733, 0.337, 0.66, 0.725, 0.313, 0.657, 0.716, 0.289, 0.653, 0.708, 0.265, 0.65, 0.7, 0.24, 0.647, 0.692, 0.213, 0.464, 0.681, 0.982, 0.476, 0.69, 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.73, 0.952, 0.55, 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.61, 0.777, 0.929, 0.621, 0.785, 0.926, 0.633, 0.792, 0.923, 0.644, 0.8, 0.92, 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.75, 0.872, 0.889, 0.757, 0.877, 0.885, 0.762, 0.881, 0.88, 0.767, 0.884, 0.875, 0.77, 0.887, 0.868, 0.773, 0.888, 0.861, 0.774, 0.889, 0.852, 0.774, 0.89, 0.842, 0.774, 0.889, 0.831, 0.772, 0.888, 0.819, 0.77, 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.87, 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.84, 0.644, 0.729, 0.833, 0.623, 0.724, 0.826, 0.603, 0.72, 0.819, 0.581, 0.716, 0.811, 0.56, 0.712, 0.804, 0.539, 0.708, 0.796, 0.517, 0.704, 0.788, 0.495, 0.7, 0.78, 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.74, 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.68, 0.984, 0.494, 0.689, 0.978, 0.506, 0.697, 0.973, 0.518, 0.705, 0.968, 0.53, 0.713, 0.963, 0.542, 0.722, 0.958, 0.554, 0.73, 0.954, 0.566, 0.738, 0.95, 0.578, 0.746, 0.946, 0.59, 0.754, 0.942, 0.602, 0.762, 0.939, 0.614, 0.77, 0.935, 0.626, 0.778, 0.932, 0.637, 0.786, 0.929, 0.649, 0.794, 0.926, 0.66, 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.91, 0.735, 0.853, 0.908, 0.744, 0.859, 0.905, 0.753, 0.866, 0.903, 0.762, 0.872, 0.9, 0.77, 0.877, 0.897, 0.776, 0.882, 0.893, 0.782, 0.886, 0.889, 0.787, 0.89, 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.8, 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.71, 0.76, 0.856, 0.69, 0.755, 0.849, 0.669, 0.75, 0.842, 0.649, 0.745, 0.835, 0.628, 0.741, 0.827, 0.606, 0.736, 0.82, 0.585, 0.732, 0.812, 0.563, 0.728, 0.804, 0.542, 0.723, 0.796, 0.52, 0.719, 0.788, 0.498, 0.715, 0.78, 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.51, 0.687, 0.98, 0.522, 0.696, 0.975, 0.534, 0.704, 0.97, 0.546, 0.712, 0.965, 0.558, 0.721, 0.961, 0.57, 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.77, 0.938, 0.64, 0.778, 0.935, 0.652, 0.786, 0.932, 0.664, 0.794, 0.93, 0.675, 0.802, 0.927, 0.687, 0.81, 0.925, 0.698, 0.818, 0.923, 0.709, 0.826, 0.921, 0.72, 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.87, 0.909, 0.78, 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.88, 0.815, 0.903, 0.872, 0.815, 0.903, 0.862, 0.814, 0.902, 0.851, 0.812, 0.9, 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.61, 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.5, 0.73, 0.78, 0.477, 0.726, 0.772, 0.455, 0.722, 0.763, 0.432, 0.718, 0.755, 0.41, 0.714, 0.746, 0.387, 0.71, 0.738, 0.364, 0.706, 0.73, 0.34, 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.72, 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.77, 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.93, 0.701, 0.811, 0.928, 0.713, 0.82, 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.92, 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.89, 0.836, 0.91, 0.882, 0.836, 0.91, 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.72, 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.59, 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.74, 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.7, 0.685, 0.216, 0.528, 0.675, 0.989, 0.54, 0.684, 0.983, 0.551, 0.693, 0.978, 0.563, 0.701, 0.973, 0.575, 0.71, 0.969, 0.586, 0.718, 0.964, 0.598, 0.727, 0.96, 0.61, 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.77, 0.943, 0.668, 0.778, 0.94, 0.68, 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.93, 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.87, 0.922, 0.804, 0.877, 0.921, 0.814, 0.885, 0.92, 0.824, 0.892, 0.918, 0.832, 0.898, 0.917, 0.84, 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.82, 0.878, 0.746, 0.814, 0.87, 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.57, 0.773, 0.804, 0.548, 0.768, 0.795, 0.525, 0.763, 0.787, 0.502, 0.758, 0.778, 0.48, 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.72, 0.7, 0.269, 0.716, 0.691, 0.243, 0.712, 0.683, 0.216, 0.542, 0.673, 0.99, 0.554, 0.682, 0.985, 0.565, 0.691, 0.98, 0.577, 0.7, 0.975, 0.588, 0.708, 0.97, 0.6, 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.76, 0.948, 0.669, 0.769, 0.945, 0.681, 0.778, 0.943, 0.692, 0.786, 0.94, 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.83, 0.932, 0.763, 0.838, 0.93, 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.83, 0.889, 0.926, 0.84, 0.896, 0.925, 0.85, 0.903, 0.924, 0.858, 0.91, 0.922, 0.865, 0.915, 0.92, 0.871, 0.92, 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.87, 0.919, 0.867, 0.865, 0.914, 0.851, 0.86, 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.88, 0.75, 0.83, 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.82, 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.48, 0.767, 0.768, 0.458, 0.763, 0.759, 0.435, 0.758, 0.75, 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.68, 0.216, 0.556, 0.671, 0.992, 0.567, 0.68, 0.986, 0.578, 0.689, 0.981, 0.59, 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.96, 0.646, 0.741, 0.956, 0.658, 0.75, 0.953, 0.67, 0.759, 0.95, 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.74, 0.812, 0.937, 0.752, 0.821, 0.936, 0.763, 0.83, 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.9, 0.931, 0.866, 0.908, 0.931, 0.876, 0.915, 0.93, 0.884, 0.922, 0.929, 0.89, 0.927, 0.926, 0.895, 0.93, 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.92, 0.859, 0.877, 0.913, 0.84, 0.871, 0.906, 0.819, 0.864, 0.898, 0.798, 0.858, 0.89, 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.81, 0.572, 0.8, 0.801, 0.549, 0.795, 0.792, 0.526, 0.79, 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.73, 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.74, 0.686, 0.243, 0.736, 0.677, 0.216, 0.569, 0.668, 0.993, 0.58, 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.74, 0.958, 0.67, 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.83, 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.87, 0.904, 0.937, 0.882, 0.912, 0.937, 0.892, 0.92, 0.937, 0.901, 0.928, 0.937, 0.909, 0.934, 0.936, 0.914, 0.938, 0.932, 0.917, 0.94, 0.926, 0.915, 0.94, 0.916, 0.912, 0.936, 0.902, 0.906, 0.931, 0.885, 0.9, 0.925, 0.866, 0.893, 0.917, 0.846, 0.887, 0.909, 0.824, 0.88, 0.9, 0.802, 0.873, 0.891, 0.78, 0.867, 0.882, 0.757, 0.86, 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.83, 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.79, 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.76, 0.7, 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.71, 0.97, 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.75, 0.801, 0.943, 0.762, 0.81, 0.941, 0.774, 0.82, 0.94, 0.786, 0.829, 0.939, 0.798, 0.839, 0.939, 0.81, 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.94, 0.871, 0.897, 0.94, 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.93, 0.943, 0.912, 0.924, 0.937, 0.893, 0.916, 0.929, 0.872, 0.909, 0.92, 0.85, 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.48, 0.805, 0.76, 0.457, 0.8, 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.34, 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.67, 0.215, 0.593, 0.662, 0.995, 0.603, 0.671, 0.99, 0.614, 0.68, 0.985, 0.625, 0.689, 0.98, 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.68, 0.735, 0.96, 0.691, 0.744, 0.957, 0.702, 0.753, 0.955, 0.714, 0.762, 0.952, 0.725, 0.771, 0.95, 0.737, 0.781, 0.948, 0.748, 0.79, 0.946, 0.76, 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.82, 0.847, 0.94, 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.92, 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.95, 0.954, 0.956, 0.938, 0.948, 0.949, 0.92, 0.94, 0.941, 0.899, 0.932, 0.931, 0.877, 0.924, 0.921, 0.854, 0.916, 0.911, 0.83, 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.85, 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.41, 0.802, 0.729, 0.387, 0.797, 0.72, 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.24, 0.768, 0.666, 0.214, 0.604, 0.659, 0.996, 0.614, 0.668, 0.99, 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.69, 0.732, 0.961, 0.701, 0.741, 0.958, 0.712, 0.75, 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.95, 0.931, 0.93, 0.953, 0.945, 0.941, 0.956, 0.958, 0.952, 0.96, 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.91, 0.831, 0.921, 0.899, 0.807, 0.914, 0.889, 0.783, 0.907, 0.878, 0.759, 0.9, 0.868, 0.735, 0.893, 0.858, 0.711, 0.887, 0.848, 0.688, 0.88, 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.85, 0.79, 0.547, 0.845, 0.78, 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.29, 0.788, 0.68, 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.71, 0.969, 0.688, 0.719, 0.966, 0.699, 0.729, 0.962, 0.71, 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.95, 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.94, 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.83, 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.71, 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.85, 0.766, 0.5, 0.845, 0.757, 0.477, 0.839, 0.748, 0.454, 0.834, 0.739, 0.43, 0.829, 0.729, 0.407, 0.823, 0.72, 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.66, 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.97, 0.698, 0.716, 0.966, 0.708, 0.725, 0.963, 0.719, 0.734, 0.96, 0.73, 0.743, 0.957, 0.741, 0.753, 0.954, 0.752, 0.762, 0.952, 0.763, 0.771, 0.95, 0.774, 0.781, 0.948, 0.786, 0.79, 0.947, 0.797, 0.8, 0.945, 0.809, 0.81, 0.945, 0.82, 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.86, 0.944, 0.88, 0.87, 0.945, 0.893, 0.88, 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.99, 0.957, 0.946, 0.983, 0.946, 0.924, 0.975, 0.935, 0.9, 0.967, 0.923, 0.876, 0.959, 0.912, 0.851, 0.951, 0.901, 0.827, 0.943, 0.89, 0.803, 0.936, 0.88, 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.89, 0.809, 0.614, 0.884, 0.8, 0.591, 0.878, 0.79, 0.567, 0.872, 0.78, 0.544, 0.866, 0.771, 0.521, 0.861, 0.762, 0.498, 0.855, 0.752, 0.475, 0.85, 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.67, 0.262, 0.803, 0.662, 0.236, 0.798, 0.653, 0.21, 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.97, 0.706, 0.711, 0.966, 0.717, 0.721, 0.963, 0.727, 0.73, 0.96, 0.738, 0.739, 0.957, 0.749, 0.748, 0.955, 0.76, 0.758, 0.952, 0.771, 0.767, 0.95, 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.85, 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.91, 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.97, 0.937, 0.955, 0.98, 0.944, 0.955, 0.987, 0.946, 0.949, 0.989, 0.942, 0.936, 0.985, 0.935, 0.916, 0.98, 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.8, 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.9, 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.45, 0.854, 0.728, 0.427, 0.848, 0.719, 0.404, 0.843, 0.71, 0.38, 0.838, 0.701, 0.357, 0.833, 0.692, 0.333, 0.827, 0.683, 0.31, 0.822, 0.674, 0.285, 0.817, 0.665, 0.26, 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.66, 0.988, 0.674, 0.67, 0.983, 0.684, 0.679, 0.978, 0.694, 0.688, 0.974, 0.704, 0.697, 0.97, 0.715, 0.707, 0.967, 0.725, 0.716, 0.963, 0.735, 0.725, 0.96, 0.746, 0.735, 0.957, 0.757, 0.744, 0.955, 0.767, 0.753, 0.952, 0.778, 0.763, 0.95, 0.789, 0.772, 0.948, 0.8, 0.781, 0.947, 0.811, 0.791, 0.945, 0.822, 0.801, 0.944, 0.833, 0.81, 0.943, 0.845, 0.82, 0.943, 0.856, 0.83, 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.93, 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.94, 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.88, 0.75, 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.66, 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.97, 0.722, 0.702, 0.967, 0.733, 0.711, 0.963, 0.743, 0.72, 0.96, 0.753, 0.73, 0.957, 0.764, 0.739, 0.954, 0.774, 0.748, 0.952, 0.785, 0.757, 0.95, 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.85, 0.814, 0.941, 0.861, 0.824, 0.941, 0.872, 0.833, 0.94, 0.884, 0.843, 0.94, 0.895, 0.852, 0.94, 0.906, 0.862, 0.94, 0.917, 0.871, 0.941, 0.928, 0.88, 0.941, 0.939, 0.889, 0.941, 0.949, 0.897, 0.941, 0.959, 0.904, 0.94, 0.968, 0.91, 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.9, 0.878, 0.98, 0.893, 0.857, 0.976, 0.884, 0.836, 0.971, 0.875, 0.813, 0.965, 0.866, 0.79, 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.8, 0.629, 0.917, 0.79, 0.605, 0.912, 0.781, 0.582, 0.906, 0.771, 0.56, 0.9, 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.85, 0.68, 0.329, 0.845, 0.672, 0.305, 0.84, 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.65, 0.988, 0.691, 0.659, 0.983, 0.7, 0.669, 0.979, 0.71, 0.678, 0.974, 0.72, 0.687, 0.97, 0.73, 0.696, 0.966, 0.74, 0.706, 0.963, 0.75, 0.715, 0.96, 0.76, 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.77, 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.94, 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.93, 0.87, 0.936, 0.94, 0.878, 0.936, 0.95, 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.88, 0.849, 0.979, 0.872, 0.828, 0.975, 0.864, 0.807, 0.97, 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.81, 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.88, 0.71, 0.42, 0.875, 0.701, 0.397, 0.869, 0.692, 0.374, 0.864, 0.683, 0.35, 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.63, 0.202, 0.671, 0.625, 0.998, 0.68, 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.97, 0.737, 0.691, 0.966, 0.747, 0.7, 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.95, 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.94, 0.849, 0.791, 0.939, 0.859, 0.8, 0.938, 0.87, 0.809, 0.937, 0.88, 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.95, 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.98, 0.86, 0.821, 0.977, 0.853, 0.8, 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.81, 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.53, 0.91, 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.65, 0.277, 0.85, 0.641, 0.252, 0.845, 0.633, 0.226, 0.839, 0.624, 0.2, 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.73, 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.94, 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.93, 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.95, 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.98, 0.867, 0.88, 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.84, 0.792, 0.976, 0.833, 0.771, 0.973, 0.825, 0.75, 0.969, 0.817, 0.728, 0.964, 0.809, 0.706, 0.959, 0.8, 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.89, 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.65, 0.977, 0.732, 0.66, 0.973, 0.741, 0.669, 0.969, 0.75, 0.678, 0.965, 0.76, 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.74, 0.943, 0.828, 0.749, 0.94, 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.93, 0.887, 0.8, 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.95, 0.846, 0.911, 0.957, 0.85, 0.906, 0.964, 0.852, 0.899, 0.97, 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.84, 0.983, 0.84, 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.7, 0.964, 0.79, 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.59, 0.939, 0.748, 0.567, 0.934, 0.739, 0.545, 0.929, 0.731, 0.523, 0.923, 0.722, 0.5, 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.67, 0.365, 0.886, 0.662, 0.342, 0.88, 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.72, 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.68, 0.96, 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.87, 0.774, 0.929, 0.88, 0.782, 0.927, 0.889, 0.79, 0.924, 0.899, 0.797, 0.922, 0.908, 0.805, 0.92, 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.95, 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.98, 0.834, 0.845, 0.982, 0.831, 0.83, 0.983, 0.826, 0.813, 0.983, 0.821, 0.795, 0.982, 0.815, 0.776, 0.98, 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.73, 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.43, 0.908, 0.68, 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.87, 0.62, 0.244, 0.865, 0.612, 0.219, 0.86, 0.604, 0.192, 0.701, 0.599, 0.997, 0.71, 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.79, 0.69, 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.93, 0.864, 0.757, 0.928, 0.874, 0.765, 0.925, 0.883, 0.772, 0.923, 0.892, 0.78, 0.92, 0.901, 0.787, 0.917, 0.91, 0.793, 0.914, 0.918, 0.8, 0.911, 0.927, 0.805, 0.908, 0.935, 0.811, 0.904, 0.942, 0.815, 0.899, 0.95, 0.819, 0.894, 0.956, 0.821, 0.887, 0.963, 0.823, 0.88, 0.968, 0.824, 0.871, 0.973, 0.824, 0.86, 0.977, 0.822, 0.849, 0.98, 0.82, 0.835, 0.982, 0.817, 0.82, 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.97, 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.58, 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.47, 0.924, 0.688, 0.448, 0.919, 0.68, 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.29, 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.62, 0.98, 0.742, 0.629, 0.975, 0.751, 0.638, 0.97, 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.69, 0.946, 0.813, 0.699, 0.942, 0.822, 0.707, 0.939, 0.831, 0.715, 0.936, 0.84, 0.723, 0.933, 0.849, 0.731, 0.93, 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.92, 0.787, 0.905, 0.928, 0.793, 0.901, 0.935, 0.798, 0.896, 0.943, 0.802, 0.891, 0.95, 0.805, 0.885, 0.956, 0.807, 0.878, 0.962, 0.809, 0.87, 0.967, 0.809, 0.861, 0.972, 0.809, 0.85, 0.976, 0.808, 0.838, 0.979, 0.805, 0.825, 0.981, 0.802, 0.81, 0.983, 0.799, 0.795, 0.983, 0.794, 0.778, 0.983, 0.789, 0.76, 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.66, 0.97, 0.75, 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.51, 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.4, 0.914, 0.654, 0.378, 0.909, 0.646, 0.355, 0.903, 0.638, 0.333, 0.898, 0.63, 0.31, 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.99, 0.731, 0.603, 0.984, 0.739, 0.612, 0.979, 0.748, 0.621, 0.974, 0.756, 0.63, 0.969, 0.765, 0.639, 0.964, 0.774, 0.648, 0.96, 0.782, 0.656, 0.955, 0.791, 0.665, 0.951, 0.8, 0.673, 0.947, 0.809, 0.682, 0.943, 0.818, 0.69, 0.94, 0.826, 0.698, 0.936, 0.835, 0.706, 0.933, 0.844, 0.714, 0.93, 0.853, 0.722, 0.926, 0.862, 0.729, 0.923, 0.871, 0.737, 0.92, 0.879, 0.744, 0.917, 0.888, 0.751, 0.913, 0.896, 0.758, 0.91, 0.905, 0.764, 0.906, 0.913, 0.77, 0.903, 0.921, 0.775, 0.898, 0.929, 0.78, 0.894, 0.936, 0.784, 0.889, 0.943, 0.788, 0.883, 0.95, 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.78, 0.769, 0.983, 0.776, 0.751, 0.983, 0.77, 0.733, 0.982, 0.764, 0.714, 0.98, 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.57, 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.67, 0.44, 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.26, 0.887, 0.597, 0.235, 0.882, 0.589, 0.21, 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.77, 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.83, 0.689, 0.933, 0.839, 0.697, 0.93, 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.89, 0.74, 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.95, 0.777, 0.868, 0.956, 0.779, 0.86, 0.961, 0.78, 0.851, 0.966, 0.78, 0.842, 0.971, 0.78, 0.831, 0.975, 0.779, 0.819, 0.978, 0.777, 0.806, 0.98, 0.774, 0.791, 0.982, 0.771, 0.776, 0.983, 0.767, 0.76, 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.74, 0.667, 0.977, 0.733, 0.647, 0.974, 0.727, 0.627, 0.971, 0.72, 0.606, 0.968, 0.713, 0.585, 0.964, 0.706, 0.564, 0.96, 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.66, 0.436, 0.933, 0.652, 0.414, 0.928, 0.644, 0.392, 0.923, 0.636, 0.37, 0.918, 0.629, 0.348, 0.913, 0.621, 0.326, 0.908, 0.613, 0.303, 0.903, 0.605, 0.28, 0.897, 0.597, 0.257, 0.892, 0.589, 0.232, 0.887, 0.581, 0.207, 0.881, 0.573, 0.18, 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.63, 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.93, 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.9, 0.734, 0.899, 0.908, 0.74, 0.895, 0.916, 0.745, 0.89, 0.923, 0.75, 0.885, 0.93, 0.754, 0.879, 0.937, 0.758, 0.873, 0.944, 0.761, 0.867, 0.95, 0.763, 0.859, 0.956, 0.765, 0.851, 0.961, 0.766, 0.842, 0.966, 0.766, 0.832, 0.97, 0.766, 0.821, 0.974, 0.764, 0.809, 0.977, 0.762, 0.796, 0.98, 0.76, 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.98, 0.727, 0.66, 0.978, 0.721, 0.64, 0.976, 0.715, 0.62, 0.973, 0.708, 0.6, 0.97, 0.701, 0.579, 0.967, 0.694, 0.559, 0.963, 0.687, 0.538, 0.959, 0.68, 0.517, 0.955, 0.673, 0.496, 0.951, 0.665, 0.474, 0.946, 0.658, 0.453, 0.942, 0.65, 0.432, 0.937, 0.643, 0.41, 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.3, 0.907, 0.596, 0.277, 0.902, 0.588, 0.253, 0.897, 0.58, 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.97, 0.773, 0.604, 0.964, 0.781, 0.613, 0.959, 0.789, 0.621, 0.954, 0.797, 0.63, 0.949, 0.805, 0.638, 0.945, 0.813, 0.646, 0.94, 0.821, 0.654, 0.936, 0.83, 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.87, 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.91, 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.95, 0.749, 0.851, 0.956, 0.751, 0.842, 0.961, 0.751, 0.833, 0.966, 0.752, 0.823, 0.97, 0.751, 0.812, 0.974, 0.75, 0.8, 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.69, 0.983, 0.721, 0.672, 0.981, 0.715, 0.653, 0.98, 0.709, 0.633, 0.977, 0.703, 0.614, 0.975, 0.697, 0.594, 0.972, 0.69, 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.47, 0.949, 0.648, 0.448, 0.945, 0.64, 0.427, 0.941, 0.633, 0.406, 0.936, 0.625, 0.384, 0.931, 0.618, 0.363, 0.926, 0.61, 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.25, 0.901, 0.571, 0.226, 0.896, 0.563, 0.201, 0.89, 0.556, 0.174, 0.739, 0.55, 0.992, 0.747, 0.559, 0.986, 0.754, 0.568, 0.98, 0.762, 0.577, 0.974, 0.77, 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.62, 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.68, 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.71, 0.887, 0.911, 0.715, 0.882, 0.918, 0.72, 0.877, 0.925, 0.724, 0.871, 0.932, 0.727, 0.865, 0.938, 0.73, 0.858, 0.944, 0.733, 0.85, 0.95, 0.735, 0.842, 0.956, 0.736, 0.834, 0.961, 0.737, 0.824, 0.965, 0.737, 0.814, 0.97, 0.737, 0.802, 0.973, 0.736, 0.79, 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.7, 0.984, 0.713, 0.682, 0.983, 0.708, 0.664, 0.982, 0.702, 0.645, 0.98, 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.96, 0.651, 0.485, 0.956, 0.644, 0.465, 0.952, 0.637, 0.444, 0.948, 0.63, 0.423, 0.944, 0.623, 0.401, 0.939, 0.615, 0.38, 0.934, 0.608, 0.358, 0.93, 0.6, 0.337, 0.925, 0.593, 0.315, 0.92, 0.585, 0.292, 0.915, 0.578, 0.27, 0.91, 0.57, 0.246, 0.905, 0.562, 0.222, 0.899, 0.555, 0.197, 0.894, 0.547, 0.171, 0.745, 0.54, 0.991, 0.752, 0.55, 0.984, 0.76, 0.559, 0.978, 0.767, 0.568, 0.972, 0.775, 0.577, 0.966, 0.782, 0.585, 0.96, 0.79, 0.594, 0.955, 0.798, 0.602, 0.95, 0.806, 0.61, 0.944, 0.813, 0.618, 0.939, 0.821, 0.626, 0.934, 0.829, 0.634, 0.93, 0.837, 0.641, 0.925, 0.845, 0.648, 0.92, 0.852, 0.655, 0.915, 0.86, 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.87, 0.926, 0.71, 0.864, 0.932, 0.714, 0.857, 0.939, 0.717, 0.85, 0.945, 0.719, 0.842, 0.95, 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.72, 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.7, 0.674, 0.983, 0.695, 0.656, 0.982, 0.69, 0.638, 0.981, 0.684, 0.619, 0.979, 0.679, 0.6, 0.977, 0.673, 0.581, 0.975, 0.666, 0.561, 0.972, 0.66, 0.541, 0.969, 0.654, 0.521, 0.966, 0.647, 0.501, 0.962, 0.64, 0.48, 0.959, 0.634, 0.459, 0.955, 0.627, 0.439, 0.951, 0.62, 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.75, 0.531, 0.989, 0.757, 0.54, 0.983, 0.765, 0.549, 0.976, 0.772, 0.558, 0.97, 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.81, 0.6, 0.942, 0.817, 0.608, 0.936, 0.825, 0.615, 0.931, 0.833, 0.623, 0.926, 0.84, 0.63, 0.921, 0.848, 0.637, 0.916, 0.855, 0.644, 0.911, 0.863, 0.651, 0.907, 0.87, 0.657, 0.902, 0.878, 0.663, 0.897, 0.885, 0.669, 0.891, 0.893, 0.675, 0.886, 0.9, 0.68, 0.881, 0.907, 0.685, 0.875, 0.914, 0.689, 0.869, 0.92, 0.693, 0.863, 0.927, 0.697, 0.857, 0.933, 0.7, 0.85, 0.939, 0.703, 0.842, 0.945, 0.705, 0.834, 0.95, 0.707, 0.825, 0.956, 0.708, 0.816, 0.96, 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.98, 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.63, 0.982, 0.672, 0.612, 0.98, 0.666, 0.593, 0.978, 0.66, 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.94, 0.588, 0.35, 0.936, 0.58, 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.19, 0.901, 0.529, 0.164, 0.755, 0.521, 0.988, 0.762, 0.53, 0.981, 0.77, 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.95, 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.88, 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.68, 0.856, 0.928, 0.684, 0.849, 0.934, 0.687, 0.842, 0.94, 0.689, 0.834, 0.945, 0.691, 0.826, 0.951, 0.693, 0.817, 0.956, 0.694, 0.807, 0.96, 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.75, 0.977, 0.69, 0.736, 0.98, 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.98, 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.63, 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.57, 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.16, 0.76, 0.51, 0.986, 0.767, 0.52, 0.979, 0.774, 0.529, 0.973, 0.781, 0.538, 0.966, 0.788, 0.546, 0.96, 0.796, 0.555, 0.954, 0.803, 0.563, 0.948, 0.81, 0.571, 0.942, 0.817, 0.579, 0.936, 0.825, 0.586, 0.93, 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.65, 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.67, 0.842, 0.934, 0.673, 0.834, 0.94, 0.675, 0.826, 0.945, 0.677, 0.818, 0.951, 0.679, 0.809, 0.955, 0.68, 0.799, 0.96, 0.68, 0.789, 0.964, 0.68, 0.778, 0.968, 0.68, 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.67, 0.698, 0.982, 0.667, 0.682, 0.983, 0.664, 0.666, 0.983, 0.66, 0.65, 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.56, 0.977, 0.63, 0.541, 0.975, 0.625, 0.522, 0.973, 0.619, 0.503, 0.97, 0.613, 0.483, 0.967, 0.606, 0.463, 0.964, 0.6, 0.443, 0.96, 0.594, 0.423, 0.956, 0.587, 0.403, 0.953, 0.58, 0.383, 0.949, 0.574, 0.362, 0.944, 0.567, 0.341, 0.94, 0.56, 0.32, 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.51, 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.8, 0.544, 0.951, 0.807, 0.552, 0.945, 0.814, 0.56, 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.91, 0.856, 0.603, 0.904, 0.863, 0.609, 0.898, 0.87, 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.65, 0.849, 0.923, 0.653, 0.842, 0.929, 0.657, 0.835, 0.935, 0.659, 0.827, 0.94, 0.662, 0.818, 0.946, 0.663, 0.81, 0.951, 0.665, 0.8, 0.955, 0.666, 0.79, 0.96, 0.666, 0.78, 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.98, 0.657, 0.689, 0.981, 0.654, 0.674, 0.982, 0.65, 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.59, 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.95, 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.25, 0.924, 0.522, 0.228, 0.919, 0.514, 0.204, 0.914, 0.507, 0.179, 0.909, 0.5, 0.153, 0.77, 0.488, 0.983, 0.777, 0.498, 0.976, 0.783, 0.507, 0.969, 0.79, 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.93, 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.9, 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.85, 0.918, 0.637, 0.843, 0.924, 0.64, 0.835, 0.93, 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.76, 0.967, 0.652, 0.749, 0.97, 0.651, 0.736, 0.973, 0.649, 0.723, 0.976, 0.647, 0.71, 0.978, 0.645, 0.696, 0.98, 0.643, 0.681, 0.981, 0.64, 0.666, 0.982, 0.637, 0.65, 0.982, 0.633, 0.634, 0.983, 0.629, 0.617, 0.982, 0.625, 0.6, 0.982, 0.62, 0.582, 0.981, 0.616, 0.565, 0.979, 0.611, 0.546, 0.978, 0.605, 0.528, 0.976, 0.6, 0.509, 0.974, 0.595, 0.49, 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.29, 0.935, 0.525, 0.268, 0.93, 0.518, 0.246, 0.926, 0.511, 0.224, 0.921, 0.504, 0.2, 0.916, 0.497, 0.175, 0.911, 0.49, 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.92, 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.87, 0.894, 0.606, 0.864, 0.901, 0.611, 0.857, 0.907, 0.615, 0.85, 0.913, 0.619, 0.843, 0.919, 0.623, 0.836, 0.925, 0.626, 0.828, 0.93, 0.629, 0.82, 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.74, 0.97, 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.98, 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.54, 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.96, 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.22, 0.922, 0.494, 0.196, 0.918, 0.487, 0.172, 0.913, 0.48, 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.95, 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.54, 0.916, 0.844, 0.547, 0.91, 0.851, 0.554, 0.904, 0.857, 0.56, 0.897, 0.864, 0.566, 0.891, 0.87, 0.572, 0.884, 0.877, 0.578, 0.878, 0.883, 0.583, 0.871, 0.89, 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.92, 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.62, 0.795, 0.946, 0.621, 0.786, 0.95, 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.98, 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.98, 0.59, 0.55, 0.979, 0.585, 0.533, 0.978, 0.58, 0.515, 0.976, 0.575, 0.496, 0.974, 0.57, 0.478, 0.972, 0.565, 0.459, 0.969, 0.559, 0.44, 0.967, 0.553, 0.421, 0.964, 0.547, 0.402, 0.96, 0.542, 0.382, 0.957, 0.535, 0.362, 0.953, 0.529, 0.342, 0.95, 0.523, 0.322, 0.946, 0.517, 0.302, 0.942, 0.51, 0.281, 0.937, 0.504, 0.26, 0.933, 0.497, 0.238, 0.929, 0.49, 0.216, 0.924, 0.484, 0.192, 0.919, 0.477, 0.168, 0.914, 0.47, 0.141, 0.783, 0.453, 0.977, 0.789, 0.462, 0.969, 0.796, 0.471, 0.962, 0.802, 0.48, 0.954, 0.808, 0.489, 0.947, 0.815, 0.497, 0.94, 0.821, 0.505, 0.933, 0.828, 0.513, 0.926, 0.834, 0.52, 0.919, 0.84, 0.527, 0.913, 0.847, 0.534, 0.906, 0.853, 0.541, 0.899, 0.86, 0.548, 0.893, 0.866, 0.554, 0.886, 0.873, 0.56, 0.88, 0.879, 0.565, 0.873, 0.885, 0.57, 0.866, 0.891, 0.575, 0.859, 0.897, 0.58, 0.852, 0.903, 0.585, 0.845, 0.909, 0.589, 0.838, 0.915, 0.592, 0.83, 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.95, 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.71, 0.971, 0.607, 0.698, 0.974, 0.605, 0.684, 0.976, 0.603, 0.67, 0.977, 0.601, 0.656, 0.979, 0.598, 0.641, 0.98, 0.596, 0.626, 0.98, 0.592, 0.61, 0.981, 0.589, 0.594, 0.981, 0.585, 0.577, 0.98, 0.581, 0.56, 0.98, 0.577, 0.543, 0.979, 0.572, 0.526, 0.977, 0.568, 0.508, 0.976, 0.563, 0.49, 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.53, 0.377, 0.958, 0.524, 0.357, 0.954, 0.518, 0.337, 0.95, 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.93, 0.48, 0.211, 0.925, 0.473, 0.188, 0.92, 0.466, 0.164, 0.916, 0.459, 0.137, 0.787, 0.44, 0.975, 0.793, 0.45, 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.93, 0.831, 0.5, 0.923, 0.837, 0.508, 0.916, 0.843, 0.515, 0.909, 0.85, 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.91, 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.59, 0.789, 0.941, 0.591, 0.78, 0.946, 0.593, 0.77, 0.95, 0.594, 0.76, 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.97, 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.98, 0.579, 0.602, 0.98, 0.575, 0.586, 0.98, 0.572, 0.57, 0.98, 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.55, 0.483, 0.974, 0.545, 0.465, 0.972, 0.54, 0.447, 0.969, 0.535, 0.428, 0.967, 0.529, 0.409, 0.964, 0.524, 0.39, 0.961, 0.518, 0.371, 0.958, 0.512, 0.352, 0.954, 0.506, 0.332, 0.951, 0.5, 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.48, 0.926, 0.834, 0.488, 0.919, 0.84, 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.87, 0.528, 0.877, 0.876, 0.533, 0.87, 0.882, 0.539, 0.862, 0.888, 0.544, 0.855, 0.894, 0.549, 0.848, 0.9, 0.553, 0.84, 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.8, 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.95, 0.58, 0.752, 0.954, 0.58, 0.741, 0.958, 0.581, 0.73, 0.961, 0.581, 0.718, 0.964, 0.58, 0.706, 0.967, 0.58, 0.694, 0.97, 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.61, 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.55, 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.44, 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.5, 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.94, 0.47, 0.246, 0.935, 0.464, 0.225, 0.931, 0.458, 0.203, 0.927, 0.451, 0.18, 0.922, 0.445, 0.155, 0.917, 0.438, 0.129, 0.795, 0.413, 0.97, 0.801, 0.423, 0.962, 0.807, 0.433, 0.954, 0.813, 0.442, 0.946, 0.818, 0.45, 0.938, 0.824, 0.459, 0.93, 0.83, 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.86, 0.502, 0.886, 0.866, 0.508, 0.879, 0.872, 0.514, 0.872, 0.878, 0.52, 0.864, 0.884, 0.525, 0.857, 0.89, 0.53, 0.85, 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.81, 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.95, 0.565, 0.744, 0.953, 0.566, 0.733, 0.957, 0.566, 0.722, 0.96, 0.566, 0.71, 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.47, 0.973, 0.519, 0.452, 0.971, 0.515, 0.434, 0.969, 0.51, 0.416, 0.966, 0.504, 0.398, 0.964, 0.499, 0.379, 0.961, 0.494, 0.36, 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.94, 0.459, 0.242, 0.936, 0.452, 0.22, 0.932, 0.446, 0.198, 0.927, 0.44, 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.81, 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.88, 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.82, 0.913, 0.533, 0.812, 0.918, 0.537, 0.803, 0.923, 0.54, 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.55, 0.747, 0.949, 0.551, 0.736, 0.953, 0.552, 0.725, 0.956, 0.552, 0.714, 0.96, 0.552, 0.702, 0.963, 0.552, 0.69, 0.965, 0.551, 0.677, 0.968, 0.55, 0.664, 0.97, 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.54, 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.52, 0.497, 0.975, 0.516, 0.48, 0.973, 0.511, 0.463, 0.972, 0.507, 0.446, 0.97, 0.502, 0.428, 0.968, 0.497, 0.41, 0.966, 0.492, 0.392, 0.963, 0.487, 0.373, 0.96, 0.481, 0.355, 0.957, 0.476, 0.336, 0.954, 0.47, 0.317, 0.951, 0.465, 0.297, 0.947, 0.459, 0.278, 0.944, 0.453, 0.258, 0.94, 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.12, 0.802, 0.385, 0.965, 0.808, 0.395, 0.957, 0.813, 0.405, 0.948, 0.819, 0.414, 0.94, 0.825, 0.423, 0.932, 0.83, 0.431, 0.924, 0.836, 0.439, 0.916, 0.842, 0.447, 0.908, 0.847, 0.454, 0.9, 0.853, 0.462, 0.892, 0.859, 0.468, 0.885, 0.864, 0.475, 0.877, 0.87, 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.83, 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.53, 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.54, 0.976, 0.514, 0.523, 0.975, 0.51, 0.507, 0.975, 0.506, 0.49, 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.96, 0.469, 0.349, 0.957, 0.464, 0.33, 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.94, 0.435, 0.232, 0.936, 0.429, 0.211, 0.932, 0.423, 0.19, 0.927, 0.417, 0.167, 0.923, 0.411, 0.142, 0.919, 0.405, 0.116, 0.806, 0.37, 0.963, 0.811, 0.38, 0.954, 0.816, 0.39, 0.945, 0.822, 0.399, 0.937, 0.827, 0.408, 0.929, 0.833, 0.417, 0.92, 0.838, 0.425, 0.912, 0.844, 0.433, 0.904, 0.85, 0.44, 0.896, 0.855, 0.447, 0.888, 0.861, 0.454, 0.88, 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.79, 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.52, 0.742, 0.945, 0.521, 0.731, 0.948, 0.522, 0.72, 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.52, 0.635, 0.97, 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.5, 0.516, 0.974, 0.497, 0.5, 0.974, 0.493, 0.483, 0.973, 0.489, 0.467, 0.971, 0.485, 0.45, 0.97, 0.48, 0.433, 0.968, 0.476, 0.415, 0.966, 0.471, 0.397, 0.964, 0.466, 0.38, 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.95, 0.44, 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.96, 0.814, 0.364, 0.951, 0.819, 0.375, 0.942, 0.825, 0.384, 0.934, 0.83, 0.393, 0.925, 0.835, 0.402, 0.917, 0.841, 0.41, 0.908, 0.846, 0.418, 0.9, 0.852, 0.426, 0.892, 0.857, 0.433, 0.884, 0.863, 0.44, 0.876, 0.868, 0.446, 0.868, 0.873, 0.452, 0.86, 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.81, 0.909, 0.486, 0.801, 0.914, 0.49, 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.94, 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.69, 0.957, 0.508, 0.678, 0.96, 0.508, 0.666, 0.962, 0.507, 0.653, 0.965, 0.507, 0.64, 0.967, 0.505, 0.627, 0.968, 0.504, 0.613, 0.97, 0.502, 0.599, 0.971, 0.5, 0.585, 0.972, 0.498, 0.57, 0.973, 0.495, 0.555, 0.973, 0.493, 0.54, 0.973, 0.49, 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.46, 0.97, 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.0, 0.0, 0.0, 0.0, 0.062, 0.125, 0.0, 0.125, 0.25, 0.0, 0.188, 0.375, 0.0, 0.25, 0.5, 0.0, 0.312, 0.625, 0.0, 0.375, 0.75, 0.0, 0.438, 0.875, 0.0, 0.5, 1.0, 0.125, 0.062, 0.0, 0.125, 0.125, 0.125, 0.125, 0.188, 0.25, 0.125, 0.25, 0.375, 0.125, 0.312, 0.5, 0.125, 0.375, 0.625, 0.125, 0.438, 0.75, 0.125, 0.5, 0.875, 0.125, 0.562, 1.0, 0.25, 0.125, 0.0, 0.25, 0.188, 0.125, 0.25, 0.25, 0.25, 0.25, 0.312, 0.375, 0.25, 0.375, 0.5, 0.25, 0.438, 0.625, 0.25, 0.5, 0.75, 0.25, 0.562, 0.875, 0.25, 0.625, 1.0, 0.375, 0.188, 0.0, 0.375, 0.25, 0.125, 0.375, 0.312, 0.25, 0.375, 0.375, 0.375, 0.375, 0.438, 0.5, 0.375, 0.5, 0.625, 0.375, 0.562, 0.75, 0.375, 0.625, 0.875, 0.375, 0.688, 1.0, 0.5, 0.25, 0.0, 0.5, 0.312, 0.125, 0.5, 0.375, 0.25, 0.5, 0.438, 0.375, 0.5, 0.5, 0.5, 0.5, 0.562, 0.625, 0.5, 0.625, 0.75, 0.5, 0.688, 0.875, 0.5, 0.75, 1.0, 0.625, 0.312, 0.0, 0.625, 0.375, 0.125, 0.625, 0.438, 0.25, 0.625, 0.5, 0.375, 0.625, 0.562, 0.5, 0.625, 0.625, 0.625, 0.625, 0.688, 0.75, 0.625, 0.75, 0.875, 0.625, 0.812, 1.0, 0.75, 0.375, 0.0, 0.75, 0.438, 0.125, 0.75, 0.5, 0.25, 0.75, 0.562, 0.375, 0.75, 0.625, 0.5, 0.75, 0.688, 0.625, 0.75, 0.75, 0.75, 0.75, 0.812, 0.875, 0.75, 0.875, 1.0, 0.875, 0.438, 0.0, 0.875, 0.5, 0.125, 0.875, 0.562, 0.25, 0.875, 0.625, 0.375, 0.875, 0.688, 0.5, 0.875, 0.75, 0.625, 0.875, 0.812, 0.75, 0.875, 0.875, 0.875, 0.875, 0.938, 1.0, 1.0, 0.5, 0.0, 1.0, 0.562, 0.125, 1.0, 0.625, 0.25, 1.0, 0.688, 0.375, 1.0, 0.75, 0.5, 1.0, 0.812, 0.625, 1.0, 0.875, 0.75, 1.0, 0.938, 0.875, 1.0, 1.0, 1.0]).reshape((9, 9, 3))
cmaps = {'BiPeak': SegmentedBivarColormap(BiPeak, 256, 'square', (0.5, 0.5), name='BiPeak'), 'BiOrangeBlue': SegmentedBivarColormap(BiOrangeBlue, 256, 'square', (0, 0), name='BiOrangeBlue'), 'BiCone': SegmentedBivarColormap(BiPeak, 256, 'circle', (0.5, 0.5), name='BiCone')}

# File: matplotlib-main/lib/matplotlib/_cm_listed.py
from .colors import ListedColormap
_magma_data = [[0.001462, 0.000466, 0.013866], [0.002258, 0.001295, 0.018331], [0.003279, 0.002305, 0.023708], [0.004512, 0.00349, 0.029965], [0.00595, 0.004843, 0.03713], [0.007588, 0.006356, 0.044973], [0.009426, 0.008022, 0.052844], [0.011465, 0.009828, 0.06075], [0.013708, 0.011771, 0.068667], [0.016156, 0.01384, 0.076603], [0.018815, 0.016026, 0.084584], [0.021692, 0.01832, 0.09261], [0.024792, 0.020715, 0.100676], [0.028123, 0.023201, 0.108787], [0.031696, 0.025765, 0.116965], [0.03552, 0.028397, 0.125209], [0.039608, 0.03109, 0.133515], [0.04383, 0.03383, 0.141886], [0.048062, 0.036607, 0.150327], [0.05232, 0.039407, 0.158841], [0.056615, 0.04216, 0.167446], [0.060949, 0.044794, 0.176129], [0.06533, 0.047318, 0.184892], [0.069764, 0.049726, 0.193735], [0.074257, 0.052017, 0.20266], [0.078815, 0.054184, 0.211667], [0.083446, 0.056225, 0.220755], [0.088155, 0.058133, 0.229922], [0.092949, 0.059904, 0.239164], [0.097833, 0.061531, 0.248477], [0.102815, 0.06301, 0.257854], [0.107899, 0.064335, 0.267289], [0.113094, 0.065492, 0.276784], [0.118405, 0.066479, 0.286321], [0.123833, 0.067295, 0.295879], [0.12938, 0.067935, 0.305443], [0.135053, 0.068391, 0.315], [0.140858, 0.068654, 0.324538], [0.146785, 0.068738, 0.334011], [0.152839, 0.068637, 0.343404], [0.159018, 0.068354, 0.352688], [0.165308, 0.067911, 0.361816], [0.171713, 0.067305, 0.370771], [0.178212, 0.066576, 0.379497], [0.184801, 0.065732, 0.387973], [0.19146, 0.064818, 0.396152], [0.198177, 0.063862, 0.404009], [0.204935, 0.062907, 0.411514], [0.211718, 0.061992, 0.418647], [0.218512, 0.061158, 0.425392], [0.225302, 0.060445, 0.431742], [0.232077, 0.059889, 0.437695], [0.238826, 0.059517, 0.443256], [0.245543, 0.059352, 0.448436], [0.25222, 0.059415, 0.453248], [0.258857, 0.059706, 0.45771], [0.265447, 0.060237, 0.46184], [0.271994, 0.060994, 0.46566], [0.278493, 0.061978, 0.46919], [0.284951, 0.063168, 0.472451], [0.291366, 0.064553, 0.475462], [0.29774, 0.066117, 0.478243], [0.304081, 0.067835, 0.480812], [0.310382, 0.069702, 0.483186], [0.316654, 0.07169, 0.48538], [0.322899, 0.073782, 0.487408], [0.329114, 0.075972, 0.489287], [0.335308, 0.078236, 0.491024], [0.341482, 0.080564, 0.492631], [0.347636, 0.082946, 0.494121], [0.353773, 0.085373, 0.495501], [0.359898, 0.087831, 0.496778], [0.366012, 0.090314, 0.49796], [0.372116, 0.092816, 0.499053], [0.378211, 0.095332, 0.500067], [0.384299, 0.097855, 0.501002], [0.390384, 0.100379, 0.501864], [0.396467, 0.102902, 0.502658], [0.402548, 0.10542, 0.503386], [0.408629, 0.10793, 0.504052], [0.414709, 0.110431, 0.504662], [0.420791, 0.11292, 0.505215], [0.426877, 0.115395, 0.505714], [0.432967, 0.117855, 0.50616], [0.439062, 0.120298, 0.506555], [0.445163, 0.122724, 0.506901], [0.451271, 0.125132, 0.507198], [0.457386, 0.127522, 0.507448], [0.463508, 0.129893, 0.507652], [0.46964, 0.132245, 0.507809], [0.47578, 0.134577, 0.507921], [0.481929, 0.136891, 0.507989], [0.488088, 0.139186, 0.508011], [0.494258, 0.141462, 0.507988], [0.500438, 0.143719, 0.50792], [0.506629, 0.145958, 0.507806], [0.512831, 0.148179, 0.507648], [0.519045, 0.150383, 0.507443], [0.52527, 0.152569, 0.507192], [0.531507, 0.154739, 0.506895], [0.537755, 0.156894, 0.506551], [0.544015, 0.159033, 0.506159], [0.550287, 0.161158, 0.505719], [0.556571, 0.163269, 0.50523], [0.562866, 0.165368, 0.504692], [0.569172, 0.167454, 0.504105], [0.57549, 0.16953, 0.503466], [0.581819, 0.171596, 0.502777], [0.588158, 0.173652, 0.502035], [0.594508, 0.175701, 0.501241], [0.600868, 0.177743, 0.500394], [0.607238, 0.179779, 0.499492], [0.613617, 0.181811, 0.498536], [0.620005, 0.18384, 0.497524], [0.626401, 0.185867, 0.496456], [0.632805, 0.187893, 0.495332], [0.639216, 0.189921, 0.49415], [0.645633, 0.191952, 0.49291], [0.652056, 0.193986, 0.491611], [0.658483, 0.196027, 0.490253], [0.664915, 0.198075, 0.488836], [0.671349, 0.200133, 0.487358], [0.677786, 0.202203, 0.485819], [0.684224, 0.204286, 0.484219], [0.690661, 0.206384, 0.482558], [0.697098, 0.208501, 0.480835], [0.703532, 0.210638, 0.479049], [0.709962, 0.212797, 0.477201], [0.716387, 0.214982, 0.47529], [0.722805, 0.217194, 0.473316], [0.729216, 0.219437, 0.471279], [0.735616, 0.221713, 0.46918], [0.742004, 0.224025, 0.467018], [0.748378, 0.226377, 0.464794], [0.754737, 0.228772, 0.462509], [0.761077, 0.231214, 0.460162], [0.767398, 0.233705, 0.457755], [0.773695, 0.236249, 0.455289], [0.779968, 0.238851, 0.452765], [0.786212, 0.241514, 0.450184], [0.792427, 0.244242, 0.447543], [0.798608, 0.24704, 0.444848], [0.804752, 0.249911, 0.442102], [0.810855, 0.252861, 0.439305], [0.816914, 0.255895, 0.436461], [0.822926, 0.259016, 0.433573], [0.828886, 0.262229, 0.430644], [0.834791, 0.26554, 0.427671], [0.840636, 0.268953, 0.424666], [0.846416, 0.272473, 0.421631], [0.852126, 0.276106, 0.418573], [0.857763, 0.279857, 0.415496], [0.86332, 0.283729, 0.412403], [0.868793, 0.287728, 0.409303], [0.874176, 0.291859, 0.406205], [0.879464, 0.296125, 0.403118], [0.884651, 0.30053, 0.400047], [0.889731, 0.305079, 0.397002], [0.8947, 0.309773, 0.393995], [0.899552, 0.314616, 0.391037], [0.904281, 0.31961, 0.388137], [0.908884, 0.324755, 0.385308], [0.913354, 0.330052, 0.382563], [0.917689, 0.3355, 0.379915], [0.921884, 0.341098, 0.377376], [0.925937, 0.346844, 0.374959], [0.929845, 0.352734, 0.372677], [0.933606, 0.358764, 0.370541], [0.937221, 0.364929, 0.368567], [0.940687, 0.371224, 0.366762], [0.944006, 0.377643, 0.365136], [0.94718, 0.384178, 0.363701], [0.95021, 0.39082, 0.362468], [0.953099, 0.397563, 0.361438], [0.955849, 0.4044, 0.360619], [0.958464, 0.411324, 0.360014], [0.960949, 0.418323, 0.35963], [0.96331, 0.42539, 0.359469], [0.965549, 0.432519, 0.359529], [0.967671, 0.439703, 0.35981], [0.96968, 0.446936, 0.360311], [0.971582, 0.45421, 0.36103], [0.973381, 0.46152, 0.361965], [0.975082, 0.468861, 0.363111], [0.97669, 0.476226, 0.364466], [0.97821, 0.483612, 0.366025], [0.979645, 0.491014, 0.367783], [0.981, 0.498428, 0.369734], [0.982279, 0.505851, 0.371874], [0.983485, 0.51328, 0.374198], [0.984622, 0.520713, 0.376698], [0.985693, 0.528148, 0.379371], [0.9867, 0.535582, 0.38221], [0.987646, 0.543015, 0.38521], [0.988533, 0.550446, 0.388365], [0.989363, 0.557873, 0.391671], [0.990138, 0.565296, 0.395122], [0.990871, 0.572706, 0.398714], [0.991558, 0.580107, 0.402441], [0.992196, 0.587502, 0.406299], [0.992785, 0.594891, 0.410283], [0.993326, 0.602275, 0.41439], [0.993834, 0.609644, 0.418613], [0.994309, 0.616999, 0.42295], [0.994738, 0.62435, 0.427397], [0.995122, 0.631696, 0.431951], [0.99548, 0.639027, 0.436607], [0.99581, 0.646344, 0.441361], [0.996096, 0.653659, 0.446213], [0.996341, 0.660969, 0.45116], [0.99658, 0.668256, 0.456192], [0.996775, 0.675541, 0.461314], [0.996925, 0.682828, 0.466526], [0.997077, 0.690088, 0.471811], [0.997186, 0.697349, 0.477182], [0.997254, 0.704611, 0.482635], [0.997325, 0.711848, 0.488154], [0.997351, 0.719089, 0.493755], [0.997351, 0.726324, 0.499428], [0.997341, 0.733545, 0.505167], [0.997285, 0.740772, 0.510983], [0.997228, 0.747981, 0.516859], [0.997138, 0.75519, 0.522806], [0.997019, 0.762398, 0.528821], [0.996898, 0.769591, 0.534892], [0.996727, 0.776795, 0.541039], [0.996571, 0.783977, 0.547233], [0.996369, 0.791167, 0.553499], [0.996162, 0.798348, 0.55982], [0.995932, 0.805527, 0.566202], [0.99568, 0.812706, 0.572645], [0.995424, 0.819875, 0.57914], [0.995131, 0.827052, 0.585701], [0.994851, 0.834213, 0.592307], [0.994524, 0.841387, 0.598983], [0.994222, 0.84854, 0.605696], [0.993866, 0.855711, 0.612482], [0.993545, 0.862859, 0.619299], [0.99317, 0.870024, 0.626189], [0.992831, 0.877168, 0.633109], [0.99244, 0.88433, 0.640099], [0.992089, 0.89147, 0.647116], [0.991688, 0.898627, 0.654202], [0.991332, 0.905763, 0.661309], [0.99093, 0.912915, 0.668481], [0.99057, 0.920049, 0.675675], [0.990175, 0.927196, 0.682926], [0.989815, 0.934329, 0.690198], [0.989434, 0.94147, 0.697519], [0.989077, 0.948604, 0.704863], [0.988717, 0.955742, 0.712242], [0.988367, 0.962878, 0.719649], [0.988033, 0.970012, 0.727077], [0.987691, 0.977154, 0.734536], [0.987387, 0.984288, 0.742002], [0.987053, 0.991438, 0.749504]]
_inferno_data = [[0.001462, 0.000466, 0.013866], [0.002267, 0.00127, 0.01857], [0.003299, 0.002249, 0.024239], [0.004547, 0.003392, 0.030909], [0.006006, 0.004692, 0.038558], [0.007676, 0.006136, 0.046836], [0.009561, 0.007713, 0.055143], [0.011663, 0.009417, 0.06346], [0.013995, 0.011225, 0.071862], [0.016561, 0.013136, 0.080282], [0.019373, 0.015133, 0.088767], [0.022447, 0.017199, 0.097327], [0.025793, 0.019331, 0.10593], [0.029432, 0.021503, 0.114621], [0.033385, 0.023702, 0.123397], [0.037668, 0.025921, 0.132232], [0.042253, 0.028139, 0.141141], [0.046915, 0.030324, 0.150164], [0.051644, 0.032474, 0.159254], [0.056449, 0.034569, 0.168414], [0.06134, 0.03659, 0.177642], [0.066331, 0.038504, 0.186962], [0.071429, 0.040294, 0.196354], [0.076637, 0.041905, 0.205799], [0.081962, 0.043328, 0.215289], [0.087411, 0.044556, 0.224813], [0.09299, 0.045583, 0.234358], [0.098702, 0.046402, 0.243904], [0.104551, 0.047008, 0.25343], [0.110536, 0.047399, 0.262912], [0.116656, 0.047574, 0.272321], [0.122908, 0.047536, 0.281624], [0.129285, 0.047293, 0.290788], [0.135778, 0.046856, 0.299776], [0.142378, 0.046242, 0.308553], [0.149073, 0.045468, 0.317085], [0.15585, 0.044559, 0.325338], [0.162689, 0.043554, 0.333277], [0.169575, 0.042489, 0.340874], [0.176493, 0.041402, 0.348111], [0.183429, 0.040329, 0.354971], [0.190367, 0.039309, 0.361447], [0.197297, 0.0384, 0.367535], [0.204209, 0.037632, 0.373238], [0.211095, 0.03703, 0.378563], [0.217949, 0.036615, 0.383522], [0.224763, 0.036405, 0.388129], [0.231538, 0.036405, 0.3924], [0.238273, 0.036621, 0.396353], [0.244967, 0.037055, 0.400007], [0.25162, 0.037705, 0.403378], [0.258234, 0.038571, 0.406485], [0.26481, 0.039647, 0.409345], [0.271347, 0.040922, 0.411976], [0.27785, 0.042353, 0.414392], [0.284321, 0.043933, 0.416608], [0.290763, 0.045644, 0.418637], [0.297178, 0.04747, 0.420491], [0.303568, 0.049396, 0.422182], [0.309935, 0.051407, 0.423721], [0.316282, 0.05349, 0.425116], [0.32261, 0.055634, 0.426377], [0.328921, 0.057827, 0.427511], [0.335217, 0.06006, 0.428524], [0.3415, 0.062325, 0.429425], [0.347771, 0.064616, 0.430217], [0.354032, 0.066925, 0.430906], [0.360284, 0.069247, 0.431497], [0.366529, 0.071579, 0.431994], [0.372768, 0.073915, 0.4324], [0.379001, 0.076253, 0.432719], [0.385228, 0.078591, 0.432955], [0.391453, 0.080927, 0.433109], [0.397674, 0.083257, 0.433183], [0.403894, 0.08558, 0.433179], [0.410113, 0.087896, 0.433098], [0.416331, 0.090203, 0.432943], [0.422549, 0.092501, 0.432714], [0.428768, 0.09479, 0.432412], [0.434987, 0.097069, 0.432039], [0.441207, 0.099338, 0.431594], [0.447428, 0.101597, 0.43108], [0.453651, 0.103848, 0.430498], [0.459875, 0.106089, 0.429846], [0.4661, 0.108322, 0.429125], [0.472328, 0.110547, 0.428334], [0.478558, 0.112764, 0.427475], [0.484789, 0.114974, 0.426548], [0.491022, 0.117179, 0.425552], [0.497257, 0.119379, 0.424488], [0.503493, 0.121575, 0.423356], [0.50973, 0.123769, 0.422156], [0.515967, 0.12596, 0.420887], [0.522206, 0.12815, 0.419549], [0.528444, 0.130341, 0.418142], [0.534683, 0.132534, 0.416667], [0.54092, 0.134729, 0.415123], [0.547157, 0.136929, 0.413511], [0.553392, 0.139134, 0.411829], [0.559624, 0.141346, 0.410078], [0.565854, 0.143567, 0.408258], [0.572081, 0.145797, 0.406369], [0.578304, 0.148039, 0.404411], [0.584521, 0.150294, 0.402385], [0.590734, 0.152563, 0.40029], [0.59694, 0.154848, 0.398125], [0.603139, 0.157151, 0.395891], [0.60933, 0.159474, 0.393589], [0.615513, 0.161817, 0.391219], [0.621685, 0.164184, 0.388781], [0.627847, 0.166575, 0.386276], [0.633998, 0.168992, 0.383704], [0.640135, 0.171438, 0.381065], [0.64626, 0.173914, 0.378359], [0.652369, 0.176421, 0.375586], [0.658463, 0.178962, 0.372748], [0.66454, 0.181539, 0.369846], [0.670599, 0.184153, 0.366879], [0.676638, 0.186807, 0.363849], [0.682656, 0.189501, 0.360757], [0.688653, 0.192239, 0.357603], [0.694627, 0.195021, 0.354388], [0.700576, 0.197851, 0.351113], [0.7065, 0.200728, 0.347777], [0.712396, 0.203656, 0.344383], [0.718264, 0.206636, 0.340931], [0.724103, 0.20967, 0.337424], [0.729909, 0.212759, 0.333861], [0.735683, 0.215906, 0.330245], [0.741423, 0.219112, 0.326576], [0.747127, 0.222378, 0.322856], [0.752794, 0.225706, 0.319085], [0.758422, 0.229097, 0.315266], [0.76401, 0.232554, 0.311399], [0.769556, 0.236077, 0.307485], [0.775059, 0.239667, 0.303526], [0.780517, 0.243327, 0.299523], [0.785929, 0.247056, 0.295477], [0.791293, 0.250856, 0.29139], [0.796607, 0.254728, 0.287264], [0.801871, 0.258674, 0.283099], [0.807082, 0.262692, 0.278898], [0.812239, 0.266786, 0.274661], [0.817341, 0.270954, 0.27039], [0.822386, 0.275197, 0.266085], [0.827372, 0.279517, 0.26175], [0.832299, 0.283913, 0.257383], [0.837165, 0.288385, 0.252988], [0.841969, 0.292933, 0.248564], [0.846709, 0.297559, 0.244113], [0.851384, 0.30226, 0.239636], [0.855992, 0.307038, 0.235133], [0.860533, 0.311892, 0.230606], [0.865006, 0.316822, 0.226055], [0.869409, 0.321827, 0.221482], [0.873741, 0.326906, 0.216886], [0.878001, 0.33206, 0.212268], [0.882188, 0.337287, 0.207628], [0.886302, 0.342586, 0.202968], [0.890341, 0.347957, 0.198286], [0.894305, 0.353399, 0.193584], [0.898192, 0.358911, 0.18886], [0.902003, 0.364492, 0.184116], [0.905735, 0.37014, 0.17935], [0.90939, 0.375856, 0.174563], [0.912966, 0.381636, 0.169755], [0.916462, 0.387481, 0.164924], [0.919879, 0.393389, 0.16007], [0.923215, 0.399359, 0.155193], [0.92647, 0.405389, 0.150292], [0.929644, 0.411479, 0.145367], [0.932737, 0.417627, 0.140417], [0.935747, 0.423831, 0.13544], [0.938675, 0.430091, 0.130438], [0.941521, 0.436405, 0.125409], [0.944285, 0.442772, 0.120354], [0.946965, 0.449191, 0.115272], [0.949562, 0.45566, 0.110164], [0.952075, 0.462178, 0.105031], [0.954506, 0.468744, 0.099874], [0.956852, 0.475356, 0.094695], [0.959114, 0.482014, 0.089499], [0.961293, 0.488716, 0.084289], [0.963387, 0.495462, 0.079073], [0.965397, 0.502249, 0.073859], [0.967322, 0.509078, 0.068659], [0.969163, 0.515946, 0.063488], [0.970919, 0.522853, 0.058367], [0.97259, 0.529798, 0.053324], [0.974176, 0.53678, 0.048392], [0.975677, 0.543798, 0.043618], [0.977092, 0.55085, 0.03905], [0.978422, 0.557937, 0.034931], [0.979666, 0.565057, 0.031409], [0.980824, 0.572209, 0.028508], [0.981895, 0.579392, 0.02625], [0.982881, 0.586606, 0.024661], [0.983779, 0.593849, 0.02377], [0.984591, 0.601122, 0.023606], [0.985315, 0.608422, 0.024202], [0.985952, 0.61575, 0.025592], [0.986502, 0.623105, 0.027814], [0.986964, 0.630485, 0.030908], [0.987337, 0.63789, 0.034916], [0.987622, 0.64532, 0.039886], [0.987819, 0.652773, 0.045581], [0.987926, 0.66025, 0.05175], [0.987945, 0.667748, 0.058329], [0.987874, 0.675267, 0.065257], [0.987714, 0.682807, 0.072489], [0.987464, 0.690366, 0.07999], [0.987124, 0.697944, 0.087731], [0.986694, 0.70554, 0.095694], [0.986175, 0.713153, 0.103863], [0.985566, 0.720782, 0.112229], [0.984865, 0.728427, 0.120785], [0.984075, 0.736087, 0.129527], [0.983196, 0.743758, 0.138453], [0.982228, 0.751442, 0.147565], [0.981173, 0.759135, 0.156863], [0.980032, 0.766837, 0.166353], [0.978806, 0.774545, 0.176037], [0.977497, 0.782258, 0.185923], [0.976108, 0.789974, 0.196018], [0.974638, 0.797692, 0.206332], [0.973088, 0.805409, 0.216877], [0.971468, 0.813122, 0.227658], [0.969783, 0.820825, 0.238686], [0.968041, 0.828515, 0.249972], [0.966243, 0.836191, 0.261534], [0.964394, 0.843848, 0.273391], [0.962517, 0.851476, 0.285546], [0.960626, 0.859069, 0.29801], [0.95872, 0.866624, 0.31082], [0.956834, 0.874129, 0.323974], [0.954997, 0.881569, 0.337475], [0.953215, 0.888942, 0.351369], [0.951546, 0.896226, 0.365627], [0.950018, 0.903409, 0.380271], [0.948683, 0.910473, 0.395289], [0.947594, 0.917399, 0.410665], [0.946809, 0.924168, 0.426373], [0.946392, 0.930761, 0.442367], [0.946403, 0.937159, 0.458592], [0.946903, 0.943348, 0.47497], [0.947937, 0.949318, 0.491426], [0.949545, 0.955063, 0.50786], [0.95174, 0.960587, 0.524203], [0.954529, 0.965896, 0.540361], [0.957896, 0.971003, 0.556275], [0.961812, 0.975924, 0.571925], [0.966249, 0.980678, 0.587206], [0.971162, 0.985282, 0.602154], [0.976511, 0.989753, 0.61676], [0.982257, 0.994109, 0.631017], [0.988362, 0.998364, 0.644924]]
_plasma_data = [[0.050383, 0.029803, 0.527975], [0.063536, 0.028426, 0.533124], [0.075353, 0.027206, 0.538007], [0.086222, 0.026125, 0.542658], [0.096379, 0.025165, 0.547103], [0.10598, 0.024309, 0.551368], [0.115124, 0.023556, 0.555468], [0.123903, 0.022878, 0.559423], [0.132381, 0.022258, 0.56325], [0.140603, 0.021687, 0.566959], [0.148607, 0.021154, 0.570562], [0.156421, 0.020651, 0.574065], [0.16407, 0.020171, 0.577478], [0.171574, 0.019706, 0.580806], [0.17895, 0.019252, 0.584054], [0.186213, 0.018803, 0.587228], [0.193374, 0.018354, 0.59033], [0.200445, 0.017902, 0.593364], [0.207435, 0.017442, 0.596333], [0.21435, 0.016973, 0.599239], [0.221197, 0.016497, 0.602083], [0.227983, 0.016007, 0.604867], [0.234715, 0.015502, 0.607592], [0.241396, 0.014979, 0.610259], [0.248032, 0.014439, 0.612868], [0.254627, 0.013882, 0.615419], [0.261183, 0.013308, 0.617911], [0.267703, 0.012716, 0.620346], [0.274191, 0.012109, 0.622722], [0.280648, 0.011488, 0.625038], [0.287076, 0.010855, 0.627295], [0.293478, 0.010213, 0.62949], [0.299855, 0.009561, 0.631624], [0.30621, 0.008902, 0.633694], [0.312543, 0.008239, 0.6357], [0.318856, 0.007576, 0.63764], [0.32515, 0.006915, 0.639512], [0.331426, 0.006261, 0.641316], [0.337683, 0.005618, 0.643049], [0.343925, 0.004991, 0.64471], [0.35015, 0.004382, 0.646298], [0.356359, 0.003798, 0.64781], [0.362553, 0.003243, 0.649245], [0.368733, 0.002724, 0.650601], [0.374897, 0.002245, 0.651876], [0.381047, 0.001814, 0.653068], [0.387183, 0.001434, 0.654177], [0.393304, 0.001114, 0.655199], [0.399411, 0.000859, 0.656133], [0.405503, 0.000678, 0.656977], [0.41158, 0.000577, 0.65773], [0.417642, 0.000564, 0.65839], [0.423689, 0.000646, 0.658956], [0.429719, 0.000831, 0.659425], [0.435734, 0.001127, 0.659797], [0.441732, 0.00154, 0.660069], [0.447714, 0.00208, 0.66024], [0.453677, 0.002755, 0.66031], [0.459623, 0.003574, 0.660277], [0.46555, 0.004545, 0.660139], [0.471457, 0.005678, 0.659897], [0.477344, 0.00698, 0.659549], [0.48321, 0.00846, 0.659095], [0.489055, 0.010127, 0.658534], [0.494877, 0.01199, 0.657865], [0.500678, 0.014055, 0.657088], [0.506454, 0.016333, 0.656202], [0.512206, 0.018833, 0.655209], [0.517933, 0.021563, 0.654109], [0.523633, 0.024532, 0.652901], [0.529306, 0.027747, 0.651586], [0.534952, 0.031217, 0.650165], [0.54057, 0.03495, 0.64864], [0.546157, 0.038954, 0.64701], [0.551715, 0.043136, 0.645277], [0.557243, 0.047331, 0.643443], [0.562738, 0.051545, 0.641509], [0.568201, 0.055778, 0.639477], [0.573632, 0.060028, 0.637349], [0.579029, 0.064296, 0.635126], [0.584391, 0.068579, 0.632812], [0.589719, 0.072878, 0.630408], [0.595011, 0.07719, 0.627917], [0.600266, 0.081516, 0.625342], [0.605485, 0.085854, 0.622686], [0.610667, 0.090204, 0.619951], [0.615812, 0.094564, 0.61714], [0.620919, 0.098934, 0.614257], [0.625987, 0.103312, 0.611305], [0.631017, 0.107699, 0.608287], [0.636008, 0.112092, 0.605205], [0.640959, 0.116492, 0.602065], [0.645872, 0.120898, 0.598867], [0.650746, 0.125309, 0.595617], [0.65558, 0.129725, 0.592317], [0.660374, 0.134144, 0.588971], [0.665129, 0.138566, 0.585582], [0.669845, 0.142992, 0.582154], [0.674522, 0.147419, 0.578688], [0.67916, 0.151848, 0.575189], [0.683758, 0.156278, 0.57166], [0.688318, 0.160709, 0.568103], [0.69284, 0.165141, 0.564522], [0.697324, 0.169573, 0.560919], [0.701769, 0.174005, 0.557296], [0.706178, 0.178437, 0.553657], [0.710549, 0.182868, 0.550004], [0.714883, 0.187299, 0.546338], [0.719181, 0.191729, 0.542663], [0.723444, 0.196158, 0.538981], [0.72767, 0.200586, 0.535293], [0.731862, 0.205013, 0.531601], [0.736019, 0.209439, 0.527908], [0.740143, 0.213864, 0.524216], [0.744232, 0.218288, 0.520524], [0.748289, 0.222711, 0.516834], [0.752312, 0.227133, 0.513149], [0.756304, 0.231555, 0.509468], [0.760264, 0.235976, 0.505794], [0.764193, 0.240396, 0.502126], [0.76809, 0.244817, 0.498465], [0.771958, 0.249237, 0.494813], [0.775796, 0.253658, 0.491171], [0.779604, 0.258078, 0.487539], [0.783383, 0.2625, 0.483918], [0.787133, 0.266922, 0.480307], [0.790855, 0.271345, 0.476706], [0.794549, 0.27577, 0.473117], [0.798216, 0.280197, 0.469538], [0.801855, 0.284626, 0.465971], [0.805467, 0.289057, 0.462415], [0.809052, 0.293491, 0.45887], [0.812612, 0.297928, 0.455338], [0.816144, 0.302368, 0.451816], [0.819651, 0.306812, 0.448306], [0.823132, 0.311261, 0.444806], [0.826588, 0.315714, 0.441316], [0.830018, 0.320172, 0.437836], [0.833422, 0.324635, 0.434366], [0.836801, 0.329105, 0.430905], [0.840155, 0.33358, 0.427455], [0.843484, 0.338062, 0.424013], [0.846788, 0.342551, 0.420579], [0.850066, 0.347048, 0.417153], [0.853319, 0.351553, 0.413734], [0.856547, 0.356066, 0.410322], [0.85975, 0.360588, 0.406917], [0.862927, 0.365119, 0.403519], [0.866078, 0.36966, 0.400126], [0.869203, 0.374212, 0.396738], [0.872303, 0.378774, 0.393355], [0.875376, 0.383347, 0.389976], [0.878423, 0.387932, 0.3866], [0.881443, 0.392529, 0.383229], [0.884436, 0.397139, 0.37986], [0.887402, 0.401762, 0.376494], [0.89034, 0.406398, 0.37313], [0.89325, 0.411048, 0.369768], [0.896131, 0.415712, 0.366407], [0.898984, 0.420392, 0.363047], [0.901807, 0.425087, 0.359688], [0.904601, 0.429797, 0.356329], [0.907365, 0.434524, 0.35297], [0.910098, 0.439268, 0.34961], [0.9128, 0.444029, 0.346251], [0.915471, 0.448807, 0.34289], [0.918109, 0.453603, 0.339529], [0.920714, 0.458417, 0.336166], [0.923287, 0.463251, 0.332801], [0.925825, 0.468103, 0.329435], [0.928329, 0.472975, 0.326067], [0.930798, 0.477867, 0.322697], [0.933232, 0.48278, 0.319325], [0.93563, 0.487712, 0.315952], [0.93799, 0.492667, 0.312575], [0.940313, 0.497642, 0.309197], [0.942598, 0.502639, 0.305816], [0.944844, 0.507658, 0.302433], [0.947051, 0.512699, 0.299049], [0.949217, 0.517763, 0.295662], [0.951344, 0.52285, 0.292275], [0.953428, 0.52796, 0.288883], [0.95547, 0.533093, 0.28549], [0.957469, 0.53825, 0.282096], [0.959424, 0.543431, 0.278701], [0.961336, 0.548636, 0.275305], [0.963203, 0.553865, 0.271909], [0.965024, 0.559118, 0.268513], [0.966798, 0.564396, 0.265118], [0.968526, 0.5697, 0.261721], [0.970205, 0.575028, 0.258325], [0.971835, 0.580382, 0.254931], [0.973416, 0.585761, 0.25154], [0.974947, 0.591165, 0.248151], [0.976428, 0.596595, 0.244767], [0.977856, 0.602051, 0.241387], [0.979233, 0.607532, 0.238013], [0.980556, 0.613039, 0.234646], [0.981826, 0.618572, 0.231287], [0.983041, 0.624131, 0.227937], [0.984199, 0.629718, 0.224595], [0.985301, 0.63533, 0.221265], [0.986345, 0.640969, 0.217948], [0.987332, 0.646633, 0.214648], [0.98826, 0.652325, 0.211364], [0.989128, 0.658043, 0.2081], [0.989935, 0.663787, 0.204859], [0.990681, 0.669558, 0.201642], [0.991365, 0.675355, 0.198453], [0.991985, 0.681179, 0.195295], [0.992541, 0.68703, 0.19217], [0.993032, 0.692907, 0.189084], [0.993456, 0.69881, 0.186041], [0.993814, 0.704741, 0.183043], [0.994103, 0.710698, 0.180097], [0.994324, 0.716681, 0.177208], [0.994474, 0.722691, 0.174381], [0.994553, 0.728728, 0.171622], [0.994561, 0.734791, 0.168938], [0.994495, 0.74088, 0.166335], [0.994355, 0.746995, 0.163821], [0.994141, 0.753137, 0.161404], [0.993851, 0.759304, 0.159092], [0.993482, 0.765499, 0.156891], [0.993033, 0.77172, 0.154808], [0.992505, 0.777967, 0.152855], [0.991897, 0.784239, 0.151042], [0.991209, 0.790537, 0.149377], [0.990439, 0.796859, 0.14787], [0.989587, 0.803205, 0.146529], [0.988648, 0.809579, 0.145357], [0.987621, 0.815978, 0.144363], [0.986509, 0.822401, 0.143557], [0.985314, 0.828846, 0.142945], [0.984031, 0.835315, 0.142528], [0.982653, 0.841812, 0.142303], [0.98119, 0.848329, 0.142279], [0.979644, 0.854866, 0.142453], [0.977995, 0.861432, 0.142808], [0.976265, 0.868016, 0.143351], [0.974443, 0.874622, 0.144061], [0.97253, 0.88125, 0.144923], [0.970533, 0.887896, 0.145919], [0.968443, 0.894564, 0.147014], [0.966271, 0.901249, 0.14818], [0.964021, 0.90795, 0.14937], [0.961681, 0.914672, 0.15052], [0.959276, 0.921407, 0.151566], [0.956808, 0.928152, 0.152409], [0.954287, 0.934908, 0.152921], [0.951726, 0.941671, 0.152925], [0.949151, 0.948435, 0.152178], [0.946602, 0.95519, 0.150328], [0.944152, 0.961916, 0.146861], [0.941896, 0.96859, 0.140956], [0.940015, 0.975158, 0.131326]]
_viridis_data = [[0.267004, 0.004874, 0.329415], [0.26851, 0.009605, 0.335427], [0.269944, 0.014625, 0.341379], [0.271305, 0.019942, 0.347269], [0.272594, 0.025563, 0.353093], [0.273809, 0.031497, 0.358853], [0.274952, 0.037752, 0.364543], [0.276022, 0.044167, 0.370164], [0.277018, 0.050344, 0.375715], [0.277941, 0.056324, 0.381191], [0.278791, 0.062145, 0.386592], [0.279566, 0.067836, 0.391917], [0.280267, 0.073417, 0.397163], [0.280894, 0.078907, 0.402329], [0.281446, 0.08432, 0.407414], [0.281924, 0.089666, 0.412415], [0.282327, 0.094955, 0.417331], [0.282656, 0.100196, 0.42216], [0.28291, 0.105393, 0.426902], [0.283091, 0.110553, 0.431554], [0.283197, 0.11568, 0.436115], [0.283229, 0.120777, 0.440584], [0.283187, 0.125848, 0.44496], [0.283072, 0.130895, 0.449241], [0.282884, 0.13592, 0.453427], [0.282623, 0.140926, 0.457517], [0.28229, 0.145912, 0.46151], [0.281887, 0.150881, 0.465405], [0.281412, 0.155834, 0.469201], [0.280868, 0.160771, 0.472899], [0.280255, 0.165693, 0.476498], [0.279574, 0.170599, 0.479997], [0.278826, 0.17549, 0.483397], [0.278012, 0.180367, 0.486697], [0.277134, 0.185228, 0.489898], [0.276194, 0.190074, 0.493001], [0.275191, 0.194905, 0.496005], [0.274128, 0.199721, 0.498911], [0.273006, 0.20452, 0.501721], [0.271828, 0.209303, 0.504434], [0.270595, 0.214069, 0.507052], [0.269308, 0.218818, 0.509577], [0.267968, 0.223549, 0.512008], [0.26658, 0.228262, 0.514349], [0.265145, 0.232956, 0.516599], [0.263663, 0.237631, 0.518762], [0.262138, 0.242286, 0.520837], [0.260571, 0.246922, 0.522828], [0.258965, 0.251537, 0.524736], [0.257322, 0.25613, 0.526563], [0.255645, 0.260703, 0.528312], [0.253935, 0.265254, 0.529983], [0.252194, 0.269783, 0.531579], [0.250425, 0.27429, 0.533103], [0.248629, 0.278775, 0.534556], [0.246811, 0.283237, 0.535941], [0.244972, 0.287675, 0.53726], [0.243113, 0.292092, 0.538516], [0.241237, 0.296485, 0.539709], [0.239346, 0.300855, 0.540844], [0.237441, 0.305202, 0.541921], [0.235526, 0.309527, 0.542944], [0.233603, 0.313828, 0.543914], [0.231674, 0.318106, 0.544834], [0.229739, 0.322361, 0.545706], [0.227802, 0.326594, 0.546532], [0.225863, 0.330805, 0.547314], [0.223925, 0.334994, 0.548053], [0.221989, 0.339161, 0.548752], [0.220057, 0.343307, 0.549413], [0.21813, 0.347432, 0.550038], [0.21621, 0.351535, 0.550627], [0.214298, 0.355619, 0.551184], [0.212395, 0.359683, 0.55171], [0.210503, 0.363727, 0.552206], [0.208623, 0.367752, 0.552675], [0.206756, 0.371758, 0.553117], [0.204903, 0.375746, 0.553533], [0.203063, 0.379716, 0.553925], [0.201239, 0.38367, 0.554294], [0.19943, 0.387607, 0.554642], [0.197636, 0.391528, 0.554969], [0.19586, 0.395433, 0.555276], [0.1941, 0.399323, 0.555565], [0.192357, 0.403199, 0.555836], [0.190631, 0.407061, 0.556089], [0.188923, 0.41091, 0.556326], [0.187231, 0.414746, 0.556547], [0.185556, 0.41857, 0.556753], [0.183898, 0.422383, 0.556944], [0.182256, 0.426184, 0.55712], [0.180629, 0.429975, 0.557282], [0.179019, 0.433756, 0.55743], [0.177423, 0.437527, 0.557565], [0.175841, 0.44129, 0.557685], [0.174274, 0.445044, 0.557792], [0.172719, 0.448791, 0.557885], [0.171176, 0.45253, 0.557965], [0.169646, 0.456262, 0.55803], [0.168126, 0.459988, 0.558082], [0.166617, 0.463708, 0.558119], [0.165117, 0.467423, 0.558141], [0.163625, 0.471133, 0.558148], [0.162142, 0.474838, 0.55814], [0.160665, 0.47854, 0.558115], [0.159194, 0.482237, 0.558073], [0.157729, 0.485932, 0.558013], [0.15627, 0.489624, 0.557936], [0.154815, 0.493313, 0.55784], [0.153364, 0.497, 0.557724], [0.151918, 0.500685, 0.557587], [0.150476, 0.504369, 0.55743], [0.149039, 0.508051, 0.55725], [0.147607, 0.511733, 0.557049], [0.14618, 0.515413, 0.556823], [0.144759, 0.519093, 0.556572], [0.143343, 0.522773, 0.556295], [0.141935, 0.526453, 0.555991], [0.140536, 0.530132, 0.555659], [0.139147, 0.533812, 0.555298], [0.13777, 0.537492, 0.554906], [0.136408, 0.541173, 0.554483], [0.135066, 0.544853, 0.554029], [0.133743, 0.548535, 0.553541], [0.132444, 0.552216, 0.553018], [0.131172, 0.555899, 0.552459], [0.129933, 0.559582, 0.551864], [0.128729, 0.563265, 0.551229], [0.127568, 0.566949, 0.550556], [0.126453, 0.570633, 0.549841], [0.125394, 0.574318, 0.549086], [0.124395, 0.578002, 0.548287], [0.123463, 0.581687, 0.547445], [0.122606, 0.585371, 0.546557], [0.121831, 0.589055, 0.545623], [0.121148, 0.592739, 0.544641], [0.120565, 0.596422, 0.543611], [0.120092, 0.600104, 0.54253], [0.119738, 0.603785, 0.5414], [0.119512, 0.607464, 0.540218], [0.119423, 0.611141, 0.538982], [0.119483, 0.614817, 0.537692], [0.119699, 0.61849, 0.536347], [0.120081, 0.622161, 0.534946], [0.120638, 0.625828, 0.533488], [0.12138, 0.629492, 0.531973], [0.122312, 0.633153, 0.530398], [0.123444, 0.636809, 0.528763], [0.12478, 0.640461, 0.527068], [0.126326, 0.644107, 0.525311], [0.128087, 0.647749, 0.523491], [0.130067, 0.651384, 0.521608], [0.132268, 0.655014, 0.519661], [0.134692, 0.658636, 0.517649], [0.137339, 0.662252, 0.515571], [0.14021, 0.665859, 0.513427], [0.143303, 0.669459, 0.511215], [0.146616, 0.67305, 0.508936], [0.150148, 0.676631, 0.506589], [0.153894, 0.680203, 0.504172], [0.157851, 0.683765, 0.501686], [0.162016, 0.687316, 0.499129], [0.166383, 0.690856, 0.496502], [0.170948, 0.694384, 0.493803], [0.175707, 0.6979, 0.491033], [0.180653, 0.701402, 0.488189], [0.185783, 0.704891, 0.485273], [0.19109, 0.708366, 0.482284], [0.196571, 0.711827, 0.479221], [0.202219, 0.715272, 0.476084], [0.20803, 0.718701, 0.472873], [0.214, 0.722114, 0.469588], [0.220124, 0.725509, 0.466226], [0.226397, 0.728888, 0.462789], [0.232815, 0.732247, 0.459277], [0.239374, 0.735588, 0.455688], [0.24607, 0.73891, 0.452024], [0.252899, 0.742211, 0.448284], [0.259857, 0.745492, 0.444467], [0.266941, 0.748751, 0.440573], [0.274149, 0.751988, 0.436601], [0.281477, 0.755203, 0.432552], [0.288921, 0.758394, 0.428426], [0.296479, 0.761561, 0.424223], [0.304148, 0.764704, 0.419943], [0.311925, 0.767822, 0.415586], [0.319809, 0.770914, 0.411152], [0.327796, 0.77398, 0.40664], [0.335885, 0.777018, 0.402049], [0.344074, 0.780029, 0.397381], [0.35236, 0.783011, 0.392636], [0.360741, 0.785964, 0.387814], [0.369214, 0.788888, 0.382914], [0.377779, 0.791781, 0.377939], [0.386433, 0.794644, 0.372886], [0.395174, 0.797475, 0.367757], [0.404001, 0.800275, 0.362552], [0.412913, 0.803041, 0.357269], [0.421908, 0.805774, 0.35191], [0.430983, 0.808473, 0.346476], [0.440137, 0.811138, 0.340967], [0.449368, 0.813768, 0.335384], [0.458674, 0.816363, 0.329727], [0.468053, 0.818921, 0.323998], [0.477504, 0.821444, 0.318195], [0.487026, 0.823929, 0.312321], [0.496615, 0.826376, 0.306377], [0.506271, 0.828786, 0.300362], [0.515992, 0.831158, 0.294279], [0.525776, 0.833491, 0.288127], [0.535621, 0.835785, 0.281908], [0.545524, 0.838039, 0.275626], [0.555484, 0.840254, 0.269281], [0.565498, 0.84243, 0.262877], [0.575563, 0.844566, 0.256415], [0.585678, 0.846661, 0.249897], [0.595839, 0.848717, 0.243329], [0.606045, 0.850733, 0.236712], [0.616293, 0.852709, 0.230052], [0.626579, 0.854645, 0.223353], [0.636902, 0.856542, 0.21662], [0.647257, 0.8584, 0.209861], [0.657642, 0.860219, 0.203082], [0.668054, 0.861999, 0.196293], [0.678489, 0.863742, 0.189503], [0.688944, 0.865448, 0.182725], [0.699415, 0.867117, 0.175971], [0.709898, 0.868751, 0.169257], [0.720391, 0.87035, 0.162603], [0.730889, 0.871916, 0.156029], [0.741388, 0.873449, 0.149561], [0.751884, 0.874951, 0.143228], [0.762373, 0.876424, 0.137064], [0.772852, 0.877868, 0.131109], [0.783315, 0.879285, 0.125405], [0.79376, 0.880678, 0.120005], [0.804182, 0.882046, 0.114965], [0.814576, 0.883393, 0.110347], [0.82494, 0.88472, 0.106217], [0.83527, 0.886029, 0.102646], [0.845561, 0.887322, 0.099702], [0.85581, 0.888601, 0.097452], [0.866013, 0.889868, 0.095953], [0.876168, 0.891125, 0.09525], [0.886271, 0.892374, 0.095374], [0.89632, 0.893616, 0.096335], [0.906311, 0.894855, 0.098125], [0.916242, 0.896091, 0.100717], [0.926106, 0.89733, 0.104071], [0.935904, 0.89857, 0.108131], [0.945636, 0.899815, 0.112838], [0.9553, 0.901065, 0.118128], [0.964894, 0.902323, 0.123941], [0.974417, 0.90359, 0.130215], [0.983868, 0.904867, 0.136897], [0.993248, 0.906157, 0.143936]]
_cividis_data = [[0.0, 0.135112, 0.304751], [0.0, 0.138068, 0.311105], [0.0, 0.141013, 0.317579], [0.0, 0.143951, 0.323982], [0.0, 0.146877, 0.330479], [0.0, 0.149791, 0.337065], [0.0, 0.152673, 0.343704], [0.0, 0.155377, 0.3505], [0.0, 0.157932, 0.357521], [0.0, 0.160495, 0.364534], [0.0, 0.163058, 0.371608], [0.0, 0.165621, 0.378769], [0.0, 0.168204, 0.385902], [0.0, 0.1708, 0.3931], [0.0, 0.17342, 0.400353], [0.0, 0.176082, 0.407577], [0.0, 0.178802, 0.414764], [0.0, 0.18161, 0.421859], [0.0, 0.18455, 0.428802], [0.0, 0.186915, 0.435532], [0.0, 0.188769, 0.439563], [0.0, 0.19095, 0.441085], [0.0, 0.193366, 0.441561], [0.003602, 0.195911, 0.441564], [0.017852, 0.198528, 0.441248], [0.03211, 0.201199, 0.440785], [0.046205, 0.203903, 0.440196], [0.058378, 0.206629, 0.439531], [0.068968, 0.209372, 0.438863], [0.078624, 0.212122, 0.438105], [0.087465, 0.214879, 0.437342], [0.095645, 0.217643, 0.436593], [0.103401, 0.220406, 0.43579], [0.110658, 0.22317, 0.435067], [0.117612, 0.225935, 0.434308], [0.124291, 0.228697, 0.433547], [0.130669, 0.231458, 0.43284], [0.13683, 0.234216, 0.432148], [0.142852, 0.236972, 0.431404], [0.148638, 0.239724, 0.430752], [0.154261, 0.242475, 0.43012], [0.159733, 0.245221, 0.429528], [0.165113, 0.247965, 0.428908], [0.170362, 0.250707, 0.428325], [0.17549, 0.253444, 0.42779], [0.180503, 0.25618, 0.427299], [0.185453, 0.258914, 0.426788], [0.190303, 0.261644, 0.426329], [0.195057, 0.264372, 0.425924], [0.199764, 0.267099, 0.425497], [0.204385, 0.269823, 0.425126], [0.208926, 0.272546, 0.424809], [0.213431, 0.275266, 0.42448], [0.217863, 0.277985, 0.424206], [0.222264, 0.280702, 0.423914], [0.226598, 0.283419, 0.423678], [0.230871, 0.286134, 0.423498], [0.23512, 0.288848, 0.423304], [0.239312, 0.291562, 0.423167], [0.243485, 0.294274, 0.423014], [0.247605, 0.296986, 0.422917], [0.251675, 0.299698, 0.422873], [0.255731, 0.302409, 0.422814], [0.25974, 0.30512, 0.42281], [0.263738, 0.307831, 0.422789], [0.267693, 0.310542, 0.422821], [0.271639, 0.313253, 0.422837], [0.275513, 0.315965, 0.422979], [0.279411, 0.318677, 0.423031], [0.28324, 0.32139, 0.423211], [0.287065, 0.324103, 0.423373], [0.290884, 0.326816, 0.423517], [0.294669, 0.329531, 0.423716], [0.298421, 0.332247, 0.423973], [0.302169, 0.334963, 0.424213], [0.305886, 0.337681, 0.424512], [0.309601, 0.340399, 0.42479], [0.313287, 0.34312, 0.42512], [0.316941, 0.345842, 0.425512], [0.320595, 0.348565, 0.425889], [0.32425, 0.351289, 0.42625], [0.327875, 0.354016, 0.42667], [0.331474, 0.356744, 0.427144], [0.335073, 0.359474, 0.427605], [0.338673, 0.362206, 0.428053], [0.342246, 0.364939, 0.428559], [0.345793, 0.367676, 0.429127], [0.349341, 0.370414, 0.429685], [0.352892, 0.373153, 0.430226], [0.356418, 0.375896, 0.430823], [0.359916, 0.378641, 0.431501], [0.363446, 0.381388, 0.432075], [0.366923, 0.384139, 0.432796], [0.37043, 0.38689, 0.433428], [0.373884, 0.389646, 0.434209], [0.377371, 0.392404, 0.43489], [0.38083, 0.395164, 0.435653], [0.384268, 0.397928, 0.436475], [0.387705, 0.400694, 0.437305], [0.391151, 0.403464, 0.438096], [0.394568, 0.406236, 0.438986], [0.397991, 0.409011, 0.439848], [0.401418, 0.41179, 0.440708], [0.40482, 0.414572, 0.441642], [0.408226, 0.417357, 0.44257], [0.411607, 0.420145, 0.443577], [0.414992, 0.422937, 0.444578], [0.418383, 0.425733, 0.44556], [0.421748, 0.428531, 0.44664], [0.42512, 0.431334, 0.447692], [0.428462, 0.43414, 0.448864], [0.431817, 0.43695, 0.449982], [0.435168, 0.439763, 0.451134], [0.438504, 0.44258, 0.452341], [0.44181, 0.445402, 0.453659], [0.445148, 0.448226, 0.454885], [0.448447, 0.451053, 0.456264], [0.451759, 0.453887, 0.457582], [0.455072, 0.456718, 0.458976], [0.458366, 0.459552, 0.460457], [0.461616, 0.462405, 0.461969], [0.464947, 0.465241, 0.463395], [0.468254, 0.468083, 0.464908], [0.471501, 0.47096, 0.466357], [0.474812, 0.473832, 0.467681], [0.478186, 0.476699, 0.468845], [0.481622, 0.479573, 0.469767], [0.485141, 0.482451, 0.470384], [0.488697, 0.485318, 0.471008], [0.492278, 0.488198, 0.471453], [0.495913, 0.491076, 0.471751], [0.499552, 0.49396, 0.472032], [0.503185, 0.496851, 0.472305], [0.506866, 0.499743, 0.472432], [0.51054, 0.502643, 0.47255], [0.514226, 0.505546, 0.47264], [0.51792, 0.508454, 0.472707], [0.521643, 0.511367, 0.472639], [0.525348, 0.514285, 0.47266], [0.529086, 0.517207, 0.472543], [0.532829, 0.520135, 0.472401], [0.536553, 0.523067, 0.472352], [0.540307, 0.526005, 0.472163], [0.544069, 0.528948, 0.471947], [0.54784, 0.531895, 0.471704], [0.551612, 0.534849, 0.471439], [0.555393, 0.537807, 0.471147], [0.559181, 0.540771, 0.470829], [0.562972, 0.543741, 0.470488], [0.566802, 0.546715, 0.469988], [0.570607, 0.549695, 0.469593], [0.574417, 0.552682, 0.469172], [0.578236, 0.555673, 0.468724], [0.582087, 0.55867, 0.468118], [0.585916, 0.561674, 0.467618], [0.589753, 0.564682, 0.46709], [0.593622, 0.567697, 0.466401], [0.597469, 0.570718, 0.465821], [0.601354, 0.573743, 0.465074], [0.605211, 0.576777, 0.464441], [0.609105, 0.579816, 0.463638], [0.612977, 0.582861, 0.46295], [0.616852, 0.585913, 0.462237], [0.620765, 0.58897, 0.461351], [0.624654, 0.592034, 0.460583], [0.628576, 0.595104, 0.459641], [0.632506, 0.59818, 0.458668], [0.636412, 0.601264, 0.457818], [0.640352, 0.604354, 0.456791], [0.64427, 0.60745, 0.455886], [0.648222, 0.610553, 0.454801], [0.652178, 0.613664, 0.453689], [0.656114, 0.61678, 0.452702], [0.660082, 0.619904, 0.451534], [0.664055, 0.623034, 0.450338], [0.668008, 0.626171, 0.44927], [0.671991, 0.629316, 0.448018], [0.675981, 0.632468, 0.446736], [0.679979, 0.635626, 0.445424], [0.68395, 0.638793, 0.444251], [0.687957, 0.641966, 0.442886], [0.691971, 0.645145, 0.441491], [0.695985, 0.648334, 0.440072], [0.700008, 0.651529, 0.438624], [0.704037, 0.654731, 0.437147], [0.708067, 0.657942, 0.435647], [0.712105, 0.66116, 0.434117], [0.716177, 0.664384, 0.432386], [0.720222, 0.667618, 0.430805], [0.724274, 0.670859, 0.429194], [0.728334, 0.674107, 0.427554], [0.732422, 0.677364, 0.425717], [0.736488, 0.680629, 0.424028], [0.740589, 0.6839, 0.422131], [0.744664, 0.687181, 0.420393], [0.748772, 0.69047, 0.418448], [0.752886, 0.693766, 0.416472], [0.756975, 0.697071, 0.414659], [0.761096, 0.700384, 0.412638], [0.765223, 0.703705, 0.410587], [0.769353, 0.707035, 0.408516], [0.773486, 0.710373, 0.406422], [0.777651, 0.713719, 0.404112], [0.781795, 0.717074, 0.401966], [0.785965, 0.720438, 0.399613], [0.790116, 0.72381, 0.397423], [0.794298, 0.72719, 0.395016], [0.79848, 0.73058, 0.392597], [0.802667, 0.733978, 0.390153], [0.806859, 0.737385, 0.387684], [0.811054, 0.740801, 0.385198], [0.815274, 0.744226, 0.382504], [0.819499, 0.747659, 0.379785], [0.823729, 0.751101, 0.377043], [0.827959, 0.754553, 0.374292], [0.832192, 0.758014, 0.371529], [0.836429, 0.761483, 0.368747], [0.840693, 0.764962, 0.365746], [0.844957, 0.76845, 0.362741], [0.849223, 0.771947, 0.359729], [0.853515, 0.775454, 0.3565], [0.857809, 0.778969, 0.353259], [0.862105, 0.782494, 0.350011], [0.866421, 0.786028, 0.346571], [0.870717, 0.789572, 0.343333], [0.875057, 0.793125, 0.339685], [0.879378, 0.796687, 0.336241], [0.88372, 0.800258, 0.332599], [0.888081, 0.803839, 0.32877], [0.89244, 0.80743, 0.324968], [0.896818, 0.81103, 0.320982], [0.901195, 0.814639, 0.317021], [0.905589, 0.818257, 0.312889], [0.91, 0.821885, 0.308594], [0.914407, 0.825522, 0.304348], [0.918828, 0.829168, 0.29996], [0.923279, 0.832822, 0.295244], [0.927724, 0.836486, 0.290611], [0.93218, 0.840159, 0.28588], [0.93666, 0.843841, 0.280876], [0.941147, 0.84753, 0.275815], [0.945654, 0.851228, 0.270532], [0.950178, 0.854933, 0.265085], [0.954725, 0.858646, 0.259365], [0.959284, 0.862365, 0.253563], [0.963872, 0.866089, 0.247445], [0.968469, 0.869819, 0.24131], [0.973114, 0.87355, 0.234677], [0.97778, 0.877281, 0.227954], [0.982497, 0.881008, 0.220878], [0.987293, 0.884718, 0.213336], [0.992218, 0.888385, 0.205468], [0.994847, 0.892954, 0.203445], [0.995249, 0.898384, 0.207561], [0.995503, 0.903866, 0.21237], [0.995737, 0.909344, 0.217772]]
_twilight_data = [[0.8857501584075443, 0.8500092494306783, 0.8879736506427196], [0.8837852019553906, 0.8507294054031063, 0.8872322209694989], [0.8817223105928579, 0.8512759407765347, 0.8863805692551482], [0.8795410528270573, 0.8516567540749572, 0.8854143767924102], [0.8772488085896548, 0.8518702833887027, 0.8843412038131143], [0.8748534750857597, 0.8519152612302319, 0.8831692696761383], [0.8723313408512408, 0.8518016547808089, 0.8818970435500162], [0.8697047485350982, 0.8515240300479789, 0.8805388339000336], [0.8669601550533358, 0.8510896085314068, 0.8790976697717334], [0.86408985081464, 0.8505039116750779, 0.8775792578489263], [0.8611024543689985, 0.8497675485700126, 0.8759924292343957], [0.8579825924567037, 0.8488893481028184, 0.8743403855344628], [0.8547259318925698, 0.8478748812467282, 0.8726282980930582], [0.8513371457085719, 0.8467273579611647, 0.8708608165735044], [0.8478071070257792, 0.8454546229209523, 0.8690403678369444], [0.8441261828674842, 0.8440648271103739, 0.8671697332269007], [0.8403042080595778, 0.8425605950855084, 0.865250882410458], [0.8363403180919118, 0.8409479651895194, 0.8632852800107016], [0.8322270571293441, 0.8392349062775448, 0.8612756350042788], [0.8279689431601354, 0.837426007513952, 0.8592239945130679], [0.8235742968025285, 0.8355248776479544, 0.8571319132851495], [0.8190465467793753, 0.8335364929949034, 0.855002062870101], [0.8143898212114309, 0.8314655869419785, 0.8528375906214702], [0.8095999819094809, 0.8293189667350546, 0.8506444160105037], [0.8046916442981458, 0.8270983878056066, 0.8484244929697402], [0.79967075421268, 0.8248078181208093, 0.8461821002957853], [0.7945430508923111, 0.8224511622630462, 0.8439218478682798], [0.7893144556460892, 0.8200321318870201, 0.8416486380471222], [0.7839910104276492, 0.8175542640053343, 0.8393674746403673], [0.7785789200822759, 0.8150208937874255, 0.8370834463093898], [0.7730841659017094, 0.8124352473546601, 0.8348017295057968], [0.7675110850441786, 0.8098007598713145, 0.8325281663805967], [0.7618690793798029, 0.8071194938764749, 0.830266486168872], [0.7561644358438198, 0.8043940873347794, 0.8280213899472], [0.750403467654067, 0.8016269900896532, 0.8257973785108242], [0.7445924777189017, 0.7988204771958325, 0.8235986758615652], [0.7387377170049494, 0.7959766573503101, 0.8214292278043301], [0.7328454364552346, 0.7930974646884407, 0.8192926338423038], [0.726921775128297, 0.7901846863592763, 0.8171921746672638], [0.7209728066553678, 0.7872399592345264, 0.8151307392087926], [0.7150040307625213, 0.7842648709158119, 0.8131111655994991], [0.709020781345393, 0.7812608871607091, 0.8111359185511793], [0.7030297722540817, 0.7782290497335813, 0.8092061884805697], [0.6970365443886174, 0.7751705000806606, 0.8073233538006345], [0.691046410093091, 0.7720862946067809, 0.8054884169067907], [0.6850644615439593, 0.7689774029354699, 0.8037020626717691], [0.6790955449988215, 0.765844721313959, 0.8019646617300199], [0.6731442255942621, 0.7626890873389048, 0.8002762854580953], [0.6672147980375281, 0.7595112803730375, 0.7986367465453776], [0.6613112930078745, 0.7563120270871903, 0.7970456043491897], [0.6554369232645472, 0.7530920875676843, 0.7955027112903105], [0.6495957300425348, 0.7498520122194177, 0.7940067402149911], [0.6437910831099849, 0.7465923800833657, 0.7925565320130605], [0.6380258682854598, 0.7433137671403319, 0.7911510045957317], [0.6323027138710603, 0.740016721601314, 0.7897889276264043], [0.6266240202260459, 0.7367017540369944, 0.7884690131633456], [0.6209919306481755, 0.733369347989232, 0.7871899462469658], [0.6154084641177048, 0.7300199523273969, 0.7859502270675048], [0.6098754317609306, 0.7266539875975829, 0.7847483573269471], [0.6043943420027486, 0.7232718614323369, 0.7835829559353559], [0.5989665814482068, 0.7198739489224673, 0.7824525989934664], [0.5935933569683722, 0.7164606049658685, 0.781355882376401], [0.588275797805555, 0.7130321464645814, 0.7802914140563652], [0.5830148703693241, 0.7095888767699747, 0.7792578182047659], [0.5778116438998202, 0.7061310615715398, 0.7782534512102552], [0.5726668948158774, 0.7026589535425779, 0.7772770268091199], [0.5675811785386197, 0.6991727930264627, 0.776327485342753], [0.5625551535721934, 0.6956727838162965, 0.7754035914230984], [0.5575894041960517, 0.6921591145825405, 0.7745041337932782], [0.5526845058934713, 0.6886319451516638, 0.7736279426902245], [0.5478409815301863, 0.6850914221850988, 0.7727738647344087], [0.5430593242401823, 0.6815376725306588, 0.7719407969783508], [0.5383401557517628, 0.677970811290954, 0.7711273443905772], [0.533683891477284, 0.6743909370521273, 0.7703325054879735], [0.529090861832473, 0.6707981230280622, 0.7695555229231313], [0.5245615147059358, 0.6671924299614223, 0.7687954171423095], [0.5200962739223556, 0.6635739143403039, 0.768051194033441], [0.5156955988596057, 0.65994260812898, 0.7673219148959617], [0.5113599254160193, 0.6562985398183186, 0.7666066378064533], [0.5070896957645166, 0.6526417240314645, 0.7659044566083585], [0.5028853540415561, 0.6489721673409526, 0.7652144671817491], [0.4987473366135607, 0.6452898684900934, 0.7645357873418008], [0.4946761847863938, 0.6415948411950443, 0.7638671900213091], [0.4906722493856122, 0.6378870485884708, 0.7632081276316384], [0.4867359599430568, 0.6341664625110051, 0.7625578008592404], [0.4828677867260272, 0.6304330455306234, 0.761915371498953], [0.47906816236197386, 0.6266867625186013, 0.7612800037566242], [0.47533752394906287, 0.6229275728383581, 0.7606508557181775], [0.4716762951887709, 0.6191554324288464, 0.7600270922788305], [0.46808490970531597, 0.6153702869579029, 0.7594078989109274], [0.4645637671630393, 0.6115720882286415, 0.7587924262302581], [0.4611132664702388, 0.607760777169989, 0.7581798643680714], [0.45773377230160567, 0.6039363004658646, 0.7575693690185916], [0.45442563977552913, 0.6000985950385866, 0.7569601366060649], [0.45118918687617743, 0.5962476205135354, 0.7563512064324664], [0.4480247093358917, 0.5923833145214658, 0.7557417647410792], [0.4449324685421538, 0.5885055998308617, 0.7551311041857901], [0.441912717666964, 0.5846144110017557, 0.7545183888441067], [0.43896563958048396, 0.5807096924109849, 0.7539027620828594], [0.4360913895835637, 0.5767913799818608, 0.7532834105961016], [0.43329008867358393, 0.5728594162560667, 0.7526594653256667], [0.4305617907305757, 0.5689137457245718, 0.752030080993127], [0.42790652284925834, 0.5649543060909209, 0.7513944352191484], [0.42532423665011354, 0.560981049599503, 0.7507516498900512], [0.4228148567577266, 0.5569939212699658, 0.7501008698822764], [0.42037822361396326, 0.5529928715810817, 0.7494412559451894], [0.4180141407923363, 0.5489778542188889, 0.7487719316700112], [0.4157223260454232, 0.544948827153504, 0.7480920445900052], [0.4135024574331473, 0.5409057477109848, 0.7474007329754309], [0.4113541469730457, 0.5368485776500593, 0.7466971285506578], [0.4092768899914751, 0.5327773017713032, 0.7459803063570782], [0.4072701869421907, 0.5286918801105741, 0.7452494263758127], [0.4053334378930318, 0.5245922817498312, 0.7445036583670813], [0.40346600333905397, 0.5204784765384003, 0.7437421522356709], [0.40166714010896104, 0.5163504496968876, 0.7429640345324835], [0.39993606933454834, 0.5122081814321852, 0.7421684457131799], [0.3982719152586337, 0.5080516653927614, 0.7413545091809972], [0.3966737490566561, 0.5038808905384797, 0.7405213858051674], [0.3951405880820763, 0.4996958532637776, 0.7396682021171571], [0.39367135736822567, 0.4954965577745118, 0.738794102296364], [0.39226494876209317, 0.4912830033289926, 0.7378982478447508], [0.390920175719949, 0.4870552025122304, 0.7369797713388125], [0.38963580160340855, 0.48281316715123496, 0.7360378254693274], [0.3884105330084243, 0.47855691131792805, 0.7350715764115726], [0.3872430145933025, 0.4742864593363539, 0.7340801678785439], [0.386131841788921, 0.4700018340988123, 0.7330627749243106], [0.3850755679365139, 0.46570306719930193, 0.732018540336905], [0.38407269378943537, 0.46139018782416635, 0.7309466543290268], [0.3831216808440275, 0.457063235814072, 0.7298462679135326], [0.38222094988570376, 0.45272225034283325, 0.7287165614400378], [0.3813688793045416, 0.4483672766927786, 0.7275567131714135], [0.3805638069656562, 0.4439983720863372, 0.7263658704513531], [0.3798040374484875, 0.4396155882122263, 0.7251432377876109], [0.3790878928311076, 0.43521897612544935, 0.7238879869132313], [0.378413635091359, 0.43080859411413064, 0.7225993199306104], [0.3777794975351373, 0.4263845142616835, 0.7212763999353023], [0.3771837184425123, 0.4219468022345483, 0.7199184152447577], [0.37662448930806297, 0.41749553747893614, 0.7185245473617611], [0.37610001286385814, 0.4130307995247706, 0.7170939691992023], [0.375608469194424, 0.40855267638072096, 0.7156258509158755], [0.37514802505380473, 0.4040612609993941, 0.7141193695725726], [0.3747168601930223, 0.3995566498711684, 0.7125736851650046], [0.3743131319931234, 0.3950389482828331, 0.7109879652237746], [0.3739349933047578, 0.3905082752937583, 0.7093613429347845], [0.3735806215098284, 0.3859647438605754, 0.7076929760731058], [0.37324816143326384, 0.38140848555753937, 0.7059820097480604], [0.3729357864666503, 0.3768396383521984, 0.7042275578058994], [0.37264166757849604, 0.3722583500483685, 0.7024287314570723], [0.37236397858465387, 0.36766477862108266, 0.7005846349652077], [0.3721008970244382, 0.3630590973698238, 0.6986943461507372], [0.3718506155898596, 0.3584414828587522, 0.6967569581025654], [0.3716113323440048, 0.3538121372967869, 0.6947714991938089], [0.37138124223736607, 0.34917126878479027, 0.6927370347192883], [0.37115856636209105, 0.3445191141023017, 0.6906525358646499], [0.3709415155133733, 0.33985591488818123, 0.6885170337950512], [0.3707283327942267, 0.33518193808489577, 0.6863294816960677], [0.37051738634484427, 0.3304974124430785, 0.6840888878885721], [0.37030682071842685, 0.32580269697872455, 0.6817941168448668], [0.37009487130772695, 0.3210981375964933, 0.6794440539905685], [0.3698798032902536, 0.31638410101153364, 0.6770375543809057], [0.36965987626565955, 0.3116609876295197, 0.6745734474341955], [0.3694333459127623, 0.3069292355186234, 0.6720505284912062], [0.36919847837592484, 0.3021893217650707, 0.6694675433161452], [0.3689535530659678, 0.29744175492366276, 0.6668232208982426], [0.3686968223189527, 0.292687098561501, 0.6641162529823691], [0.36842655638020444, 0.2879259643777846, 0.661345269109446], [0.3681410147989972, 0.2831590122118299, 0.6585088880697231], [0.3678384369653108, 0.2783869718129776, 0.655605668384537], [0.36751707094367697, 0.2736106331709098, 0.6526341171161864], [0.36717513650699446, 0.26883085667326956, 0.6495927229789225], [0.3668108554010799, 0.26404857724525643, 0.6464799165290824], [0.3664224325155063, 0.25926481158628106, 0.6432940914076554], [0.36600853966739794, 0.25448043878086224, 0.6400336180336859], [0.3655669837353898, 0.24969683475296395, 0.6366967518748858], [0.3650957984588681, 0.24491536803550484, 0.6332817352005559], [0.3645930889012501, 0.24013747024823828, 0.629786801550261], [0.3640569302208851, 0.23536470386204195, 0.6262101345195302], [0.36348537610385145, 0.2305987621839642, 0.6225498862239288], [0.3628764356004103, 0.2258414929328703, 0.6188041741082302], [0.36222809558295926, 0.22109488427338303, 0.6149711234609613], [0.36153829010998356, 0.21636111429594002, 0.6110488067964093], [0.36080493826624654, 0.21164251793458128, 0.6070353217206471], [0.36002681809096376, 0.20694122817889948, 0.6029284543191687], [0.35920088560930186, 0.20226037920758122, 0.5987265295935138], [0.3583248996661781, 0.197602942459778, 0.5944276851750107], [0.35739663292915563, 0.1929720819784246, 0.5900301125106313], [0.35641381143126327, 0.18837119869242164, 0.5855320765920552], [0.3553741530690672, 0.18380392577704466, 0.580931914318328], [0.3542753496066376, 0.17927413271618647, 0.5762280966066872], [0.35311574421123737, 0.17478570377561287, 0.5714187152355529], [0.3518924860887379, 0.17034320478524959, 0.5665028491121665], [0.3506030444193101, 0.1659512998472086, 0.5614796470399323], [0.34924513554955644, 0.16161477763045118, 0.5563483747416378], [0.3478165323877778, 0.1573386351115298, 0.5511085345270326], [0.3463150717579309, 0.15312802296627787, 0.5457599924248665], [0.34473901574536375, 0.1489882058982641, 0.5403024592040654], [0.34308600291572294, 0.14492465359918028, 0.534737042820671], [0.34135411074506483, 0.1409427920655632, 0.5290650094033675], [0.33954168752669694, 0.1370480189671817, 0.5232879753508524], [0.3376473209067111, 0.13324562282438077, 0.5174080757397947], [0.33566978565015315, 0.12954074251271822, 0.5114280721516895], [0.33360804901486, 0.1259381830100592, 0.505351647966549], [0.33146154891145124, 0.12244245263391232, 0.4991827458843107], [0.3292300520323141, 0.11905764321981127, 0.49292595612342666], [0.3269137124539796, 0.1157873496841953, 0.4865864649569746], [0.32451307931207785, 0.11263459791730848, 0.48017007211645196], [0.3220288227606932, 0.10960114111258401, 0.4736849472572688], [0.31946262395497965, 0.1066887988239266, 0.46713728801395243], [0.316816480890235, 0.10389861387653518, 0.46053414662739794], [0.3140927841475553, 0.10123077676403242, 0.45388335612058467], [0.31129434479712365, 0.0986847719340522, 0.4471931371516162], [0.30842444457210105, 0.09625938534057774, 0.44047194882050544], [0.30548675819945936, 0.09395276484082374, 0.4337284999936111], [0.3024853636457425, 0.0917611873973036, 0.42697404043749887], [0.2994248396021477, 0.08968225371675004, 0.42021619665853854], [0.2963100038890529, 0.08771325096046395, 0.41346259134143476], [0.2931459309698525, 0.08585065688962071, 0.40672178082365834], [0.2899379244517661, 0.08409078829085731, 0.40000214725256295], [0.28669151388283165, 0.08242987384848069, 0.39331182532243375], [0.28341239797185225, 0.08086415336549937, 0.38665868550105914], [0.2801063857697547, 0.07938999480226153, 0.38005028528138707], [0.2767793961581559, 0.07800394103378822, 0.37349382846504675], [0.2734373934245081, 0.07670280023749607, 0.36699616136347685], [0.2700863774911405, 0.07548367558427554, 0.36056376228111864], [0.26673233211995284, 0.0743440180285462, 0.3542027606624096], [0.26338121807151404, 0.07328165793989708, 0.34791888996380105], [0.26003895187439957, 0.0722947810433622, 0.3417175669546984], [0.256711916510839, 0.07138010624208224, 0.3356064898460009], [0.25340685873736807, 0.07053358292685183, 0.3295945757321303], [0.2501284530619938, 0.06975820642910699, 0.32368100685760637], [0.24688226237959, 0.06905363944920445, 0.31786993834254956], [0.24367372557466271, 0.06841985515092269, 0.3121652405088837], [0.2405081333229594, 0.0678571038148556, 0.3065705449367832], [0.23739062429054825, 0.06736588805055552, 0.3010892218406587], [0.23433055727563878, 0.0669355996616394, 0.295740099298676], [0.23132955273021344, 0.06657618693909059, 0.29051361067988485], [0.2283917709422868, 0.06628997924139618, 0.28541074411068496], [0.22552164337737857, 0.0660781731193956, 0.28043398847505197], [0.22272706739121817, 0.06593379067565194, 0.275597146520537], [0.22001251100779617, 0.0658579189189076, 0.2709027999432586], [0.21737845072382705, 0.06585966123356204, 0.2663420934966951], [0.21482843531473683, 0.06594038561377849, 0.26191675992376573], [0.21237411048541005, 0.06608502466175845, 0.2576516509356954], [0.21001214221188125, 0.06630857391894718, 0.2535289048041211], [0.2077442377448806, 0.06661453200418091, 0.24954644291943817], [0.20558051999470117, 0.06699046239786874, 0.24572497420147632], [0.20352007949514977, 0.06744417961242422, 0.24205576625191821], [0.2015613376412984, 0.06798327102620025, 0.23852974228695395], [0.19971571438603364, 0.06859271055370472, 0.23517094067076993], [0.19794834061899208, 0.06931406607166066, 0.23194647381302336], [0.1960826032659409, 0.07032122724242362, 0.22874673279569585], [0.19410351363791453, 0.07160830485689157, 0.22558727307410353], [0.19199449184606268, 0.0731828306492733, 0.22243385243433622], [0.18975853639094634, 0.07501986186214377, 0.2193005075652994], [0.18739228342697645, 0.07710209689958833, 0.21618875376309582], [0.18488035509396164, 0.07942573027972388, 0.21307651648984993], [0.18774482037046955, 0.07725158846803931, 0.21387448578597812], [0.19049578401722037, 0.07531127841678764, 0.2146562337112265], [0.1931548636579131, 0.07360681904011795, 0.21542362939081539], [0.19571853588267552, 0.07215778103960274, 0.21617499187076789], [0.19819343656336558, 0.07097462525273879, 0.21690975060032436], [0.20058760685133747, 0.07006457614998421, 0.21762721310371608], [0.20290365333558247, 0.06943524858045896, 0.21833167885096033], [0.20531725273301316, 0.06891959226639757, 0.21911516689288835], [0.20785704662965598, 0.06848439879702528, 0.22000133917653536], [0.21052882914958676, 0.06812195249816172, 0.22098759107715404], [0.2133313859647627, 0.06783014842602667, 0.2220704321302429], [0.21625279838647882, 0.06761633027051639, 0.22324568672294431], [0.21930503925136402, 0.06746578636294004, 0.22451023616807558], [0.22247308588973624, 0.06738821405309284, 0.22585960379408354], [0.2257539681670791, 0.06738213230014747, 0.22728984778098055], [0.2291562027859284, 0.06743473087115257, 0.22879681433956656], [0.23266299920501882, 0.06755710438847978, 0.23037617493752832], [0.23627495835774248, 0.06774359820987802, 0.23202360805926608], [0.23999586188690308, 0.06798502996477995, 0.23373434258507808], [0.2438114972024792, 0.06828985152901187, 0.23550427698321885], [0.247720929905011, 0.06865333790948652, 0.2373288009471749], [0.25172899728289466, 0.0690646308260355, 0.23920260612763083], [0.2558213554748177, 0.06953231029187984, 0.24112190491594204], [0.25999463887892144, 0.07005385560386188, 0.24308218808684579], [0.2642551220706094, 0.07061659562299544, 0.24507758869355967], [0.2685909594817286, 0.07122671627792246, 0.24710443563450618], [0.272997015188973, 0.07188355544616351, 0.2491584709323293], [0.277471508091428, 0.07258296989925478, 0.2512349399594277], [0.2820174629736694, 0.07331569321404097, 0.25332800295084507], [0.28662309235899847, 0.07408846082680887, 0.2554347867371703], [0.29128515387578635, 0.0748990498474667, 0.25755101595750435], [0.2960004726065818, 0.07574533600095842, 0.25967245030364566], [0.3007727681291869, 0.07661782433616476, 0.2617929409781967], [0.30559226007249934, 0.07752196310753731, 0.2639100669211966], [0.31045520848595526, 0.07845687167618218, 0.2660200572779356], [0.3153587000920581, 0.07942099731524319, 0.2681190407694196], [0.3202998655799406, 0.08041299473755484, 0.2702032289303951], [0.3252788886040126, 0.08142839007654609, 0.27226772884656186], [0.3302917447118144, 0.08246763389003825, 0.27430929404579435], [0.3353335322445545, 0.08353243411900396, 0.2763253435679004], [0.34040164359597463, 0.08462223619170267, 0.27831254595259397], [0.345493557138718, 0.08573665496512634, 0.28026769921081435], [0.3506067824603248, 0.08687555176033529, 0.28218770540182386], [0.35573889947341125, 0.08803897435024335, 0.2840695897279818], [0.36088752387578377, 0.0892271943627452, 0.28591050458531014], [0.36605031412464006, 0.0904406854276979, 0.2877077458811747], [0.3712250843130934, 0.09167999748026273, 0.2894586539763317], [0.3764103053221462, 0.09294519809377791, 0.2911602415731392], [0.38160247377467543, 0.09423873126371218, 0.2928110750626949], [0.3867993907954417, 0.09556181960083443, 0.29440901248173756], [0.39199887556812907, 0.09691583650296684, 0.2959521200550908], [0.39719876876325577, 0.09830232096827862, 0.2974385647628578], [0.40239692379737496, 0.09972293031495055, 0.2988667436973397], [0.4075912039268871, 0.10117945586419633, 0.300235195077286], [0.41277985630360303, 0.1026734006932461, 0.3015422643746897], [0.41796105205173684, 0.10420644885760968, 0.3027865203963184], [0.42313214269556043, 0.10578120994917611, 0.3039675809469457], [0.4282910131578975, 0.1073997763055258, 0.30508479060294547], [0.4334355841041439, 0.1090642347484701, 0.3061376792828915], [0.4385637818793154, 0.11077667828375456, 0.30712600062348083], [0.44367358645071275, 0.11253912421257944, 0.3080497309546545], [0.4487629917317482, 0.1143535557462255, 0.30890905921943196], [0.4538300508699989, 0.11622183788331528, 0.3097044124984492], [0.45887288947308297, 0.11814571137706886, 0.3104363697903881], [0.46389102840284874, 0.12012561256850712, 0.31110343446582983], [0.46888111384598413, 0.12216445576414045, 0.31170911458932665], [0.473841437035254, 0.12426354237989065, 0.31225470169927194], [0.47877034239726296, 0.12642401401409453, 0.3127417273582196], [0.48366628618847957, 0.1286467902201389, 0.31317188565991266], [0.48852847371852987, 0.13093210934893723, 0.31354553695453014], [0.49335504375145617, 0.13328091630401023, 0.31386561956734976], [0.4981443546207415, 0.13569380302451714, 0.314135190862664], [0.5028952497497061, 0.13817086581280427, 0.3143566215383367], [0.5076068118105369, 0.14071192654913128, 0.3145320012008257], [0.5122783510532176, 0.14331656120063752, 0.3146630922831542], [0.5169084880054446, 0.14598463068714407, 0.3147540759228004], [0.5214965286322996, 0.14871544765633712, 0.3148076795453443], [0.5260418962547748, 0.15150818660835483, 0.31482653406646727], [0.5305442048985645, 0.15436183633886777, 0.3148129978918713], [0.5350027976174474, 0.15727540775107324, 0.3147708520739653], [0.5394173664919906, 0.16024769309971934, 0.31470295028655965], [0.5437877131360856, 0.16327738551419116, 0.31461204226295625], [0.5481137003346762, 0.1663630904279047, 0.3145010299091471], [0.5523952157271191, 0.16950338809328983, 0.3143729155461537], [0.5566322903496934, 0.17269677158182117, 0.31423043195101424], [0.5608249903911717, 0.17594170887918095, 0.31407639883970623], [0.564973435290177, 0.17923664950367169, 0.3139136046337036], [0.5690778478401143, 0.18258004462335425, 0.3137444095679653], [0.5731384575410787, 0.18597036007065024, 0.3135712686852], [0.5771555081299204, 0.18940601489760422, 0.3133970433357208], [0.5811293276158656, 0.19288548904692518, 0.3132239939418394], [0.5850602439646688, 0.19640737049066315, 0.3130540116373273], [0.5889486193554471, 0.19997020971775276, 0.31288922211590126], [0.5927948053652026, 0.20357251410079796, 0.3127323483930494], [0.5965991810912237, 0.207212956082026, 0.3125852303112123], [0.6003621301041158, 0.21089030138947745, 0.3124493441041469], [0.6040840169673274, 0.21460331490206347, 0.31232652641170694], [0.6077652399481865, 0.21835070166659282, 0.312219032918702], [0.6114062072731884, 0.22213124697023234, 0.3121288139643524], [0.6150072323639137, 0.22594402043981826, 0.3120568068576574], [0.6185686525887719, 0.2297879924917992, 0.3120046383872893], [0.6220907982108261, 0.2336621873300741, 0.3119738327362739], [0.6255741650043496, 0.23756535071152696, 0.3119669831491227], [0.6290189201698587, 0.24149689191922535, 0.3119844719564572], [0.6324253485421027, 0.24545598775548677, 0.3120276597462445], [0.6357937104834237, 0.24944185818822678, 0.3120979395330059], [0.6391243387840212, 0.2534536546198314, 0.3121968961206398], [0.642417577481186, 0.257490519876798, 0.31232631707560987], [0.6456734938264543, 0.2615520316161528, 0.31248673753935263], [0.6488923016945825, 0.2656375533620908, 0.3126794181957019], [0.652074172902773, 0.269746505252367, 0.3129056060581917], [0.6552193260932713, 0.2738782665241015, 0.3131666792687211], [0.6583280801134499, 0.2780321095766563, 0.3134643447952643], [0.6614003753260178, 0.28220778870555907, 0.3137991292649849], [0.6644363246987884, 0.2864048361425618, 0.31417223403606975], [0.6674360376636913, 0.29062280081258873, 0.31458483752056837], [0.670399595476762, 0.29486126309253047, 0.3150381395687221], [0.6733272556481733, 0.29911962764489264, 0.3155337232398221], [0.6762189792440975, 0.30339762792450425, 0.3160724937230589], [0.6790747402815734, 0.30769497879760166, 0.31665545668946665], [0.6818945715094452, 0.31201133280550686, 0.3172838048924495], [0.6846785094249453, 0.3163463482122221, 0.31795870784057567], [0.6874265643516962, 0.32069970535138104, 0.3186813762227769], [0.6901389321505248, 0.32507091815606004, 0.319453323328983], [0.6928154484676493, 0.32945984647042675, 0.3202754315314667], [0.6954560834689112, 0.33386622163232865, 0.3211488430698579], [0.6980608153581771, 0.3382897632604862, 0.3220747885521809], [0.700629624772421, 0.34273019305341756, 0.32305449047765694], [0.7031624945881415, 0.34718723719598, 0.32408913679491225], [0.7056595112261009, 0.3516605297812094, 0.32518014084085567], [0.7081205956842048, 0.356149855233803, 0.32632861885644465], [0.7105456546582587, 0.36065500290840113, 0.3275357416278876], [0.7129346683977347, 0.36517570519856757, 0.3288027427038317], [0.7152876061484729, 0.3697117022522345, 0.3301308728723546], [0.7176044490813385, 0.3742627271068619, 0.3315213862095893], [0.7198852149054985, 0.37882848839337313, 0.332975552002454], [0.7221299918421461, 0.3834086450896306, 0.33449469983585844], [0.7243386564778159, 0.38800301593162145, 0.3360799596569183], [0.7265112290022755, 0.3926113126792577, 0.3377325942005665], [0.7286477385671655, 0.39723324476747235, 0.33945384341064017], [0.7307482075484517, 0.401868526884681, 0.3412449533046818], [0.7328127050626875, 0.4065168468778026, 0.3431071517341082], [0.7348413359856494, 0.4111778700451951, 0.3450416947080907], [0.7368342217358587, 0.4158512585029011, 0.347049785207584], [0.7387914002459927, 0.4205367299231533, 0.34913260148542435], [0.7407130161950609, 0.4252339389526239, 0.35129130890802607], [0.7425992159973317, 0.42994254036133867, 0.3535270924537459], [0.7444501867657067, 0.4346621718461711, 0.35584108091122535], [0.7462661578916344, 0.439392450449735, 0.3582343914230064], [0.7480473927555956, 0.44413297780351974, 0.36070813602540136], [0.7497942054717047, 0.4488833348154881, 0.3632633755836028], [0.7515068504589166, 0.45364314496866825, 0.36590112443835765], [0.7531856636904657, 0.45841199172949604, 0.3686223664223477], [0.7548310506695954, 0.46318942799460555, 0.3714280448394211], [0.7564434157714071, 0.4679750143794846, 0.37431909037543515], [0.7580232553845584, 0.4727682731566229, 0.3772963553109668], [0.7595711110534006, 0.4775687122205708, 0.380360657784311], [0.7610876378057071, 0.48237579130289127, 0.3835127572385229], [0.7625733355405261, 0.48718906673415824, 0.38675335037837993], [0.7640288560928866, 0.49200802533379656, 0.39008308392311997], [0.7654549259333051, 0.4968321290972723, 0.3935025400011538], [0.7668522895064389, 0.5016608471009063, 0.39701221751773474], [0.768221765997353, 0.5064936237128791, 0.40061257089416885], [0.7695642334401418, 0.5113298901696085, 0.4043039806968248], [0.7708809196230247, 0.516168926434691, 0.40808667584648967], [0.7721725722960555, 0.5210102658711383, 0.4119608998712287], [0.7734402182988989, 0.5258533209345156, 0.41592679539764366], [0.774684947460632, 0.5306974938477673, 0.4199844035696376], [0.775907907306857, 0.5355421788246119, 0.42413367909988375], [0.7771103295521099, 0.5403867491056124, 0.4283745037125848], [0.7782934580763312, 0.545230594884266, 0.432706647838971], [0.7794586273150664, 0.5500730841397727, 0.4371297985644476], [0.7806077474948377, 0.5549133574489061, 0.4416433242636464], [0.7817418047898184, 0.5597509805259486, 0.44624687186865436], [0.7828622526444091, 0.5645853311116688, 0.45093985823706345], [0.7839706083641448, 0.5694157832671042, 0.4557215474289206], [0.7850684501960684, 0.5742417003617839, 0.46059116206904965], [0.7861573713233296, 0.5790624629815756, 0.465547782819184], [0.7872390410818835, 0.5838774374455721, 0.47059039582133383], [0.7883151404562396, 0.5886860017356244, 0.4757179187907608], [0.7893873776625194, 0.5934875421745599, 0.48092913815357724], [0.7904577684772788, 0.5982813427706246, 0.48622257801969754], [0.7915283284347561, 0.603066705931472, 0.49159667021646397], [0.7926003430423745, 0.6078432208703702, 0.4970502062153201], [0.7936755969866496, 0.6126102933407219, 0.5025816129126943], [0.7947558597265404, 0.617367344002207, 0.5081892121310299], [0.7958429237958377, 0.6221137880845115, 0.5138712409190979], [0.7969385471995161, 0.626849056792967, 0.5196258425240281], [0.7980444781513664, 0.6315725822508955, 0.5254510814483478], [0.7991624518501963, 0.6362837937202919, 0.5313449594256143], [0.8002941538975398, 0.6409821330674986, 0.5373053518514104], [0.8014412429256005, 0.6456670345921877, 0.5433300863249918], [0.8026053114611295, 0.6503379374810385, 0.5494169158460365], [0.8037879253107763, 0.6549942654947263, 0.5555635086708381], [0.804990547908103, 0.6596354502756416, 0.5617674511054698], [0.8062146052692706, 0.6642608958528229, 0.5680262917864979], [0.8074614045096935, 0.6688700095398864, 0.5743374637345958], [0.8087321917008969, 0.6734621670219452, 0.5806983480557674], [0.8100280946652069, 0.6780367267397182, 0.5871062690808275], [0.8113501401176333, 0.6825930154624339, 0.5935584890905076], [0.8126992203988149, 0.6871303371461888, 0.600052148204351], [0.8140761104699334, 0.6916479479148213, 0.6065843782630862], [0.8154814662727948, 0.6961450550830809, 0.6131522120932265], [0.8169157577505589, 0.7006208301478398, 0.6197526063725792], [0.8183793116449822, 0.705074381896351, 0.626382454789333], [0.8198723065045529, 0.7095047497878748, 0.6330385704006711], [0.8213947205565636, 0.7139109141951604, 0.6397176669767276], [0.8229463511042843, 0.7182917733129006, 0.6464164243818421], [0.8245268129450285, 0.7226461431208888, 0.653131379154226], [0.8261354971058026, 0.7269727551823826, 0.659859001562165], [0.8277716072353446, 0.7312702332407809, 0.6665957020468297], [0.8294340781648147, 0.7355371221572935, 0.6733377200930191], [0.8311216352909631, 0.7397718464763862, 0.6800812520363146], [0.8328327718577798, 0.7439727181745988, 0.6868223587464855], [0.8345656905566583, 0.7481379479992134, 0.6935569764986385], [0.8363189884473793, 0.7522654895287526, 0.7002799902886496], [0.8380912347613196, 0.7563531486080863, 0.7069856139021298], [0.8398783988412087, 0.7603990719977968, 0.7136714781112923], [0.8416775076684515, 0.7644010120098295, 0.7203329938728462], [0.843485292229337, 0.7683566039987018, 0.7269653699897204], [0.8452981073195511, 0.7722633860104472, 0.7335636824054149], [0.847111955079651, 0.7761188023604716, 0.7401227576280706], [0.8489224556311764, 0.7799202140765015, 0.7466371929366437], [0.8507269702317879, 0.7836645734238389, 0.7530974636118285], [0.8525190720770844, 0.7873493613354844, 0.7594994148789691], [0.8542921961147046, 0.7909719677709199, 0.765838014779141], [0.856040223147254, 0.7945296360155061, 0.7721061003767414], [0.857756629435049, 0.7980196314271393, 0.778295716672475], [0.8594346370300241, 0.8014392309950078, 0.7843978875138392], [0.8610711702756552, 0.8047851790981223, 0.7903952966373629], [0.8626560105112757, 0.8080552380426153, 0.796282666437655], [0.8641834372394103, 0.8112464422465354, 0.8020461269686395], [0.8656493432560532, 0.8143554406751491, 0.8076697232416455], [0.867053149070485, 0.8173780404191124, 0.813134196269114], [0.8683995469581863, 0.8203087551218152, 0.8184163896312899], [0.8696913150261381, 0.8231415885956916, 0.8235047668317317], [0.8709384671729751, 0.8258685788943851, 0.8283849726114961], [0.8721533197845432, 0.8284805282370967, 0.8330486712880828], [0.8733517136091627, 0.8309671525127262, 0.8374885100119709], [0.8745379332026019, 0.8333197294864546, 0.8417192535806901], [0.875714587099614, 0.8355302318472394, 0.8457553751902708], [0.8768784845161469, 0.8375923807118654, 0.8496137354915025], [0.8780229843664901, 0.8395016561854007, 0.8533064535245892], [0.8791324424079277, 0.8412555488447591, 0.8568557229103964], [0.8801929331569581, 0.8428522482477862, 0.8602739992715663], [0.8811916987134195, 0.8442906671771735, 0.8635659516866988], [0.8821154248940161, 0.8455700725455935, 0.8667376504623333], [0.8829516859544853, 0.8466897027569927, 0.8697961704819097], [0.8836912714589804, 0.8476489176151927, 0.8727414710144156], [0.8843271305411354, 0.8484474157205542, 0.8755678522824297], [0.8848513815990857, 0.849084264228938, 0.8782823528537247], [0.8852589797263047, 0.8495589281098921, 0.8808841479402484], [0.8855471481195238, 0.8498717428363158, 0.8833620612117095], [0.8857115512284565, 0.8500218611585632, 0.8857253899008712]]
_twilight_shifted_data = _twilight_data[len(_twilight_data) // 2:] + _twilight_data[:len(_twilight_data) // 2]
_twilight_shifted_data.reverse()
_turbo_data = [[0.18995, 0.07176, 0.23217], [0.19483, 0.08339, 0.26149], [0.19956, 0.09498, 0.29024], [0.20415, 0.10652, 0.31844], [0.2086, 0.11802, 0.34607], [0.21291, 0.12947, 0.37314], [0.21708, 0.14087, 0.39964], [0.22111, 0.15223, 0.42558], [0.225, 0.16354, 0.45096], [0.22875, 0.17481, 0.47578], [0.23236, 0.18603, 0.50004], [0.23582, 0.1972, 0.52373], [0.23915, 0.20833, 0.54686], [0.24234, 0.21941, 0.56942], [0.24539, 0.23044, 0.59142], [0.2483, 0.24143, 0.61286], [0.25107, 0.25237, 0.63374], [0.25369, 0.26327, 0.65406], [0.25618, 0.27412, 0.67381], [0.25853, 0.28492, 0.693], [0.26074, 0.29568, 0.71162], [0.2628, 0.30639, 0.72968], [0.26473, 0.31706, 0.74718], [0.26652, 0.32768, 0.76412], [0.26816, 0.33825, 0.7805], [0.26967, 0.34878, 0.79631], [0.27103, 0.35926, 0.81156], [0.27226, 0.3697, 0.82624], [0.27334, 0.38008, 0.84037], [0.27429, 0.39043, 0.85393], [0.27509, 0.40072, 0.86692], [0.27576, 0.41097, 0.87936], [0.27628, 0.42118, 0.89123], [0.27667, 0.43134, 0.90254], [0.27691, 0.44145, 0.91328], [0.27701, 0.45152, 0.92347], [0.27698, 0.46153, 0.93309], [0.2768, 0.47151, 0.94214], [0.27648, 0.48144, 0.95064], [0.27603, 0.49132, 0.95857], [0.27543, 0.50115, 0.96594], [0.27469, 0.51094, 0.97275], [0.27381, 0.52069, 0.97899], [0.27273, 0.5304, 0.98461], [0.27106, 0.54015, 0.9893], [0.26878, 0.54995, 0.99303], [0.26592, 0.55979, 0.99583], [0.26252, 0.56967, 0.99773], [0.25862, 0.57958, 0.99876], [0.25425, 0.5895, 0.99896], [0.24946, 0.59943, 0.99835], [0.24427, 0.60937, 0.99697], [0.23874, 0.61931, 0.99485], [0.23288, 0.62923, 0.99202], [0.22676, 0.63913, 0.98851], [0.22039, 0.64901, 0.98436], [0.21382, 0.65886, 0.97959], [0.20708, 0.66866, 0.97423], [0.20021, 0.67842, 0.96833], [0.19326, 0.68812, 0.9619], [0.18625, 0.69775, 0.95498], [0.17923, 0.70732, 0.94761], [0.17223, 0.7168, 0.93981], [0.16529, 0.7262, 0.93161], [0.15844, 0.73551, 0.92305], [0.15173, 0.74472, 0.91416], [0.14519, 0.75381, 0.90496], [0.13886, 0.76279, 0.8955], [0.13278, 0.77165, 0.8858], [0.12698, 0.78037, 0.8759], [0.12151, 0.78896, 0.86581], [0.11639, 0.7974, 0.85559], [0.11167, 0.80569, 0.84525], [0.10738, 0.81381, 0.83484], [0.10357, 0.82177, 0.82437], [0.10026, 0.82955, 0.81389], [0.0975, 0.83714, 0.80342], [0.09532, 0.84455, 0.79299], [0.09377, 0.85175, 0.78264], [0.09287, 0.85875, 0.7724], [0.09267, 0.86554, 0.7623], [0.0932, 0.87211, 0.75237], [0.09451, 0.87844, 0.74265], [0.09662, 0.88454, 0.73316], [0.09958, 0.8904, 0.72393], [0.10342, 0.896, 0.715], [0.10815, 0.90142, 0.70599], [0.11374, 0.90673, 0.69651], [0.12014, 0.91193, 0.6866], [0.12733, 0.91701, 0.67627], [0.13526, 0.92197, 0.66556], [0.14391, 0.9268, 0.65448], [0.15323, 0.93151, 0.64308], [0.16319, 0.93609, 0.63137], [0.17377, 0.94053, 0.61938], [0.18491, 0.94484, 0.60713], [0.19659, 0.94901, 0.59466], [0.20877, 0.95304, 0.58199], [0.22142, 0.95692, 0.56914], [0.23449, 0.96065, 0.55614], [0.24797, 0.96423, 0.54303], [0.2618, 0.96765, 0.52981], [0.27597, 0.97092, 0.51653], [0.29042, 0.97403, 0.50321], [0.30513, 0.97697, 0.48987], [0.32006, 0.97974, 0.47654], [0.33517, 0.98234, 0.46325], [0.35043, 0.98477, 0.45002], [0.36581, 0.98702, 0.43688], [0.38127, 0.98909, 0.42386], [0.39678, 0.99098, 0.41098], [0.41229, 0.99268, 0.39826], [0.42778, 0.99419, 0.38575], [0.44321, 0.99551, 0.37345], [0.45854, 0.99663, 0.3614], [0.47375, 0.99755, 0.34963], [0.48879, 0.99828, 0.33816], [0.50362, 0.99879, 0.32701], [0.51822, 0.9991, 0.31622], [0.53255, 0.99919, 0.30581], [0.54658, 0.99907, 0.29581], [0.56026, 0.99873, 0.28623], [0.57357, 0.99817, 0.27712], [0.58646, 0.99739, 0.26849], [0.59891, 0.99638, 0.26038], [0.61088, 0.99514, 0.2528], [0.62233, 0.99366, 0.24579], [0.63323, 0.99195, 0.23937], [0.64362, 0.98999, 0.23356], [0.65394, 0.98775, 0.22835], [0.66428, 0.98524, 0.2237], [0.67462, 0.98246, 0.2196], [0.68494, 0.97941, 0.21602], [0.69525, 0.9761, 0.21294], [0.70553, 0.97255, 0.21032], [0.71577, 0.96875, 0.20815], [0.72596, 0.9647, 0.2064], [0.7361, 0.96043, 0.20504], [0.74617, 0.95593, 0.20406], [0.75617, 0.95121, 0.20343], [0.76608, 0.94627, 0.20311], [0.77591, 0.94113, 0.2031], [0.78563, 0.93579, 0.20336], [0.79524, 0.93025, 0.20386], [0.80473, 0.92452, 0.20459], [0.8141, 0.91861, 0.20552], [0.82333, 0.91253, 0.20663], [0.83241, 0.90627, 0.20788], [0.84133, 0.89986, 0.20926], [0.8501, 0.89328, 0.21074], [0.85868, 0.88655, 0.2123], [0.86709, 0.87968, 0.21391], [0.8753, 0.87267, 0.21555], [0.88331, 0.86553, 0.21719], [0.89112, 0.85826, 0.2188], [0.8987, 0.85087, 0.22038], [0.90605, 0.84337, 0.22188], [0.91317, 0.83576, 0.22328], [0.92004, 0.82806, 0.22456], [0.92666, 0.82025, 0.2257], [0.93301, 0.81236, 0.22667], [0.93909, 0.80439, 0.22744], [0.94489, 0.79634, 0.228], [0.95039, 0.78823, 0.22831], [0.9556, 0.78005, 0.22836], [0.96049, 0.77181, 0.22811], [0.96507, 0.76352, 0.22754], [0.96931, 0.75519, 0.22663], [0.97323, 0.74682, 0.22536], [0.97679, 0.73842, 0.22369], [0.98, 0.73, 0.22161], [0.98289, 0.7214, 0.21918], [0.98549, 0.7125, 0.2165], [0.98781, 0.7033, 0.21358], [0.98986, 0.69382, 0.21043], [0.99163, 0.68408, 0.20706], [0.99314, 0.67408, 0.20348], [0.99438, 0.66386, 0.19971], [0.99535, 0.65341, 0.19577], [0.99607, 0.64277, 0.19165], [0.99654, 0.63193, 0.18738], [0.99675, 0.62093, 0.18297], [0.99672, 0.60977, 0.17842], [0.99644, 0.59846, 0.17376], [0.99593, 0.58703, 0.16899], [0.99517, 0.57549, 0.16412], [0.99419, 0.56386, 0.15918], [0.99297, 0.55214, 0.15417], [0.99153, 0.54036, 0.1491], [0.98987, 0.52854, 0.14398], [0.98799, 0.51667, 0.13883], [0.9859, 0.50479, 0.13367], [0.9836, 0.49291, 0.12849], [0.98108, 0.48104, 0.12332], [0.97837, 0.4692, 0.11817], [0.97545, 0.4574, 0.11305], [0.97234, 0.44565, 0.10797], [0.96904, 0.43399, 0.10294], [0.96555, 0.42241, 0.09798], [0.96187, 0.41093, 0.0931], [0.95801, 0.39958, 0.08831], [0.95398, 0.38836, 0.08362], [0.94977, 0.37729, 0.07905], [0.94538, 0.36638, 0.07461], [0.94084, 0.35566, 0.07031], [0.93612, 0.34513, 0.06616], [0.93125, 0.33482, 0.06218], [0.92623, 0.32473, 0.05837], [0.92105, 0.31489, 0.05475], [0.91572, 0.3053, 0.05134], [0.91024, 0.29599, 0.04814], [0.90463, 0.28696, 0.04516], [0.89888, 0.27824, 0.04243], [0.89298, 0.26981, 0.03993], [0.88691, 0.26152, 0.03753], [0.88066, 0.25334, 0.03521], [0.87422, 0.24526, 0.03297], [0.8676, 0.2373, 0.03082], [0.86079, 0.22945, 0.02875], [0.8538, 0.2217, 0.02677], [0.84662, 0.21407, 0.02487], [0.83926, 0.20654, 0.02305], [0.83172, 0.19912, 0.02131], [0.82399, 0.19182, 0.01966], [0.81608, 0.18462, 0.01809], [0.80799, 0.17753, 0.0166], [0.79971, 0.17055, 0.0152], [0.79125, 0.16368, 0.01387], [0.7826, 0.15693, 0.01264], [0.77377, 0.15028, 0.01148], [0.76476, 0.14374, 0.01041], [0.75556, 0.13731, 0.00942], [0.74617, 0.13098, 0.00851], [0.73661, 0.12477, 0.00769], [0.72686, 0.11867, 0.00695], [0.71692, 0.11268, 0.00629], [0.7068, 0.1068, 0.00571], [0.6965, 0.10102, 0.00522], [0.68602, 0.09536, 0.00481], [0.67535, 0.0898, 0.00449], [0.66449, 0.08436, 0.00424], [0.65345, 0.07902, 0.00408], [0.64223, 0.0738, 0.00401], [0.63082, 0.06868, 0.00401], [0.61923, 0.06367, 0.0041], [0.60746, 0.05878, 0.00427], [0.5955, 0.05399, 0.00453], [0.58336, 0.04931, 0.00486], [0.57103, 0.04474, 0.00529], [0.55852, 0.04028, 0.00579], [0.54583, 0.03593, 0.00638], [0.53295, 0.03169, 0.00705], [0.51989, 0.02756, 0.0078], [0.50664, 0.02354, 0.00863], [0.49321, 0.01963, 0.00955], [0.4796, 0.01583, 0.01055]]
_berlin_data = [[0.62108, 0.69018, 0.99951], [0.61216, 0.68923, 0.99537], [0.6032, 0.68825, 0.99124], [0.5942, 0.68726, 0.98709], [0.58517, 0.68625, 0.98292], [0.57609, 0.68522, 0.97873], [0.56696, 0.68417, 0.97452], [0.55779, 0.6831, 0.97029], [0.54859, 0.68199, 0.96602], [0.53933, 0.68086, 0.9617], [0.53003, 0.67969, 0.95735], [0.52069, 0.67848, 0.95294], [0.51129, 0.67723, 0.94847], [0.50186, 0.67591, 0.94392], [0.49237, 0.67453, 0.9393], [0.48283, 0.67308, 0.93457], [0.47324, 0.67153, 0.92975], [0.46361, 0.6699, 0.92481], [0.45393, 0.66815, 0.91974], [0.44421, 0.66628, 0.91452], [0.43444, 0.66427, 0.90914], [0.42465, 0.66212, 0.90359], [0.41482, 0.65979, 0.89785], [0.40498, 0.65729, 0.89191], [0.39514, 0.65458, 0.88575], [0.3853, 0.65167, 0.87937], [0.37549, 0.64854, 0.87276], [0.36574, 0.64516, 0.8659], [0.35606, 0.64155, 0.8588], [0.34645, 0.63769, 0.85145], [0.33698, 0.63357, 0.84386], [0.32764, 0.62919, 0.83602], [0.31849, 0.62455, 0.82794], [0.30954, 0.61966, 0.81963], [0.30078, 0.6145, 0.81111], [0.29231, 0.60911, 0.80238], [0.2841, 0.60348, 0.79347], [0.27621, 0.59763, 0.78439], [0.26859, 0.59158, 0.77514], [0.26131, 0.58534, 0.76578], [0.25437, 0.57891, 0.7563], [0.24775, 0.57233, 0.74672], [0.24146, 0.5656, 0.73707], [0.23552, 0.55875, 0.72735], [0.22984, 0.5518, 0.7176], [0.2245, 0.54475, 0.7078], [0.21948, 0.53763, 0.698], [0.21469, 0.53043, 0.68819], [0.21017, 0.52319, 0.67838], [0.20589, 0.5159, 0.66858], [0.20177, 0.5086, 0.65879], [0.19788, 0.50126, 0.64903], [0.19417, 0.4939, 0.63929], [0.19056, 0.48654, 0.62957], [0.18711, 0.47918, 0.6199], [0.18375, 0.47183, 0.61024], [0.1805, 0.46447, 0.60062], [0.17737, 0.45712, 0.59104], [0.17426, 0.44979, 0.58148], [0.17122, 0.44247, 0.57197], [0.16824, 0.43517, 0.56249], [0.16529, 0.42788, 0.55302], [0.16244, 0.42061, 0.5436], [0.15954, 0.41337, 0.53421], [0.15674, 0.40615, 0.52486], [0.15391, 0.39893, 0.51552], [0.15112, 0.39176, 0.50623], [0.14835, 0.38459, 0.49697], [0.14564, 0.37746, 0.48775], [0.14288, 0.37034, 0.47854], [0.14014, 0.36326, 0.46939], [0.13747, 0.3562, 0.46024], [0.13478, 0.34916, 0.45115], [0.13208, 0.34215, 0.44209], [0.1294, 0.33517, 0.43304], [0.12674, 0.3282, 0.42404], [0.12409, 0.32126, 0.41507], [0.12146, 0.31435, 0.40614], [0.1189, 0.30746, 0.39723], [0.11632, 0.30061, 0.38838], [0.11373, 0.29378, 0.37955], [0.11119, 0.28698, 0.37075], [0.10861, 0.28022, 0.362], [0.10616, 0.2735, 0.35328], [0.10367, 0.26678, 0.34459], [0.10118, 0.26011, 0.33595], [0.098776, 0.25347, 0.32734], [0.096347, 0.24685, 0.31878], [0.094059, 0.24026, 0.31027], [0.091788, 0.23373, 0.30176], [0.089506, 0.22725, 0.29332], [0.087341, 0.2208, 0.28491], [0.085142, 0.21436, 0.27658], [0.083069, 0.20798, 0.26825], [0.081098, 0.20163, 0.25999], [0.07913, 0.19536, 0.25178], [0.077286, 0.18914, 0.24359], [0.075571, 0.18294, 0.2355], [0.073993, 0.17683, 0.22743], [0.07241, 0.17079, 0.21943], [0.071045, 0.1648, 0.2115], [0.069767, 0.1589, 0.20363], [0.068618, 0.15304, 0.19582], [0.06756, 0.14732, 0.18812], [0.066665, 0.14167, 0.18045], [0.065923, 0.13608, 0.17292], [0.065339, 0.1307, 0.16546], [0.064911, 0.12535, 0.15817], [0.064636, 0.12013, 0.15095], [0.064517, 0.11507, 0.14389], [0.064554, 0.11022, 0.13696], [0.064749, 0.10543, 0.13023], [0.0651, 0.10085, 0.12357], [0.065383, 0.096469, 0.11717], [0.065574, 0.092338, 0.11101], [0.065892, 0.088201, 0.10498], [0.066388, 0.084134, 0.099288], [0.067108, 0.080051, 0.093829], [0.068193, 0.076099, 0.08847], [0.06972, 0.072283, 0.083025], [0.071639, 0.068654, 0.077544], [0.073978, 0.065058, 0.07211], [0.076596, 0.061657, 0.066651], [0.079637, 0.05855, 0.061133], [0.082963, 0.055666, 0.055745], [0.086537, 0.052997, 0.050336], [0.090315, 0.050699, 0.04504], [0.09426, 0.048753, 0.039773], [0.098319, 0.047041, 0.034683], [0.10246, 0.045624, 0.030074], [0.10673, 0.044705, 0.026012], [0.11099, 0.043972, 0.022379], [0.11524, 0.043596, 0.01915], [0.11955, 0.043567, 0.016299], [0.12381, 0.043861, 0.013797], [0.1281, 0.044459, 0.011588], [0.13232, 0.045229, 0.0095315], [0.13645, 0.046164, 0.0078947], [0.14063, 0.047374, 0.006502], [0.14488, 0.048634, 0.0053266], [0.14923, 0.049836, 0.0043455], [0.15369, 0.050997, 0.0035374], [0.15831, 0.05213, 0.0028824], [0.16301, 0.053218, 0.0023628], [0.16781, 0.05424, 0.0019629], [0.17274, 0.055172, 0.001669], [0.1778, 0.056018, 0.0014692], [0.18286, 0.05682, 0.0013401], [0.18806, 0.057574, 0.0012617], [0.19323, 0.058514, 0.0012261], [0.19846, 0.05955, 0.0012271], [0.20378, 0.060501, 0.0012601], [0.20909, 0.061486, 0.0013221], [0.21447, 0.06271, 0.0014116], [0.2199, 0.063823, 0.0015287], [0.22535, 0.065027, 0.0016748], [0.23086, 0.066297, 0.0018529], [0.23642, 0.067645, 0.0020675], [0.24202, 0.069092, 0.0023247], [0.24768, 0.070458, 0.0026319], [0.25339, 0.071986, 0.0029984], [0.25918, 0.07364, 0.003435], [0.265, 0.075237, 0.0039545], [0.27093, 0.076965, 0.004571], [0.27693, 0.078822, 0.0053006], [0.28302, 0.080819, 0.0061608], [0.2892, 0.082879, 0.0071713], [0.29547, 0.085075, 0.0083494], [0.30186, 0.08746, 0.0097258], [0.30839, 0.089912, 0.011455], [0.31502, 0.09253, 0.013324], [0.32181, 0.095392, 0.015413], [0.32874, 0.098396, 0.01778], [0.3358, 0.10158, 0.020449], [0.34304, 0.10498, 0.02344], [0.35041, 0.10864, 0.026771], [0.35795, 0.11256, 0.030456], [0.36563, 0.11666, 0.034571], [0.37347, 0.12097, 0.039115], [0.38146, 0.12561, 0.043693], [0.38958, 0.13046, 0.048471], [0.39785, 0.13547, 0.053136], [0.40622, 0.1408, 0.057848], [0.41469, 0.14627, 0.062715], [0.42323, 0.15198, 0.067685], [0.43184, 0.15791, 0.073044], [0.44044, 0.16403, 0.07862], [0.44909, 0.17027, 0.084644], [0.4577, 0.17667, 0.090869], [0.46631, 0.18321, 0.097335], [0.4749, 0.18989, 0.10406], [0.48342, 0.19668, 0.11104], [0.49191, 0.20352, 0.11819], [0.50032, 0.21043, 0.1255], [0.50869, 0.21742, 0.13298], [0.51698, 0.22443, 0.14062], [0.5252, 0.23154, 0.14835], [0.53335, 0.23862, 0.15626], [0.54144, 0.24575, 0.16423], [0.54948, 0.25292, 0.17226], [0.55746, 0.26009, 0.1804], [0.56538, 0.26726, 0.18864], [0.57327, 0.27446, 0.19692], [0.58111, 0.28167, 0.20524], [0.58892, 0.28889, 0.21362], [0.59672, 0.29611, 0.22205], [0.60448, 0.30335, 0.23053], [0.61223, 0.31062, 0.23905], [0.61998, 0.31787, 0.24762], [0.62771, 0.32513, 0.25619], [0.63544, 0.33244, 0.26481], [0.64317, 0.33975, 0.27349], [0.65092, 0.34706, 0.28218], [0.65866, 0.3544, 0.29089], [0.66642, 0.36175, 0.29964], [0.67419, 0.36912, 0.30842], [0.68198, 0.37652, 0.31722], [0.68978, 0.38392, 0.32604], [0.6976, 0.39135, 0.33493], [0.70543, 0.39879, 0.3438], [0.71329, 0.40627, 0.35272], [0.72116, 0.41376, 0.36166], [0.72905, 0.42126, 0.37062], [0.73697, 0.4288, 0.37962], [0.7449, 0.43635, 0.38864], [0.75285, 0.44392, 0.39768], [0.76083, 0.45151, 0.40675], [0.76882, 0.45912, 0.41584], [0.77684, 0.46676, 0.42496], [0.78488, 0.47441, 0.43409], [0.79293, 0.48208, 0.44327], [0.80101, 0.48976, 0.45246], [0.80911, 0.49749, 0.46167], [0.81722, 0.50521, 0.47091], [0.82536, 0.51296, 0.48017], [0.83352, 0.52073, 0.48945], [0.84169, 0.52853, 0.49876], [0.84988, 0.53634, 0.5081], [0.85809, 0.54416, 0.51745], [0.86632, 0.55201, 0.52683], [0.87457, 0.55988, 0.53622], [0.88283, 0.56776, 0.54564], [0.89111, 0.57567, 0.55508], [0.89941, 0.58358, 0.56455], [0.90772, 0.59153, 0.57404], [0.91603, 0.59949, 0.58355], [0.92437, 0.60747, 0.59309], [0.93271, 0.61546, 0.60265], [0.94108, 0.62348, 0.61223], [0.94945, 0.63151, 0.62183], [0.95783, 0.63956, 0.63147], [0.96622, 0.64763, 0.64111], [0.97462, 0.65572, 0.65079], [0.98303, 0.66382, 0.66049], [0.99145, 0.67194, 0.67022], [0.99987, 0.68007, 0.67995]]
_managua_data = [[1, 0.81263, 0.40424], [0.99516, 0.80455, 0.40155], [0.99024, 0.79649, 0.39888], [0.98532, 0.78848, 0.39622], [0.98041, 0.7805, 0.39356], [0.97551, 0.77257, 0.39093], [0.97062, 0.76468, 0.3883], [0.96573, 0.75684, 0.38568], [0.96087, 0.74904, 0.3831], [0.95601, 0.74129, 0.38052], [0.95116, 0.7336, 0.37795], [0.94631, 0.72595, 0.37539], [0.94149, 0.71835, 0.37286], [0.93667, 0.7108, 0.37034], [0.93186, 0.7033, 0.36784], [0.92706, 0.69585, 0.36536], [0.92228, 0.68845, 0.36289], [0.9175, 0.68109, 0.36042], [0.91273, 0.67379, 0.358], [0.90797, 0.66653, 0.35558], [0.90321, 0.65932, 0.35316], [0.89846, 0.65216, 0.35078], [0.89372, 0.64503, 0.34839], [0.88899, 0.63796, 0.34601], [0.88426, 0.63093, 0.34367], [0.87953, 0.62395, 0.34134], [0.87481, 0.617, 0.33902], [0.87009, 0.61009, 0.3367], [0.86538, 0.60323, 0.33442], [0.86067, 0.59641, 0.33213], [0.85597, 0.58963, 0.32987], [0.85125, 0.5829, 0.3276], [0.84655, 0.57621, 0.32536], [0.84185, 0.56954, 0.32315], [0.83714, 0.56294, 0.32094], [0.83243, 0.55635, 0.31874], [0.82772, 0.54983, 0.31656], [0.82301, 0.54333, 0.31438], [0.81829, 0.53688, 0.31222], [0.81357, 0.53046, 0.3101], [0.80886, 0.52408, 0.30796], [0.80413, 0.51775, 0.30587], [0.7994, 0.51145, 0.30375], [0.79466, 0.50519, 0.30167], [0.78991, 0.49898, 0.29962], [0.78516, 0.4928, 0.29757], [0.7804, 0.48668, 0.29553], [0.77564, 0.48058, 0.29351], [0.77086, 0.47454, 0.29153], [0.76608, 0.46853, 0.28954], [0.76128, 0.46255, 0.28756], [0.75647, 0.45663, 0.28561], [0.75166, 0.45075, 0.28369], [0.74682, 0.44491, 0.28178], [0.74197, 0.4391, 0.27988], [0.73711, 0.43333, 0.27801], [0.73223, 0.42762, 0.27616], [0.72732, 0.42192, 0.2743], [0.72239, 0.41628, 0.27247], [0.71746, 0.41067, 0.27069], [0.71247, 0.40508, 0.26891], [0.70747, 0.39952, 0.26712], [0.70244, 0.39401, 0.26538], [0.69737, 0.38852, 0.26367], [0.69227, 0.38306, 0.26194], [0.68712, 0.37761, 0.26025], [0.68193, 0.37219, 0.25857], [0.67671, 0.3668, 0.25692], [0.67143, 0.36142, 0.25529], [0.6661, 0.35607, 0.25367], [0.66071, 0.35073, 0.25208], [0.65528, 0.34539, 0.25049], [0.6498, 0.34009, 0.24895], [0.64425, 0.3348, 0.24742], [0.63866, 0.32953, 0.2459], [0.633, 0.32425, 0.24442], [0.62729, 0.31901, 0.24298], [0.62152, 0.3138, 0.24157], [0.6157, 0.3086, 0.24017], [0.60983, 0.30341, 0.23881], [0.60391, 0.29826, 0.23752], [0.59793, 0.29314, 0.23623], [0.59191, 0.28805, 0.235], [0.58585, 0.28302, 0.23377], [0.57974, 0.27799, 0.23263], [0.57359, 0.27302, 0.23155], [0.56741, 0.26808, 0.23047], [0.5612, 0.26321, 0.22948], [0.55496, 0.25837, 0.22857], [0.54871, 0.25361, 0.22769], [0.54243, 0.24891, 0.22689], [0.53614, 0.24424, 0.22616], [0.52984, 0.23968, 0.22548], [0.52354, 0.2352, 0.22487], [0.51724, 0.23076, 0.22436], [0.51094, 0.22643, 0.22395], [0.50467, 0.22217, 0.22363], [0.49841, 0.21802, 0.22339], [0.49217, 0.21397, 0.22325], [0.48595, 0.21, 0.22321], [0.47979, 0.20618, 0.22328], [0.47364, 0.20242, 0.22345], [0.46756, 0.1988, 0.22373], [0.46152, 0.19532, 0.22413], [0.45554, 0.19195, 0.22465], [0.44962, 0.18873, 0.22534], [0.44377, 0.18566, 0.22616], [0.43799, 0.18266, 0.22708], [0.43229, 0.17987, 0.22817], [0.42665, 0.17723, 0.22938], [0.42111, 0.17474, 0.23077], [0.41567, 0.17238, 0.23232], [0.41033, 0.17023, 0.23401], [0.40507, 0.16822, 0.2359], [0.39992, 0.1664, 0.23794], [0.39489, 0.16475, 0.24014], [0.38996, 0.16331, 0.24254], [0.38515, 0.16203, 0.24512], [0.38046, 0.16093, 0.24792], [0.37589, 0.16, 0.25087], [0.37143, 0.15932, 0.25403], [0.36711, 0.15883, 0.25738], [0.36292, 0.15853, 0.26092], [0.35885, 0.15843, 0.26466], [0.35494, 0.15853, 0.26862], [0.35114, 0.15882, 0.27276], [0.34748, 0.15931, 0.27711], [0.34394, 0.15999, 0.28164], [0.34056, 0.16094, 0.28636], [0.33731, 0.16207, 0.29131], [0.3342, 0.16338, 0.29642], [0.33121, 0.16486, 0.3017], [0.32837, 0.16658, 0.30719], [0.32565, 0.16847, 0.31284], [0.3231, 0.17056, 0.31867], [0.32066, 0.17283, 0.32465], [0.31834, 0.1753, 0.33079], [0.31616, 0.17797, 0.3371], [0.3141, 0.18074, 0.34354], [0.31216, 0.18373, 0.35011], [0.31038, 0.1869, 0.35682], [0.3087, 0.19021, 0.36363], [0.30712, 0.1937, 0.37056], [0.3057, 0.19732, 0.3776], [0.30435, 0.20106, 0.38473], [0.30314, 0.205, 0.39195], [0.30204, 0.20905, 0.39924], [0.30106, 0.21323, 0.40661], [0.30019, 0.21756, 0.41404], [0.29944, 0.22198, 0.42151], [0.29878, 0.22656, 0.42904], [0.29822, 0.23122, 0.4366], [0.29778, 0.23599, 0.44419], [0.29745, 0.24085, 0.45179], [0.29721, 0.24582, 0.45941], [0.29708, 0.2509, 0.46703], [0.29704, 0.25603, 0.47465], [0.2971, 0.26127, 0.48225], [0.29726, 0.26658, 0.48983], [0.2975, 0.27194, 0.4974], [0.29784, 0.27741, 0.50493], [0.29828, 0.28292, 0.51242], [0.29881, 0.28847, 0.51987], [0.29943, 0.29408, 0.52728], [0.30012, 0.29976, 0.53463], [0.3009, 0.30548, 0.54191], [0.30176, 0.31122, 0.54915], [0.30271, 0.317, 0.5563], [0.30373, 0.32283, 0.56339], [0.30483, 0.32866, 0.5704], [0.30601, 0.33454, 0.57733], [0.30722, 0.34042, 0.58418], [0.30853, 0.34631, 0.59095], [0.30989, 0.35224, 0.59763], [0.3113, 0.35817, 0.60423], [0.31277, 0.3641, 0.61073], [0.31431, 0.37005, 0.61715], [0.3159, 0.376, 0.62347], [0.31752, 0.38195, 0.62969], [0.3192, 0.3879, 0.63583], [0.32092, 0.39385, 0.64188], [0.32268, 0.39979, 0.64783], [0.32446, 0.40575, 0.6537], [0.3263, 0.41168, 0.65948], [0.32817, 0.41763, 0.66517], [0.33008, 0.42355, 0.67079], [0.33201, 0.4295, 0.67632], [0.33398, 0.43544, 0.68176], [0.33596, 0.44137, 0.68715], [0.33798, 0.44731, 0.69246], [0.34003, 0.45327, 0.69769], [0.3421, 0.45923, 0.70288], [0.34419, 0.4652, 0.70799], [0.34631, 0.4712, 0.71306], [0.34847, 0.4772, 0.71808], [0.35064, 0.48323, 0.72305], [0.35283, 0.48928, 0.72798], [0.35506, 0.49537, 0.73288], [0.3573, 0.50149, 0.73773], [0.35955, 0.50763, 0.74256], [0.36185, 0.51381, 0.74736], [0.36414, 0.52001, 0.75213], [0.36649, 0.52627, 0.75689], [0.36884, 0.53256, 0.76162], [0.37119, 0.53889, 0.76633], [0.37359, 0.54525, 0.77103], [0.376, 0.55166, 0.77571], [0.37842, 0.55809, 0.78037], [0.38087, 0.56458, 0.78503], [0.38333, 0.5711, 0.78966], [0.38579, 0.57766, 0.79429], [0.38828, 0.58426, 0.7989], [0.39078, 0.59088, 0.8035], [0.39329, 0.59755, 0.8081], [0.39582, 0.60426, 0.81268], [0.39835, 0.61099, 0.81725], [0.4009, 0.61774, 0.82182], [0.40344, 0.62454, 0.82637], [0.406, 0.63137, 0.83092], [0.40856, 0.63822, 0.83546], [0.41114, 0.6451, 0.83999], [0.41372, 0.65202, 0.84451], [0.41631, 0.65896, 0.84903], [0.4189, 0.66593, 0.85354], [0.42149, 0.67294, 0.85805], [0.4241, 0.67996, 0.86256], [0.42671, 0.68702, 0.86705], [0.42932, 0.69411, 0.87156], [0.43195, 0.70123, 0.87606], [0.43457, 0.70839, 0.88056], [0.4372, 0.71557, 0.88506], [0.43983, 0.72278, 0.88956], [0.44248, 0.73004, 0.89407], [0.44512, 0.73732, 0.89858], [0.44776, 0.74464, 0.9031], [0.45042, 0.752, 0.90763], [0.45308, 0.75939, 0.91216], [0.45574, 0.76682, 0.9167], [0.45841, 0.77429, 0.92124], [0.46109, 0.78181, 0.9258], [0.46377, 0.78936, 0.93036], [0.46645, 0.79694, 0.93494], [0.46914, 0.80458, 0.93952], [0.47183, 0.81224, 0.94412], [0.47453, 0.81995, 0.94872], [0.47721, 0.8277, 0.95334], [0.47992, 0.83549, 0.95796], [0.48261, 0.84331, 0.96259], [0.4853, 0.85117, 0.96722], [0.48801, 0.85906, 0.97186], [0.49071, 0.86699, 0.97651], [0.49339, 0.87495, 0.98116], [0.49607, 0.88294, 0.98581], [0.49877, 0.89096, 0.99047], [0.50144, 0.89901, 0.99512], [0.50411, 0.90708, 0.99978]]
_vanimo_data = [[1, 0.80346, 0.99215], [0.99397, 0.79197, 0.98374], [0.98791, 0.78052, 0.97535], [0.98185, 0.7691, 0.96699], [0.97578, 0.75774, 0.95867], [0.96971, 0.74643, 0.95037], [0.96363, 0.73517, 0.94211], [0.95755, 0.72397, 0.93389], [0.95147, 0.71284, 0.9257], [0.94539, 0.70177, 0.91756], [0.93931, 0.69077, 0.90945], [0.93322, 0.67984, 0.90137], [0.92713, 0.66899, 0.89334], [0.92104, 0.65821, 0.88534], [0.91495, 0.64751, 0.87738], [0.90886, 0.63689, 0.86946], [0.90276, 0.62634, 0.86158], [0.89666, 0.61588, 0.85372], [0.89055, 0.60551, 0.84591], [0.88444, 0.59522, 0.83813], [0.87831, 0.58503, 0.83039], [0.87219, 0.57491, 0.82268], [0.86605, 0.5649, 0.815], [0.8599, 0.55499, 0.80736], [0.85373, 0.54517, 0.79974], [0.84756, 0.53544, 0.79216], [0.84138, 0.52583, 0.78461], [0.83517, 0.5163, 0.77709], [0.82896, 0.5069, 0.76959], [0.82272, 0.49761, 0.76212], [0.81647, 0.48841, 0.75469], [0.81018, 0.47934, 0.74728], [0.80389, 0.47038, 0.7399], [0.79757, 0.46154, 0.73255], [0.79123, 0.45283, 0.72522], [0.78487, 0.44424, 0.71792], [0.77847, 0.43578, 0.71064], [0.77206, 0.42745, 0.70339], [0.76562, 0.41925, 0.69617], [0.75914, 0.41118, 0.68897], [0.75264, 0.40327, 0.68179], [0.74612, 0.39549, 0.67465], [0.73957, 0.38783, 0.66752], [0.73297, 0.38034, 0.66041], [0.72634, 0.37297, 0.65331], [0.71967, 0.36575, 0.64623], [0.71293, 0.35864, 0.63915], [0.70615, 0.35166, 0.63206], [0.69929, 0.34481, 0.62496], [0.69236, 0.33804, 0.61782], [0.68532, 0.33137, 0.61064], [0.67817, 0.32479, 0.6034], [0.67091, 0.3183, 0.59609], [0.66351, 0.31184, 0.5887], [0.65598, 0.30549, 0.58123], [0.64828, 0.29917, 0.57366], [0.64045, 0.29289, 0.56599], [0.63245, 0.28667, 0.55822], [0.6243, 0.28051, 0.55035], [0.61598, 0.27442, 0.54237], [0.60752, 0.26838, 0.53428], [0.59889, 0.2624, 0.5261], [0.59012, 0.25648, 0.51782], [0.5812, 0.25063, 0.50944], [0.57214, 0.24483, 0.50097], [0.56294, 0.23914, 0.4924], [0.55359, 0.23348, 0.48376], [0.54413, 0.22795, 0.47505], [0.53454, 0.22245, 0.46623], [0.52483, 0.21706, 0.45736], [0.51501, 0.21174, 0.44843], [0.50508, 0.20651, 0.43942], [0.49507, 0.20131, 0.43036], [0.48495, 0.19628, 0.42125], [0.47476, 0.19128, 0.4121], [0.4645, 0.18639, 0.4029], [0.45415, 0.18157, 0.39367], [0.44376, 0.17688, 0.38441], [0.43331, 0.17225, 0.37513], [0.42282, 0.16773, 0.36585], [0.41232, 0.16332, 0.35655], [0.40178, 0.15897, 0.34726], [0.39125, 0.15471, 0.33796], [0.38071, 0.15058, 0.32869], [0.37017, 0.14651, 0.31945], [0.35969, 0.14258, 0.31025], [0.34923, 0.13872, 0.30106], [0.33883, 0.13499, 0.29196], [0.32849, 0.13133, 0.28293], [0.31824, 0.12778, 0.27396], [0.30808, 0.12431, 0.26508], [0.29805, 0.12097, 0.25631], [0.28815, 0.11778, 0.24768], [0.27841, 0.11462, 0.23916], [0.26885, 0.11169, 0.23079], [0.25946, 0.10877, 0.22259], [0.25025, 0.10605, 0.21455], [0.24131, 0.10341, 0.20673], [0.23258, 0.10086, 0.19905], [0.2241, 0.098494, 0.19163], [0.21593, 0.096182, 0.18443], [0.20799, 0.094098, 0.17748], [0.20032, 0.092102, 0.17072], [0.19299, 0.09021, 0.16425], [0.18596, 0.088461, 0.15799], [0.17918, 0.086861, 0.15197], [0.17272, 0.08531, 0.14623], [0.16658, 0.084017, 0.14075], [0.1607, 0.082745, 0.13546], [0.15515, 0.081683, 0.13049], [0.1499, 0.080653, 0.1257], [0.14493, 0.07978, 0.12112], [0.1402, 0.079037, 0.11685], [0.13578, 0.078426, 0.11282], [0.13168, 0.077944, 0.10894], [0.12782, 0.077586, 0.10529], [0.12422, 0.077332, 0.1019], [0.12091, 0.077161, 0.098724], [0.11793, 0.077088, 0.095739], [0.11512, 0.077124, 0.092921], [0.11267, 0.077278, 0.090344], [0.11042, 0.077557, 0.087858], [0.10835, 0.077968, 0.085431], [0.10665, 0.078516, 0.083233], [0.105, 0.079207, 0.081185], [0.10368, 0.080048, 0.079202], [0.10245, 0.081036, 0.077408], [0.10143, 0.082173, 0.075793], [0.1006, 0.083343, 0.074344], [0.099957, 0.084733, 0.073021], [0.099492, 0.086174, 0.071799], [0.099204, 0.087868, 0.070716], [0.099092, 0.089631, 0.069813], [0.099154, 0.091582, 0.069047], [0.099384, 0.093597, 0.068337], [0.099759, 0.095871, 0.067776], [0.10029, 0.098368, 0.067351], [0.10099, 0.101, 0.067056], [0.10185, 0.1039, 0.066891], [0.1029, 0.10702, 0.066853], [0.10407, 0.11031, 0.066942], [0.10543, 0.1138, 0.067155], [0.10701, 0.1175, 0.067485], [0.10866, 0.12142, 0.067929], [0.11059, 0.12561, 0.06849], [0.11265, 0.12998, 0.069162], [0.11483, 0.13453, 0.069842], [0.11725, 0.13923, 0.07061], [0.11985, 0.14422, 0.071528], [0.12259, 0.14937, 0.072403], [0.12558, 0.15467, 0.073463], [0.12867, 0.16015, 0.074429], [0.13196, 0.16584, 0.075451], [0.1354, 0.17169, 0.076499], [0.13898, 0.17771, 0.077615], [0.14273, 0.18382, 0.078814], [0.14658, 0.1901, 0.080098], [0.15058, 0.19654, 0.081473], [0.15468, 0.20304, 0.08282], [0.15891, 0.20968, 0.084315], [0.16324, 0.21644, 0.085726], [0.16764, 0.22326, 0.087378], [0.17214, 0.23015, 0.088955], [0.17673, 0.23717, 0.090617], [0.18139, 0.24418, 0.092314], [0.18615, 0.25132, 0.094071], [0.19092, 0.25846, 0.095839], [0.19578, 0.26567, 0.097702], [0.20067, 0.2729, 0.099539], [0.20564, 0.28016, 0.10144], [0.21062, 0.28744, 0.10342], [0.21565, 0.29475, 0.10534], [0.22072, 0.30207, 0.10737], [0.22579, 0.30942, 0.10942], [0.23087, 0.31675, 0.11146], [0.236, 0.32407, 0.11354], [0.24112, 0.3314, 0.11563], [0.24625, 0.33874, 0.11774], [0.25142, 0.34605, 0.11988], [0.25656, 0.35337, 0.12202], [0.26171, 0.36065, 0.12422], [0.26686, 0.36793, 0.12645], [0.272, 0.37519, 0.12865], [0.27717, 0.38242, 0.13092], [0.28231, 0.38964, 0.13316], [0.28741, 0.39682, 0.13541], [0.29253, 0.40398, 0.13773], [0.29763, 0.41111, 0.13998], [0.30271, 0.4182, 0.14232], [0.30778, 0.42527, 0.14466], [0.31283, 0.43231, 0.14699], [0.31787, 0.43929, 0.14937], [0.32289, 0.44625, 0.15173], [0.32787, 0.45318, 0.15414], [0.33286, 0.46006, 0.1566], [0.33781, 0.46693, 0.15904], [0.34276, 0.47374, 0.16155], [0.34769, 0.48054, 0.16407], [0.3526, 0.48733, 0.16661], [0.35753, 0.4941, 0.16923], [0.36245, 0.50086, 0.17185], [0.36738, 0.50764, 0.17458], [0.37234, 0.51443, 0.17738], [0.37735, 0.52125, 0.18022], [0.38238, 0.52812, 0.18318], [0.38746, 0.53505, 0.18626], [0.39261, 0.54204, 0.18942], [0.39783, 0.54911, 0.19272], [0.40311, 0.55624, 0.19616], [0.40846, 0.56348, 0.1997], [0.4139, 0.57078, 0.20345], [0.41942, 0.57819, 0.20734], [0.42503, 0.5857, 0.2114], [0.43071, 0.59329, 0.21565], [0.43649, 0.60098, 0.22009], [0.44237, 0.60878, 0.2247], [0.44833, 0.61667, 0.22956], [0.45439, 0.62465, 0.23468], [0.46053, 0.63274, 0.23997], [0.46679, 0.64092, 0.24553], [0.47313, 0.64921, 0.25138], [0.47959, 0.6576, 0.25745], [0.48612, 0.66608, 0.26382], [0.49277, 0.67466, 0.27047], [0.49951, 0.68335, 0.2774], [0.50636, 0.69213, 0.28464], [0.51331, 0.70101, 0.2922], [0.52035, 0.70998, 0.30008], [0.5275, 0.71905, 0.30828], [0.53474, 0.72821, 0.31682], [0.54207, 0.73747, 0.32567], [0.5495, 0.74682, 0.33491], [0.55702, 0.75625, 0.34443], [0.56461, 0.76577, 0.35434], [0.5723, 0.77537, 0.36457], [0.58006, 0.78506, 0.37515], [0.58789, 0.79482, 0.38607], [0.59581, 0.80465, 0.39734], [0.60379, 0.81455, 0.40894], [0.61182, 0.82453, 0.42086], [0.61991, 0.83457, 0.43311], [0.62805, 0.84467, 0.44566], [0.63623, 0.85482, 0.45852], [0.64445, 0.86503, 0.47168], [0.6527, 0.8753, 0.48511], [0.66099, 0.88562, 0.49882], [0.6693, 0.89599, 0.51278], [0.67763, 0.90641, 0.52699], [0.68597, 0.91687, 0.54141], [0.69432, 0.92738, 0.55605], [0.70269, 0.93794, 0.5709], [0.71107, 0.94855, 0.58593], [0.71945, 0.9592, 0.60112], [0.72782, 0.96989, 0.61646], [0.7362, 0.98063, 0.63191], [0.74458, 0.99141, 0.64748]]
cmaps = {name: ListedColormap(data, name=name) for (name, data) in [('magma', _magma_data), ('inferno', _inferno_data), ('plasma', _plasma_data), ('viridis', _viridis_data), ('cividis', _cividis_data), ('twilight', _twilight_data), ('twilight_shifted', _twilight_shifted_data), ('turbo', _turbo_data), ('berlin', _berlin_data), ('managua', _managua_data), ('vanimo', _vanimo_data)]}

# File: matplotlib-main/lib/matplotlib/_cm_multivar.py
from .colors import LinearSegmentedColormap, MultivarColormap
import matplotlib as mpl
_LUTSIZE = mpl.rcParams['image.lut']
_2VarAddA0_data = [[0.0, 0.0, 0.0], [0.02, 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.19, 0.37, 0.521], [0.197, 0.4, 0.572], [0.201, 0.431, 0.623], [0.204, 0.461, 0.675], [0.204, 0.491, 0.728], [0.202, 0.52, 0.783], [0.197, 0.549, 0.838], [0.187, 0.577, 0.895]]
_2VarAddA1_data = [[0.0, 0.0, 0.0], [0.03, 0.023, 0.018], [0.079, 0.06, 0.043], [0.125, 0.093, 0.065], [0.17, 0.123, 0.083], [0.213, 0.151, 0.098], [0.255, 0.177, 0.11], [0.298, 0.202, 0.12], [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.61, 0.353, 0.139], [0.658, 0.372, 0.134], [0.708, 0.39, 0.127], [0.759, 0.407, 0.118], [0.813, 0.423, 0.105]]
_2VarSubA0_data = [[1.0, 1.0, 1.0], [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.79, 0.875, 0.948], [0.748, 0.852, 0.94], [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.74, 0.91], [0.5, 0.718, 0.905], [0.457, 0.697, 0.901], [0.414, 0.675, 0.896], [0.369, 0.652, 0.892], [0.32, 0.629, 0.888], [0.266, 0.604, 0.884], [0.199, 0.574, 0.881]]
_2VarSubA1_data = [[1.0, 1.0, 1.0], [0.982, 0.967, 0.955], [0.966, 0.935, 0.908], [0.951, 0.902, 0.86], [0.937, 0.87, 0.813], [0.923, 0.838, 0.765], [0.91, 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.53], [0.851, 0.653, 0.483], [0.841, 0.622, 0.435], [0.831, 0.592, 0.388], [0.822, 0.561, 0.34], [0.813, 0.53, 0.29], [0.806, 0.498, 0.239], [0.802, 0.464, 0.184], [0.801, 0.426, 0.119]]
_3VarAddA0_data = [[0.0, 0.0, 0.0], [0.018, 0.023, 0.028], [0.04, 0.056, 0.071], [0.059, 0.087, 0.11], [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.29], [0.107, 0.23, 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.0, 0.0, 0.0], [0.02, 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.19, 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.27, 0.33, 0.018], [0.288, 0.347, 0.0], [0.302, 0.369, 0.0], [0.315, 0.391, 0.0], [0.328, 0.414, 0.0]]
_3VarAddA2_data = [[0.0, 0.0, 0.0], [0.029, 0.02, 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.25], [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.58, 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')}

# File: matplotlib-main/lib/matplotlib/_color_data.py
BASE_COLORS = {'b': (0, 0, 1), 'g': (0, 0.5, 0), 'r': (1, 0, 0), 'c': (0, 0.75, 0.75), 'm': (0.75, 0, 0.75), 'y': (0.75, 0.75, 0), 'k': (0, 0, 0), 'w': (1, 1, 1)}
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'}
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'}
XKCD_COLORS = {'xkcd:' + name: value for (name, value) in XKCD_COLORS.items()}
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'}

# File: matplotlib-main/lib/matplotlib/_constrained_layout.py
""""""
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):
    renderer = fig._get_renderer()
    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):
        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)
        match_submerged_margins(layoutgrids, fig)
        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)):
    if layoutgrids is None:
        layoutgrids = dict()
        layoutgrids['hasgrids'] = False
    if not hasattr(fig, '_parent'):
        layoutgrids[fig] = mlayoutgrid.LayoutGrid(parent=rect, name='figlb')
    else:
        gs = fig._subplotspec.get_gridspec()
        layoutgrids = make_layoutgrids_gs(layoutgrids, gs)
        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))
    for sfig in fig.subfigs:
        layoutgrids = make_layoutgrids(sfig, layoutgrids)
    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):
    if gs in layoutgrids or gs.figure is None:
        return layoutgrids
    layoutgrids['hasgrids'] = True
    if not hasattr(gs, '_subplot_spec'):
        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:
        subplot_spec = gs._subplot_spec
        parentgs = subplot_spec.get_gridspec()
        if parentgs not in layoutgrids:
            layoutgrids = make_layoutgrids_gs(layoutgrids, parentgs)
        subspeclb = layoutgrids[parentgs]
        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):
    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:
            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 notall 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()
    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 sfig in fig.subfigs:
        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)
        margin['left'] += pos.x0 - bbox.x0
        margin['right'] += bbox.x1 - pos.x1
        margin['bottom'] += pos.y0 - bbox.y0
        margin['top'] += bbox.y1 - pos.y1
        for cbax in ax._colorbars:
            pad = colorbar_get_pad(layoutgrids, cbax)
            (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:
                    margin['rightcb'] += cbbbox.width + pad
            elif loc == 'left':
                if cbp_cspan.start == ss.colspan.start:
                    margin['leftcb'] += cbbbox.width + pad
            elif loc == 'top':
                if cbp_rspan.start == ss.rowspan.start:
                    margin['topcb'] += cbbbox.height + pad
            elif cbp_rspan.stop == ss.rowspan.stop:
                margin['bottomcb'] += cbbbox.height + pad
            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
            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
        layoutgrids[gs].edit_outer_margin_mins(margin, ss)
    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):
    inv_trans_fig = fig.transFigure.inverted().transform_bbox
    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):
    for sfig in fig.subfigs:
        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()]
    for ax1 in axs:
        ss1 = ax1.get_subplotspec()
        if ss1.get_gridspec() not in layoutgrids:
            axs.remove(ax1)
            continue
        lg1 = layoutgrids[ss1.get_gridspec()]
        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)
        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)

def get_cb_parent_spans(cbax):
    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):
    fig = ax.get_figure(root=False)
    pos = ax.get_position(original=True)
    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):
    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
        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)
        newbbox = trans_fig_to_subfig.transform_bbox(bbox)
        ax._set_position(newbbox)
        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):
    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)
    cbpad = colorbar_get_pad(layoutgrids, cbax)
    if location in ('left', 'right'):
        pbcb = pb.shrunk(fraction, shrink).anchored(anchor, pb)
        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
            dx += -cbbbox.width - cbpad + lmargin - offset['left']
            offset['left'] += cbbbox.width + cbpad
            pbcb = pbcb.translated(dx, 0)
    else:
        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):
    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:
                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

# File: matplotlib-main/lib/matplotlib/_docstring.py
import inspect
from . import _api

def kwarg_doc(text):

    def decorator(func):
        func._kwarg_doc = text
        return func
    return decorator

class Substitution:

    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

    def update(self, *args, **kwargs):
        self.params.update(*args, **kwargs)

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(Substitution):

    def __init__(self):
        self.params = _ArtistKwdocLoader()

    def __call__(self, obj):
        super().__call__(obj)
        if isinstance(obj, type) and obj.__init__ != object.__init__:
            self(obj.__init__)
        return obj

def copy(source):

    def do_copy(target):
        if source.__doc__:
            target.__doc__ = source.__doc__
        return target
    return do_copy
dedent_interpd = interpd = _ArtistPropertiesSubstitution()

# File: matplotlib-main/lib/matplotlib/_enums.py
""""""
from enum import Enum, auto
from matplotlib import _docstring

class _AutoStringNameEnum(Enum):

    def _generate_next_value_(name, start, count, last_values):
        return name

    def __hash__(self):
        return str(self).__hash__()

class JoinStyle(str, _AutoStringNameEnum):
    miter = auto()
    round = auto()
    bevel = auto()

    @staticmethod
    def demo():
        import numpy as np
        import matplotlib.pyplot as plt

        def plot_angle(ax, x, y, angle, style):
            phi = np.radians(angle)
            xx = [x + 0.5, x, x + 0.5 * np.cos(phi)]
            yy = [y, y, y + 0.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(-0.5, 5.5)
        ax.set_axis_off()
        fig.show()
JoinStyle.input_description = '{' + ', '.join([f"'{js.name}'" for js in JoinStyle]) + '}'

class CapStyle(str, _AutoStringNameEnum):
    butt = auto()
    projecting = auto()
    round = auto()

    @staticmethod
    def demo():
        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(-0.5, 1.5)
        ax.set_axis_off()
        fig.show()
CapStyle.input_description = '{' + ', '.join([f"'{cs.name}'" for cs in CapStyle]) + '}'
_docstring.interpd.update({'JoinStyle': JoinStyle.input_description, 'CapStyle': CapStyle.input_description})

# File: matplotlib-main/lib/matplotlib/_fontconfig_pattern.py
""""""
from functools import lru_cache, partial
import re
from pyparsing import Group, Optional, ParseException, Regex, StringEnd, Suppress, ZeroOrMore, oneOf
_family_punc = '\\\\\\-:,'
_family_unescape = partial(re.compile('\\\\(?=[%s])' % _family_punc).sub, '')
_family_escape = partial(re.compile('(?=[%s])' % _family_punc).sub, '\\\\')
_value_punc = '\\\\=_:,'
_value_unescape = partial(re.compile('\\\\(?=[%s])' % _value_punc).sub, '')
_value_escape = partial(re.compile('(?=[%s])' % _value_punc).sub, '\\\\')
_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
def _make_fontconfig_parser():

    def comma_separated(elem):
        return elem + ZeroOrMore(Suppress(',') + elem)
    family = Regex(f'([^{_family_punc}]|(\\\\[{_family_punc}]))*')
    size = Regex('([0-9]+\\.?[0-9]*|\\.[0-9]+)')
    name = Regex('[a-z]+')
    value = Regex(f'([^{_value_punc}]|(\\\\[{_value_punc}]))*')
    prop = Group(name + Suppress('=') + comma_separated(value) | oneOf(_CONSTANTS))
    return Optional(comma_separated(family)('families')) + Optional('-' + comma_separated(size)('sizes')) + ZeroOrMore(':' + prop('properties*')) + StringEnd()

@lru_cache
def parse_fontconfig_pattern(pattern):
    parser = _make_fontconfig_parser()
    try:
        parse = parser.parseString(pattern)
    except ParseException as err:
        raise ValueError('\n' + ParseException.explain(err, 0)) from None
    parser.resetCache()
    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):
    kvs = [(k, getattr(d, f'get_{k}')()) for k in ['style', 'variant', 'weight', 'stretch', 'file', 'size']]
    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))

# File: matplotlib-main/lib/matplotlib/_internal_utils.py
""""""
from io import StringIO
from pathlib import Path
import subprocess
from matplotlib.transforms import TransformNode

def graphviz_dump_transform(transform, dest, *, highlight=None):
    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)}" [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)

# File: matplotlib-main/lib/matplotlib/_layoutgrid.py
""""""
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:

    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):
            self.solver = kiwi.Solver()
        else:
            parent.add_child(self, *parent_pos)
            self.solver = parent.solver
        self.artists = np.empty((nrows, ncols), dtype=object)
        self.children = np.empty((nrows, ncols), dtype=object)
        self.margins = {}
        self.margin_vals = {}
        for todo in ['left', 'right', 'leftcb', 'rightcb']:
            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')
        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}: L{self.lefts[j].value():1.3f}, B{self.bottoms[i].value():1.3f}, R{self.rights[j].value():1.3f}, T{self.tops[i].value():1.3f}, ML{self.margins['left'][j].value():1.3f}, MR{self.margins['right'][j].value():1.3f}, MB{self.margins['bottom'][i].value():1.3f}, MT{self.margins['top'][i].value():1.3f}, \n"
        return str

    def reset_margins(self):
        for todo in ['left', 'right', 'bottom', 'top', 'leftcb', 'rightcb', 'bottomcb', 'topcb']:
            self.edit_margins(todo, 0.0)

    def add_constraints(self, parent):
        self.hard_constraints()
        self.parent_constraints(parent)
        self.grid_constraints()

    def hard_constraints(self):
        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):
        self.children[np.ix_(np.atleast_1d(i), np.atleast_1d(j))] = child

    def parent_constraints(self, parent):
        if not isinstance(parent, LayoutGrid):
            hc = [self.lefts[0] == parent[0], self.rights[-1] == parent[0] + parent[2], 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:
                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, self.tops[0] == top, self.bottoms[-1] == bottom]
        for c in hc:
            self.solver.addConstraint(c | 'required')

    def grid_constraints(self):
        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]
        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')
            c = self.rights[i - 1] == self.lefts[i]
            self.solver.addConstraint(c | 'strong')
        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]
        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')
            c = self.bottoms[i - 1] == self.tops[i]
            self.solver.addConstraint(c | 'strong')

    def edit_margin(self, todo, size, cell):
        self.solver.suggestValue(self.margins[todo][cell], size)
        self.margin_vals[todo][cell] = size

    def edit_margin_min(self, todo, size, cell=0):
        if size > self.margin_vals[todo][cell]:
            self.edit_margin(todo, size, cell)

    def edit_margins(self, todo, size):
        for i in range(len(self.margin_vals[todo])):
            self.edit_margin(todo, size, i)

    def edit_all_margins_min(self, todo, 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):
        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)
        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 self.margin_vals[todo][col]

    def get_outer_bbox(self, rows=0, cols=0):
        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):
        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):
        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):
        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):
        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):
        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):
        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):
        self.solver.updateVariables()
_layoutboxobjnum = itertools.count()

def seq_id():
    return '%06d' % next(_layoutboxobjnum)

def plot_children(fig, lg=None, level=0):
    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)

# File: matplotlib-main/lib/matplotlib/_mathtext.py
""""""
from __future__ import annotations
import abc
import copy
import enum
import functools
import logging
import os
import re
import types
import unicodedata
import string
import typing as T
from typing import NamedTuple
import numpy as np
from pyparsing import Empty, Forward, Literal, NotAny, oneOf, OneOrMore, Optional, ParseBaseException, ParseException, ParseExpression, ParseFatalException, ParserElement, ParseResults, QuotedString, Regex, StringEnd, ZeroOrMore, pyparsing_common, Group
import matplotlib as mpl
from . import cbook
from ._mathtext_data import latex_to_bakoma, stix_glyph_fixes, stix_virtual_fonts, tex2uni
from .font_manager import FontProperties, findfont, get_font
from .ft2font import FT2Font, FT2Image, KERNING_DEFAULT
from packaging.version import parse as parse_version
from pyparsing import __version__ as pyparsing_version
if parse_version(pyparsing_version).major < 3:
    from pyparsing import nestedExpr as nested_expr
else:
    from pyparsing import nested_expr
if T.TYPE_CHECKING:
    from collections.abc import Iterable
    from .ft2font import Glyph
ParserElement.enablePackrat()
_log = logging.getLogger('matplotlib.mathtext')

def get_unicode_index(symbol: str) -> int:
    try:
        return ord(symbol)
    except TypeError:
        pass
    try:
        return tex2uni[symbol.strip('\\')]
    except KeyError as err:
        raise ValueError(f'{symbol!r} is not a valid Unicode character or TeX/Type1 symbol') from err

class VectorParse(NamedTuple):
    width: float
    height: float
    depth: float
    glyphs: list[tuple[FT2Font, float, int, float, float]]
    rects: list[tuple[float, float, float, float]]
VectorParse.__module__ = 'matplotlib.mathtext'

class RasterParse(NamedTuple):
    ox: float
    oy: float
    width: float
    height: float
    depth: float
    image: FT2Image
RasterParse.__module__ = 'matplotlib.mathtext'

class Output:

    def __init__(self, box: Box):
        self.box = box
        self.glyphs: list[tuple[float, float, FontInfo]] = []
        self.rects: list[tuple[float, float, float, float]] = []

    def to_vector(self) -> VectorParse:
        (w, h, d) = map(np.ceil, [self.box.width, self.box.height, self.box.depth])
        gs = [(info.font, info.fontsize, info.num, ox, h - oy + info.offset) for (ox, oy, info) in self.glyphs]
        rs = [(x1, h - y2, x2 - x1, y2 - y1) for (x1, y1, x2, y2) in self.rects]
        return VectorParse(w, h + d, d, gs, rs)

    def to_raster(self, *, antialiased: bool) -> RasterParse:
        xmin = min([*[ox + info.metrics.xmin for (ox, oy, info) in self.glyphs], *[x1 for (x1, y1, x2, y2) in self.rects], 0]) - 1
        ymin = min([*[oy - info.metrics.ymax for (ox, oy, info) in self.glyphs], *[y1 for (x1, y1, x2, y2) in self.rects], 0]) - 1
        xmax = max([*[ox + info.metrics.xmax for (ox, oy, info) in self.glyphs], *[x2 for (x1, y1, x2, y2) in self.rects], 0]) + 1
        ymax = max([*[oy - info.metrics.ymin for (ox, oy, info) in self.glyphs], *[y2 for (x1, y1, x2, y2) in self.rects], 0]) + 1
        w = xmax - xmin
        h = ymax - ymin - self.box.depth
        d = ymax - ymin - self.box.height
        image = FT2Image(np.ceil(w), np.ceil(h + max(d, 0)))
        shifted = ship(self.box, (-xmin, -ymin))
        for (ox, oy, info) in shifted.glyphs:
            info.font.draw_glyph_to_bitmap(image, ox, oy - info.metrics.iceberg, info.glyph, antialiased=antialiased)
        for (x1, y1, x2, y2) in shifted.rects:
            height = max(int(y2 - y1) - 1, 0)
            if height == 0:
                center = (y2 + y1) / 2
                y = int(center - (height + 1) / 2)
            else:
                y = int(y1)
            image.draw_rect_filled(int(x1), y, np.ceil(x2), y + height)
        return RasterParse(0, 0, w, h + d, d, image)

class FontMetrics(NamedTuple):
    advance: float
    height: float
    width: float
    xmin: float
    xmax: float
    ymin: float
    ymax: float
    iceberg: float
    slanted: bool

class FontInfo(NamedTuple):
    font: FT2Font
    fontsize: float
    postscript_name: str
    metrics: FontMetrics
    num: int
    glyph: Glyph
    offset: float

class Fonts(abc.ABC):

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        self.default_font_prop = default_font_prop
        self.load_glyph_flags = load_glyph_flags

    def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float, font2: str, fontclass2: str, sym2: str, fontsize2: float, dpi: float) -> float:
        return 0.0

    def _get_font(self, font: str) -> FT2Font:
        raise NotImplementedError

    def _get_info(self, font: str, font_class: str, sym: str, fontsize: float, dpi: float) -> FontInfo:
        raise NotImplementedError

    def get_metrics(self, font: str, font_class: str, sym: str, fontsize: float, dpi: float) -> FontMetrics:
        info = self._get_info(font, font_class, sym, fontsize, dpi)
        return info.metrics

    def render_glyph(self, output: Output, ox: float, oy: float, font: str, font_class: str, sym: str, fontsize: float, dpi: float) -> None:
        info = self._get_info(font, font_class, sym, fontsize, dpi)
        output.glyphs.append((ox, oy, info))

    def render_rect_filled(self, output: Output, x1: float, y1: float, x2: float, y2: float) -> None:
        output.rects.append((x1, y1, x2, y2))

    def get_xheight(self, font: str, fontsize: float, dpi: float) -> float:
        raise NotImplementedError()

    def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:
        raise NotImplementedError()

    def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
        return [(fontname, sym)]

class TruetypeFonts(Fonts, metaclass=abc.ABCMeta):

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        super().__init__(default_font_prop, load_glyph_flags)
        self._get_info = functools.cache(self._get_info)
        self._fonts = {}
        self.fontmap: dict[str | int, str] = {}
        filename = findfont(self.default_font_prop)
        default_font = get_font(filename)
        self._fonts['default'] = default_font
        self._fonts['regular'] = default_font

    def _get_font(self, font: str | int) -> FT2Font:
        if font in self.fontmap:
            basename = self.fontmap[font]
        else:
            basename = T.cast(str, font)
        cached_font = self._fonts.get(basename)
        if cached_font is None and os.path.exists(basename):
            cached_font = get_font(basename)
            self._fonts[basename] = cached_font
            self._fonts[cached_font.postscript_name] = cached_font
            self._fonts[cached_font.postscript_name.lower()] = cached_font
        return T.cast(FT2Font, cached_font)

    def _get_offset(self, font: FT2Font, glyph: Glyph, fontsize: float, dpi: float) -> float:
        if font.postscript_name == 'Cmex10':
            return glyph.height / 64 / 2 + fontsize / 3 * dpi / 72
        return 0.0

    def _get_glyph(self, fontname: str, font_class: str, sym: str) -> tuple[FT2Font, int, bool]:
        raise NotImplementedError

    def _get_info(self, fontname: str, font_class: str, sym: str, fontsize: float, dpi: float) -> FontInfo:
        (font, num, slanted) = self._get_glyph(fontname, font_class, sym)
        font.set_size(fontsize, dpi)
        glyph = font.load_char(num, flags=self.load_glyph_flags)
        (xmin, ymin, xmax, ymax) = (val / 64 for val in glyph.bbox)
        offset = self._get_offset(font, glyph, fontsize, dpi)
        metrics = FontMetrics(advance=glyph.linearHoriAdvance / 65536, height=glyph.height / 64, width=glyph.width / 64, xmin=xmin, xmax=xmax, ymin=ymin + offset, ymax=ymax + offset, iceberg=glyph.horiBearingY / 64 + offset, slanted=slanted)
        return FontInfo(font=font, fontsize=fontsize, postscript_name=font.postscript_name, metrics=metrics, num=num, glyph=glyph, offset=offset)

    def get_xheight(self, fontname: str, fontsize: float, dpi: float) -> float:
        font = self._get_font(fontname)
        font.set_size(fontsize, dpi)
        pclt = font.get_sfnt_table('pclt')
        if pclt is None:
            metrics = self.get_metrics(fontname, mpl.rcParams['mathtext.default'], 'x', fontsize, dpi)
            return metrics.iceberg
        xHeight = pclt['xHeight'] / 64.0 * (fontsize / 12.0) * (dpi / 100.0)
        return xHeight

    def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:
        return 0.75 / 12.0 * fontsize * dpi / 72.0

    def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float, font2: str, fontclass2: str, sym2: str, fontsize2: float, dpi: float) -> float:
        if font1 == font2 and fontsize1 == fontsize2:
            info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)
            info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)
            font = info1.font
            return font.get_kerning(info1.num, info2.num, KERNING_DEFAULT) / 64
        return super().get_kern(font1, fontclass1, sym1, fontsize1, font2, fontclass2, sym2, fontsize2, dpi)

class BakomaFonts(TruetypeFonts):
    _fontmap = {'cal': 'cmsy10', 'rm': 'cmr10', 'tt': 'cmtt10', 'it': 'cmmi10', 'bf': 'cmb10', 'sf': 'cmss10', 'ex': 'cmex10'}

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        self._stix_fallback = StixFonts(default_font_prop, load_glyph_flags)
        super().__init__(default_font_prop, load_glyph_flags)
        for (key, val) in self._fontmap.items():
            fullpath = findfont(val)
            self.fontmap[key] = fullpath
            self.fontmap[val] = fullpath
    _slanted_symbols = set('\\int \\oint'.split())

    def _get_glyph(self, fontname: str, font_class: str, sym: str) -> tuple[FT2Font, int, bool]:
        font = None
        if fontname in self.fontmap and sym in latex_to_bakoma:
            (basename, num) = latex_to_bakoma[sym]
            slanted = basename == 'cmmi10' or sym in self._slanted_symbols
            font = self._get_font(basename)
        elif len(sym) == 1:
            slanted = fontname == 'it'
            font = self._get_font(fontname)
            if font is not None:
                num = ord(sym)
        if font is not None and font.get_char_index(num) != 0:
            return (font, num, slanted)
        else:
            return self._stix_fallback._get_glyph(fontname, font_class, sym)
    _size_alternatives = {'(': [('rm', '('), ('ex', '¡'), ('ex', '³'), ('ex', 'µ'), ('ex', 'Ã')], ')': [('rm', ')'), ('ex', '¢'), ('ex', '´'), ('ex', '¶'), ('ex', '!')], '{': [('cal', '{'), ('ex', '©'), ('ex', 'n'), ('ex', '½'), ('ex', '(')], '}': [('cal', '}'), ('ex', 'ª'), ('ex', 'o'), ('ex', '¾'), ('ex', ')')], '[': [('rm', '['), ('ex', '£'), ('ex', 'h'), ('ex', '"')], ']': [('rm', ']'), ('ex', '¤'), ('ex', 'i'), ('ex', '#')], '\\lfloor': [('ex', '¥'), ('ex', 'j'), ('ex', '¹'), ('ex', '$')], '\\rfloor': [('ex', '¦'), ('ex', 'k'), ('ex', 'º'), ('ex', '%')], '\\lceil': [('ex', '§'), ('ex', 'l'), ('ex', '»'), ('ex', '&')], '\\rceil': [('ex', '¨'), ('ex', 'm'), ('ex', '¼'), ('ex', "'")], '\\langle': [('ex', '\xad'), ('ex', 'D'), ('ex', '¿'), ('ex', '*')], '\\rangle': [('ex', '®'), ('ex', 'E'), ('ex', 'À'), ('ex', '+')], '\\__sqrt__': [('ex', 'p'), ('ex', 'q'), ('ex', 'r'), ('ex', 's')], '\\backslash': [('ex', '²'), ('ex', '/'), ('ex', 'Â'), ('ex', '-')], '/': [('rm', '/'), ('ex', '±'), ('ex', '.'), ('ex', 'Ë'), ('ex', ',')], '\\widehat': [('rm', '^'), ('ex', 'b'), ('ex', 'c'), ('ex', 'd')], '\\widetilde': [('rm', '~'), ('ex', 'e'), ('ex', 'f'), ('ex', 'g')], '<': [('cal', 'h'), ('ex', 'D')], '>': [('cal', 'i'), ('ex', 'E')]}
    for (alias, target) in [('\\leftparen', '('), ('\\rightparent', ')'), ('\\leftbrace', '{'), ('\\rightbrace', '}'), ('\\leftbracket', '['), ('\\rightbracket', ']'), ('\\{', '{'), ('\\}', '}'), ('\\[', '['), ('\\]', ']')]:
        _size_alternatives[alias] = _size_alternatives[target]

    def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
        return self._size_alternatives.get(sym, [(fontname, sym)])

class UnicodeFonts(TruetypeFonts):
    _cmr10_substitutions = {215: 163, 8722: 161}

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        fallback_rc = mpl.rcParams['mathtext.fallback']
        font_cls: type[TruetypeFonts] | None = {'stix': StixFonts, 'stixsans': StixSansFonts, 'cm': BakomaFonts}.get(fallback_rc)
        self._fallback_font = font_cls(default_font_prop, load_glyph_flags) if font_cls else None
        super().__init__(default_font_prop, load_glyph_flags)
        for texfont in 'cal rm tt it bf sf bfit'.split():
            prop = mpl.rcParams['mathtext.' + texfont]
            font = findfont(prop)
            self.fontmap[texfont] = font
        prop = FontProperties('cmex10')
        font = findfont(prop)
        self.fontmap['ex'] = font
        if isinstance(self._fallback_font, StixFonts):
            stixsizedaltfonts = {0: 'STIXGeneral', 1: 'STIXSizeOneSym', 2: 'STIXSizeTwoSym', 3: 'STIXSizeThreeSym', 4: 'STIXSizeFourSym', 5: 'STIXSizeFiveSym'}
            for (size, name) in stixsizedaltfonts.items():
                fullpath = findfont(name)
                self.fontmap[size] = fullpath
                self.fontmap[name] = fullpath
    _slanted_symbols = set('\\int \\oint'.split())

    def _map_virtual_font(self, fontname: str, font_class: str, uniindex: int) -> tuple[str, int]:
        return (fontname, uniindex)

    def _get_glyph(self, fontname: str, font_class: str, sym: str) -> tuple[FT2Font, int, bool]:
        try:
            uniindex = get_unicode_index(sym)
            found_symbol = True
        except ValueError:
            uniindex = ord('?')
            found_symbol = False
            _log.warning('No TeX to Unicode mapping for %a.', sym)
        (fontname, uniindex) = self._map_virtual_font(fontname, font_class, uniindex)
        new_fontname = fontname
        if found_symbol:
            if fontname == 'it' and uniindex < 65536:
                char = chr(uniindex)
                if unicodedata.category(char)[0] != 'L' or unicodedata.name(char).startswith('GREEK CAPITAL'):
                    new_fontname = 'rm'
            slanted = new_fontname == 'it' or sym in self._slanted_symbols
            found_symbol = False
            font = self._get_font(new_fontname)
            if font is not None:
                if uniindex in self._cmr10_substitutions and font.family_name == 'cmr10':
                    font = get_font(cbook._get_data_path('fonts/ttf/cmsy10.ttf'))
                    uniindex = self._cmr10_substitutions[uniindex]
                glyphindex = font.get_char_index(uniindex)
                if glyphindex != 0:
                    found_symbol = True
        if not found_symbol:
            if self._fallback_font:
                if fontname in ('it', 'regular') and isinstance(self._fallback_font, StixFonts):
                    fontname = 'rm'
                g = self._fallback_font._get_glyph(fontname, font_class, sym)
                family = g[0].family_name
                if family in list(BakomaFonts._fontmap.values()):
                    family = 'Computer Modern'
                _log.info('Substituting symbol %s from %s', sym, family)
                return g
            else:
                if fontname in ('it', 'regular') and isinstance(self, StixFonts):
                    return self._get_glyph('rm', font_class, sym)
                _log.warning('Font %r does not have a glyph for %a [U+%x], substituting with a dummy symbol.', new_fontname, sym, uniindex)
                font = self._get_font('rm')
                uniindex = 164
                slanted = False
        return (font, uniindex, slanted)

    def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
        if self._fallback_font:
            return self._fallback_font.get_sized_alternatives_for_symbol(fontname, sym)
        return [(fontname, sym)]

class DejaVuFonts(UnicodeFonts, metaclass=abc.ABCMeta):
    _fontmap: dict[str | int, str] = {}

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        if isinstance(self, DejaVuSerifFonts):
            self._fallback_font = StixFonts(default_font_prop, load_glyph_flags)
        else:
            self._fallback_font = StixSansFonts(default_font_prop, load_glyph_flags)
        self.bakoma = BakomaFonts(default_font_prop, load_glyph_flags)
        TruetypeFonts.__init__(self, default_font_prop, load_glyph_flags)
        self._fontmap.update({1: 'STIXSizeOneSym', 2: 'STIXSizeTwoSym', 3: 'STIXSizeThreeSym', 4: 'STIXSizeFourSym', 5: 'STIXSizeFiveSym'})
        for (key, name) in self._fontmap.items():
            fullpath = findfont(name)
            self.fontmap[key] = fullpath
            self.fontmap[name] = fullpath

    def _get_glyph(self, fontname: str, font_class: str, sym: str) -> tuple[FT2Font, int, bool]:
        if sym == '\\prime':
            return self.bakoma._get_glyph(fontname, font_class, sym)
        else:
            uniindex = get_unicode_index(sym)
            font = self._get_font('ex')
            if font is not None:
                glyphindex = font.get_char_index(uniindex)
                if glyphindex != 0:
                    return super()._get_glyph('ex', font_class, sym)
            return super()._get_glyph(fontname, font_class, sym)

class DejaVuSerifFonts(DejaVuFonts):
    _fontmap = {'rm': 'DejaVu Serif', 'it': 'DejaVu Serif:italic', 'bf': 'DejaVu Serif:weight=bold', 'bfit': 'DejaVu Serif:italic:bold', 'sf': 'DejaVu Sans', 'tt': 'DejaVu Sans Mono', 'ex': 'DejaVu Serif Display', 0: 'DejaVu Serif'}

class DejaVuSansFonts(DejaVuFonts):
    _fontmap = {'rm': 'DejaVu Sans', 'it': 'DejaVu Sans:italic', 'bf': 'DejaVu Sans:weight=bold', 'bfit': 'DejaVu Sans:italic:bold', 'sf': 'DejaVu Sans', 'tt': 'DejaVu Sans Mono', 'ex': 'DejaVu Sans Display', 0: 'DejaVu Sans'}

class StixFonts(UnicodeFonts):
    _fontmap: dict[str | int, str] = {'rm': 'STIXGeneral', 'it': 'STIXGeneral:italic', 'bf': 'STIXGeneral:weight=bold', 'bfit': 'STIXGeneral:italic:bold', 'nonunirm': 'STIXNonUnicode', 'nonuniit': 'STIXNonUnicode:italic', 'nonunibf': 'STIXNonUnicode:weight=bold', 0: 'STIXGeneral', 1: 'STIXSizeOneSym', 2: 'STIXSizeTwoSym', 3: 'STIXSizeThreeSym', 4: 'STIXSizeFourSym', 5: 'STIXSizeFiveSym'}
    _fallback_font = None
    _sans = False

    def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int):
        TruetypeFonts.__init__(self, default_font_prop, load_glyph_flags)
        for (key, name) in self._fontmap.items():
            fullpath = findfont(name)
            self.fontmap[key] = fullpath
            self.fontmap[name] = fullpath

    def _map_virtual_font(self, fontname: str, font_class: str, uniindex: int) -> tuple[str, int]:
        font_mapping = stix_virtual_fonts.get(fontname)
        if self._sans and font_mapping is None and (fontname not in ('regular', 'default')):
            font_mapping = stix_virtual_fonts['sf']
            doing_sans_conversion = True
        else:
            doing_sans_conversion = False
        if isinstance(font_mapping, dict):
            try:
                mapping = font_mapping[font_class]
            except KeyError:
                mapping = font_mapping['rm']
        elif isinstance(font_mapping, list):
            mapping = font_mapping
        else:
            mapping = None
        if mapping is not None:
            lo = 0
            hi = len(mapping)
            while lo < hi:
                mid = (lo + hi) // 2
                range = mapping[mid]
                if uniindex < range[0]:
                    hi = mid
                elif uniindex <= range[1]:
                    break
                else:
                    lo = mid + 1
            if range[0] <= uniindex <= range[1]:
                uniindex = uniindex - range[0] + range[3]
                fontname = range[2]
            elif not doing_sans_conversion:
                uniindex = 1
                fontname = mpl.rcParams['mathtext.default']
        if fontname in ('rm', 'it'):
            uniindex = stix_glyph_fixes.get(uniindex, uniindex)
        if fontname in ('it', 'rm', 'bf', 'bfit') and 57344 <= uniindex <= 63743:
            fontname = 'nonuni' + fontname
        return (fontname, uniindex)

    @functools.cache
    def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]] | list[tuple[int, str]]:
        fixes = {'\\{': '{', '\\}': '}', '\\[': '[', '\\]': ']', '<': '⟨', '>': '⟩'}
        sym = fixes.get(sym, sym)
        try:
            uniindex = get_unicode_index(sym)
        except ValueError:
            return [(fontname, sym)]
        alternatives = [(i, chr(uniindex)) for i in range(6) if self._get_font(i).get_char_index(uniindex) != 0]
        if sym == '\\__sqrt__':
            alternatives = alternatives[:-1]
        return alternatives

class StixSansFonts(StixFonts):
    _sans = True
SHRINK_FACTOR = 0.7
NUM_SIZE_LEVELS = 6

class FontConstantsBase:
    script_space: T.ClassVar[float] = 0.05
    subdrop: T.ClassVar[float] = 0.4
    sup1: T.ClassVar[float] = 0.7
    sub1: T.ClassVar[float] = 0.3
    sub2: T.ClassVar[float] = 0.5
    delta: T.ClassVar[float] = 0.025
    delta_slanted: T.ClassVar[float] = 0.2
    delta_integral: T.ClassVar[float] = 0.1

class ComputerModernFontConstants(FontConstantsBase):
    script_space = 0.075
    subdrop = 0.2
    sup1 = 0.45
    sub1 = 0.2
    sub2 = 0.3
    delta = 0.075
    delta_slanted = 0.3
    delta_integral = 0.3

class STIXFontConstants(FontConstantsBase):
    script_space = 0.1
    sup1 = 0.8
    sub2 = 0.6
    delta = 0.05
    delta_slanted = 0.3
    delta_integral = 0.3

class STIXSansFontConstants(FontConstantsBase):
    script_space = 0.05
    sup1 = 0.8
    delta_slanted = 0.6
    delta_integral = 0.3

class DejaVuSerifFontConstants(FontConstantsBase):
    pass

class DejaVuSansFontConstants(FontConstantsBase):
    pass
_font_constant_mapping = {'DejaVu Sans': DejaVuSansFontConstants, 'DejaVu Sans Mono': DejaVuSansFontConstants, 'DejaVu Serif': DejaVuSerifFontConstants, 'cmb10': ComputerModernFontConstants, 'cmex10': ComputerModernFontConstants, 'cmmi10': ComputerModernFontConstants, 'cmr10': ComputerModernFontConstants, 'cmss10': ComputerModernFontConstants, 'cmsy10': ComputerModernFontConstants, 'cmtt10': ComputerModernFontConstants, 'STIXGeneral': STIXFontConstants, 'STIXNonUnicode': STIXFontConstants, 'STIXSizeFiveSym': STIXFontConstants, 'STIXSizeFourSym': STIXFontConstants, 'STIXSizeThreeSym': STIXFontConstants, 'STIXSizeTwoSym': STIXFontConstants, 'STIXSizeOneSym': STIXFontConstants, 'Bitstream Vera Sans': DejaVuSansFontConstants, 'Bitstream Vera': DejaVuSansFontConstants}

def _get_font_constant_set(state: ParserState) -> type[FontConstantsBase]:
    constants = _font_constant_mapping.get(state.fontset._get_font(state.font).family_name, FontConstantsBase)
    if constants is STIXFontConstants and isinstance(state.fontset, StixSansFonts):
        return STIXSansFontConstants
    return constants

class Node:

    def __init__(self) -> None:
        self.size = 0

    def __repr__(self) -> str:
        return type(self).__name__

    def get_kerning(self, next: Node | None) -> float:
        return 0.0

    def shrink(self) -> None:
        self.size += 1

    def render(self, output: Output, x: float, y: float) -> None:

class Box(Node):

    def __init__(self, width: float, height: float, depth: float) -> None:
        super().__init__()
        self.width = width
        self.height = height
        self.depth = depth

    def shrink(self) -> None:
        super().shrink()
        if self.size < NUM_SIZE_LEVELS:
            self.width *= SHRINK_FACTOR
            self.height *= SHRINK_FACTOR
            self.depth *= SHRINK_FACTOR

    def render(self, output: Output, x1: float, y1: float, x2: float, y2: float) -> None:
        pass

class Vbox(Box):

    def __init__(self, height: float, depth: float):
        super().__init__(0.0, height, depth)

class Hbox(Box):

    def __init__(self, width: float):
        super().__init__(width, 0.0, 0.0)

class Char(Node):

    def __init__(self, c: str, state: ParserState):
        super().__init__()
        self.c = c
        self.fontset = state.fontset
        self.font = state.font
        self.font_class = state.font_class
        self.fontsize = state.fontsize
        self.dpi = state.dpi
        self._update_metrics()

    def __repr__(self) -> str:
        return '`%s`' % self.c

    def _update_metrics(self) -> None:
        metrics = self._metrics = self.fontset.get_metrics(self.font, self.font_class, self.c, self.fontsize, self.dpi)
        if self.c == ' ':
            self.width = metrics.advance
        else:
            self.width = metrics.width
        self.height = metrics.iceberg
        self.depth = -(metrics.iceberg - metrics.height)

    def is_slanted(self) -> bool:
        return self._metrics.slanted

    def get_kerning(self, next: Node | None) -> float:
        advance = self._metrics.advance - self.width
        kern = 0.0
        if isinstance(next, Char):
            kern = self.fontset.get_kern(self.font, self.font_class, self.c, self.fontsize, next.font, next.font_class, next.c, next.fontsize, self.dpi)
        return advance + kern

    def render(self, output: Output, x: float, y: float) -> None:
        self.fontset.render_glyph(output, x, y, self.font, self.font_class, self.c, self.fontsize, self.dpi)

    def shrink(self) -> None:
        super().shrink()
        if self.size < NUM_SIZE_LEVELS:
            self.fontsize *= SHRINK_FACTOR
            self.width *= SHRINK_FACTOR
            self.height *= SHRINK_FACTOR
            self.depth *= SHRINK_FACTOR

class Accent(Char):

    def _update_metrics(self) -> None:
        metrics = self._metrics = self.fontset.get_metrics(self.font, self.font_class, self.c, self.fontsize, self.dpi)
        self.width = metrics.xmax - metrics.xmin
        self.height = metrics.ymax - metrics.ymin
        self.depth = 0

    def shrink(self) -> None:
        super().shrink()
        self._update_metrics()

    def render(self, output: Output, x: float, y: float) -> None:
        self.fontset.render_glyph(output, x - self._metrics.xmin, y + self._metrics.ymin, self.font, self.font_class, self.c, self.fontsize, self.dpi)

class List(Box):

    def __init__(self, elements: T.Sequence[Node]):
        super().__init__(0.0, 0.0, 0.0)
        self.shift_amount = 0.0
        self.children = [*elements]
        self.glue_set = 0.0
        self.glue_sign = 0
        self.glue_order = 0

    def __repr__(self) -> str:
        return '{}<w={:.02f} h={:.02f} d={:.02f} s={:.02f}>[{}]'.format(super().__repr__(), self.width, self.height, self.depth, self.shift_amount, ', '.join([repr(x) for x in self.children]))

    def _set_glue(self, x: float, sign: int, totals: list[float], error_type: str) -> None:
        self.glue_order = o = next((i for i in range(len(totals))[::-1] if totals[i] != 0), 0)
        self.glue_sign = sign
        if totals[o] != 0.0:
            self.glue_set = x / totals[o]
        else:
            self.glue_sign = 0
            self.glue_ratio = 0.0
        if o == 0:
            if len(self.children):
                _log.warning('%s %s: %r', error_type, type(self).__name__, self)

    def shrink(self) -> None:
        for child in self.children:
            child.shrink()
        super().shrink()
        if self.size < NUM_SIZE_LEVELS:
            self.shift_amount *= SHRINK_FACTOR
            self.glue_set *= SHRINK_FACTOR

class Hlist(List):

    def __init__(self, elements: T.Sequence[Node], w: float=0.0, m: T.Literal['additional', 'exactly']='additional', do_kern: bool=True):
        super().__init__(elements)
        if do_kern:
            self.kern()
        self.hpack(w=w, m=m)

    def kern(self) -> None:
        new_children = []
        num_children = len(self.children)
        if num_children:
            for i in range(num_children):
                elem = self.children[i]
                if i < num_children - 1:
                    next = self.children[i + 1]
                else:
                    next = None
                new_children.append(elem)
                kerning_distance = elem.get_kerning(next)
                if kerning_distance != 0.0:
                    kern = Kern(kerning_distance)
                    new_children.append(kern)
            self.children = new_children

    def hpack(self, w: float=0.0, m: T.Literal['additional', 'exactly']='additional') -> None:
        h = 0.0
        d = 0.0
        x = 0.0
        total_stretch = [0.0] * 4
        total_shrink = [0.0] * 4
        for p in self.children:
            if isinstance(p, Char):
                x += p.width
                h = max(h, p.height)
                d = max(d, p.depth)
            elif isinstance(p, Box):
                x += p.width
                if not np.isinf(p.height) and (not np.isinf(p.depth)):
                    s = getattr(p, 'shift_amount', 0.0)
                    h = max(h, p.height - s)
                    d = max(d, p.depth + s)
            elif isinstance(p, Glue):
                glue_spec = p.glue_spec
                x += glue_spec.width
                total_stretch[glue_spec.stretch_order] += glue_spec.stretch
                total_shrink[glue_spec.shrink_order] += glue_spec.shrink
            elif isinstance(p, Kern):
                x += p.width
        self.height = h
        self.depth = d
        if m == 'additional':
            w += x
        self.width = w
        x = w - x
        if x == 0.0:
            self.glue_sign = 0
            self.glue_order = 0
            self.glue_ratio = 0.0
            return
        if x > 0.0:
            self._set_glue(x, 1, total_stretch, 'Overful')
        else:
            self._set_glue(x, -1, total_shrink, 'Underful')

class Vlist(List):

    def __init__(self, elements: T.Sequence[Node], h: float=0.0, m: T.Literal['additional', 'exactly']='additional'):
        super().__init__(elements)
        self.vpack(h=h, m=m)

    def vpack(self, h: float=0.0, m: T.Literal['additional', 'exactly']='additional', l: float=np.inf) -> None:
        w = 0.0
        d = 0.0
        x = 0.0
        total_stretch = [0.0] * 4
        total_shrink = [0.0] * 4
        for p in self.children:
            if isinstance(p, Box):
                x += d + p.height
                d = p.depth
                if not np.isinf(p.width):
                    s = getattr(p, 'shift_amount', 0.0)
                    w = max(w, p.width + s)
            elif isinstance(p, Glue):
                x += d
                d = 0.0
                glue_spec = p.glue_spec
                x += glue_spec.width
                total_stretch[glue_spec.stretch_order] += glue_spec.stretch
                total_shrink[glue_spec.shrink_order] += glue_spec.shrink
            elif isinstance(p, Kern):
                x += d + p.width
                d = 0.0
            elif isinstance(p, Char):
                raise RuntimeError('Internal mathtext error: Char node found in Vlist')
        self.width = w
        if d > l:
            x += d - l
            self.depth = l
        else:
            self.depth = d
        if m == 'additional':
            h += x
        self.height = h
        x = h - x
        if x == 0:
            self.glue_sign = 0
            self.glue_order = 0
            self.glue_ratio = 0.0
            return
        if x > 0.0:
            self._set_glue(x, 1, total_stretch, 'Overful')
        else:
            self._set_glue(x, -1, total_shrink, 'Underful')

class Rule(Box):

    def __init__(self, width: float, height: float, depth: float, state: ParserState):
        super().__init__(width, height, depth)
        self.fontset = state.fontset

    def render(self, output: Output, x: float, y: float, w: float, h: float) -> None:
        self.fontset.render_rect_filled(output, x, y, x + w, y + h)

class Hrule(Rule):

    def __init__(self, state: ParserState, thickness: float | None=None):
        if thickness is None:
            thickness = state.get_current_underline_thickness()
        height = depth = thickness * 0.5
        super().__init__(np.inf, height, depth, state)

class Vrule(Rule):

    def __init__(self, state: ParserState):
        thickness = state.get_current_underline_thickness()
        super().__init__(thickness, np.inf, np.inf, state)

class _GlueSpec(NamedTuple):
    width: float
    stretch: float
    stretch_order: int
    shrink: float
    shrink_order: int
_GlueSpec._named = {'fil': _GlueSpec(0.0, 1.0, 1, 0.0, 0), 'fill': _GlueSpec(0.0, 1.0, 2, 0.0, 0), 'filll': _GlueSpec(0.0, 1.0, 3, 0.0, 0), 'neg_fil': _GlueSpec(0.0, 0.0, 0, 1.0, 1), 'neg_fill': _GlueSpec(0.0, 0.0, 0, 1.0, 2), 'neg_filll': _GlueSpec(0.0, 0.0, 0, 1.0, 3), 'empty': _GlueSpec(0.0, 0.0, 0, 0.0, 0), 'ss': _GlueSpec(0.0, 1.0, 1, -1.0, 1)}

class Glue(Node):

    def __init__(self, glue_type: _GlueSpec | T.Literal['fil', 'fill', 'filll', 'neg_fil', 'neg_fill', 'neg_filll', 'empty', 'ss']):
        super().__init__()
        if isinstance(glue_type, str):
            glue_spec = _GlueSpec._named[glue_type]
        elif isinstance(glue_type, _GlueSpec):
            glue_spec = glue_type
        else:
            raise ValueError('glue_type must be a glue spec name or instance')
        self.glue_spec = glue_spec

    def shrink(self) -> None:
        super().shrink()
        if self.size < NUM_SIZE_LEVELS:
            g = self.glue_spec
            self.glue_spec = g._replace(width=g.width * SHRINK_FACTOR)

class HCentered(Hlist):

    def __init__(self, elements: list[Node]):
        super().__init__([Glue('ss'), *elements, Glue('ss')], do_kern=False)

class VCentered(Vlist):

    def __init__(self, elements: list[Node]):
        super().__init__([Glue('ss'), *elements, Glue('ss')])

class Kern(Node):
    height = 0
    depth = 0

    def __init__(self, width: float):
        super().__init__()
        self.width = width

    def __repr__(self) -> str:
        return 'k%.02f' % self.width

    def shrink(self) -> None:
        super().shrink()
        if self.size < NUM_SIZE_LEVELS:
            self.width *= SHRINK_FACTOR

class AutoHeightChar(Hlist):

    def __init__(self, c: str, height: float, depth: float, state: ParserState, always: bool=False, factor: float | None=None):
        alternatives = state.fontset.get_sized_alternatives_for_symbol(state.font, c)
        xHeight = state.fontset.get_xheight(state.font, state.fontsize, state.dpi)
        state = state.copy()
        target_total = height + depth
        for (fontname, sym) in alternatives:
            state.font = fontname
            char = Char(sym, state)
            if char.height + char.depth >= target_total - 0.2 * xHeight:
                break
        shift = 0.0
        if state.font != 0 or len(alternatives) == 1:
            if factor is None:
                factor = target_total / (char.height + char.depth)
            state.fontsize *= factor
            char = Char(sym, state)
            shift = depth - char.depth
        super().__init__([char])
        self.shift_amount = shift

class AutoWidthChar(Hlist):

    def __init__(self, c: str, width: float, state: ParserState, always: bool=False, char_class: type[Char]=Char):
        alternatives = state.fontset.get_sized_alternatives_for_symbol(state.font, c)
        state = state.copy()
        for (fontname, sym) in alternatives:
            state.font = fontname
            char = char_class(sym, state)
            if char.width >= width:
                break
        factor = width / char.width
        state.fontsize *= factor
        char = char_class(sym, state)
        super().__init__([char])
        self.width = char.width

def ship(box: Box, xy: tuple[float, float]=(0, 0)) -> Output:
    (ox, oy) = xy
    cur_v = 0.0
    cur_h = 0.0
    off_h = ox
    off_v = oy + box.height
    output = Output(box)

    def clamp(value: float) -> float:
        return -1000000000.0 if value < -1000000000.0 else +1000000000.0 if value > +1000000000.0 else value

    def hlist_out(box: Hlist) -> None:
        nonlocal cur_v, cur_h, off_h, off_v
        cur_g = 0
        cur_glue = 0.0
        glue_order = box.glue_order
        glue_sign = box.glue_sign
        base_line = cur_v
        left_edge = cur_h
        for p in box.children:
            if isinstance(p, Char):
                p.render(output, cur_h + off_h, cur_v + off_v)
                cur_h += p.width
            elif isinstance(p, Kern):
                cur_h += p.width
            elif isinstance(p, List):
                if len(p.children) == 0:
                    cur_h += p.width
                else:
                    edge = cur_h
                    cur_v = base_line + p.shift_amount
                    if isinstance(p, Hlist):
                        hlist_out(p)
                    elif isinstance(p, Vlist):
                        vlist_out(p)
                    else:
                        assert False, 'unreachable code'
                    cur_h = edge + p.width
                    cur_v = base_line
            elif isinstance(p, Box):
                rule_height = p.height
                rule_depth = p.depth
                rule_width = p.width
                if np.isinf(rule_height):
                    rule_height = box.height
                if np.isinf(rule_depth):
                    rule_depth = box.depth
                if rule_height > 0 and rule_width > 0:
                    cur_v = base_line + rule_depth
                    p.render(output, cur_h + off_h, cur_v + off_v, rule_width, rule_height)
                    cur_v = base_line
                cur_h += rule_width
            elif isinstance(p, Glue):
                glue_spec = p.glue_spec
                rule_width = glue_spec.width - cur_g
                if glue_sign != 0:
                    if glue_sign == 1:
                        if glue_spec.stretch_order == glue_order:
                            cur_glue += glue_spec.stretch
                            cur_g = round(clamp(box.glue_set * cur_glue))
                    elif glue_spec.shrink_order == glue_order:
                        cur_glue += glue_spec.shrink
                        cur_g = round(clamp(box.glue_set * cur_glue))
                rule_width += cur_g
                cur_h += rule_width

    def vlist_out(box: Vlist) -> None:
        nonlocal cur_v, cur_h, off_h, off_v
        cur_g = 0
        cur_glue = 0.0
        glue_order = box.glue_order
        glue_sign = box.glue_sign
        left_edge = cur_h
        cur_v -= box.height
        top_edge = cur_v
        for p in box.children:
            if isinstance(p, Kern):
                cur_v += p.width
            elif isinstance(p, List):
                if len(p.children) == 0:
                    cur_v += p.height + p.depth
                else:
                    cur_v += p.height
                    cur_h = left_edge + p.shift_amount
                    save_v = cur_v
                    p.width = box.width
                    if isinstance(p, Hlist):
                        hlist_out(p)
                    elif isinstance(p, Vlist):
                        vlist_out(p)
                    else:
                        assert False, 'unreachable code'
                    cur_v = save_v + p.depth
                    cur_h = left_edge
            elif isinstance(p, Box):
                rule_height = p.height
                rule_depth = p.depth
                rule_width = p.width
                if np.isinf(rule_width):
                    rule_width = box.width
                rule_height += rule_depth
                if rule_height > 0 and rule_depth > 0:
                    cur_v += rule_height
                    p.render(output, cur_h + off_h, cur_v + off_v, rule_width, rule_height)
            elif isinstance(p, Glue):
                glue_spec = p.glue_spec
                rule_height = glue_spec.width - cur_g
                if glue_sign != 0:
                    if glue_sign == 1:
                        if glue_spec.stretch_order == glue_order:
                            cur_glue += glue_spec.stretch
                            cur_g = round(clamp(box.glue_set * cur_glue))
                    elif glue_spec.shrink_order == glue_order:
                        cur_glue += glue_spec.shrink
                        cur_g = round(clamp(box.glue_set * cur_glue))
                rule_height += cur_g
                cur_v += rule_height
            elif isinstance(p, Char):
                raise RuntimeError('Internal mathtext error: Char node found in vlist')
    assert isinstance(box, Hlist)
    hlist_out(box)
    return output

def Error(msg: str) -> ParserElement:

    def raise_error(s: str, loc: int, toks: ParseResults) -> T.Any:
        raise ParseFatalException(s, loc, msg)
    return Empty().setParseAction(raise_error)

class ParserState:

    def __init__(self, fontset: Fonts, font: str, font_class: str, fontsize: float, dpi: float):
        self.fontset = fontset
        self._font = font
        self.font_class = font_class
        self.fontsize = fontsize
        self.dpi = dpi

    def copy(self) -> ParserState:
        return copy.copy(self)

    @property
    def font(self) -> str:
        return self._font

    @font.setter
    def font(self, name: str) -> None:
        if name in ('rm', 'it', 'bf', 'bfit'):
            self.font_class = name
        self._font = name

    def get_current_underline_thickness(self) -> float:
        return self.fontset.get_underline_thickness(self.font, self.fontsize, self.dpi)

def cmd(expr: str, args: ParserElement) -> ParserElement:

    def names(elt: ParserElement) -> T.Generator[str, None, None]:
        if isinstance(elt, ParseExpression):
            for expr in elt.exprs:
                yield from names(expr)
        elif elt.resultsName:
            yield elt.resultsName
    csname = expr.split('{', 1)[0]
    err = csname + ''.join(('{%s}' % name for name in names(args))) if expr == csname else expr
    return csname - (args | Error(f'Expected {err}'))

class Parser:

    class _MathStyle(enum.Enum):
        DISPLAYSTYLE = 0
        TEXTSTYLE = 1
        SCRIPTSTYLE = 2
        SCRIPTSCRIPTSTYLE = 3
    _binary_operators = set('+ * - −\n      \\pm             \\sqcap                   \\rhd\n      \\mp             \\sqcup                   \\unlhd\n      \\times          \\vee                     \\unrhd\n      \\div            \\wedge                   \\oplus\n      \\ast            \\setminus                \\ominus\n      \\star           \\wr                      \\otimes\n      \\circ           \\diamond                 \\oslash\n      \\bullet         \\bigtriangleup           \\odot\n      \\cdot           \\bigtriangledown         \\bigcirc\n      \\cap            \\triangleleft            \\dagger\n      \\cup            \\triangleright           \\ddagger\n      \\uplus          \\lhd                     \\amalg\n      \\dotplus        \\dotminus                \\Cap\n      \\Cup            \\barwedge                \\boxdot\n      \\boxminus       \\boxplus                 \\boxtimes\n      \\curlyvee       \\curlywedge              \\divideontimes\n      \\doublebarwedge \\leftthreetimes          \\rightthreetimes\n      \\slash          \\veebar                  \\barvee\n      \\cupdot         \\intercal                \\amalg\n      \\circledcirc    \\circleddash             \\circledast\n      \\boxbar         \\obar                    \\merge\n      \\minuscolon     \\dotsminusdots\n      '.split())
    _relation_symbols = set('\n      = < > :\n      \\leq          \\geq          \\equiv       \\models\n      \\prec         \\succ         \\sim         \\perp\n      \\preceq       \\succeq       \\simeq       \\mid\n      \\ll           \\gg           \\asymp       \\parallel\n      \\subset       \\supset       \\approx      \\bowtie\n      \\subseteq     \\supseteq     \\cong        \\Join\n      \\sqsubset     \\sqsupset     \\neq         \\smile\n      \\sqsubseteq   \\sqsupseteq   \\doteq       \\frown\n      \\in           \\ni           \\propto      \\vdash\n      \\dashv        \\dots         \\doteqdot    \\leqq\n      \\geqq         \\lneqq        \\gneqq       \\lessgtr\n      \\leqslant     \\geqslant     \\eqgtr       \\eqless\n      \\eqslantless  \\eqslantgtr   \\lesseqgtr   \\backsim\n      \\backsimeq    \\lesssim      \\gtrsim      \\precsim\n      \\precnsim     \\gnsim        \\lnsim       \\succsim\n      \\succnsim     \\nsim         \\lesseqqgtr  \\gtreqqless\n      \\gtreqless    \\subseteqq    \\supseteqq   \\subsetneqq\n      \\supsetneqq   \\lessapprox   \\approxeq    \\gtrapprox\n      \\precapprox   \\succapprox   \\precnapprox \\succnapprox\n      \\npreccurlyeq \\nsucccurlyeq \\nsqsubseteq \\nsqsupseteq\n      \\sqsubsetneq  \\sqsupsetneq  \\nlesssim    \\ngtrsim\n      \\nlessgtr     \\ngtrless     \\lnapprox    \\gnapprox\n      \\napprox      \\approxeq     \\approxident \\lll\n      \\ggg          \\nparallel    \\Vdash       \\Vvdash\n      \\nVdash       \\nvdash       \\vDash       \\nvDash\n      \\nVDash       \\oequal       \\simneqq     \\triangle\n      \\triangleq         \\triangleeq         \\triangleleft\n      \\triangleright     \\ntriangleleft      \\ntriangleright\n      \\trianglelefteq    \\ntrianglelefteq    \\trianglerighteq\n      \\ntrianglerighteq  \\blacktriangleleft  \\blacktriangleright\n      \\equalparallel     \\measuredrightangle \\varlrtriangle\n      \\Doteq        \\Bumpeq       \\Subset      \\Supset\n      \\backepsilon  \\because      \\therefore   \\bot\n      \\top          \\bumpeq       \\circeq      \\coloneq\n      \\curlyeqprec  \\curlyeqsucc  \\eqcirc      \\eqcolon\n      \\eqsim        \\fallingdotseq \\gtrdot     \\gtrless\n      \\ltimes       \\rtimes       \\lessdot     \\ne\n      \\ncong        \\nequiv       \\ngeq        \\ngtr\n      \\nleq         \\nless        \\nmid        \\notin\n      \\nprec        \\nsubset      \\nsubseteq   \\nsucc\n      \\nsupset      \\nsupseteq    \\pitchfork   \\preccurlyeq\n      \\risingdotseq \\subsetneq    \\succcurlyeq \\supsetneq\n      \\varpropto    \\vartriangleleft \\scurel\n      \\vartriangleright \\rightangle \\equal     \\backcong\n      \\eqdef        \\wedgeq       \\questeq     \\between\n      \\veeeq        \\disin        \\varisins    \\isins\n      \\isindot      \\varisinobar  \\isinobar    \\isinvb\n      \\isinE        \\nisd         \\varnis      \\nis\n      \\varniobar    \\niobar       \\bagmember   \\ratio\n      \\Equiv        \\stareq       \\measeq      \\arceq\n      \\rightassert  \\rightModels  \\smallin     \\smallowns\n      \\notsmallowns \\nsimeq'.split())
    _arrow_symbols = set('\n     \\leftarrow \\longleftarrow \\uparrow \\Leftarrow \\Longleftarrow\n     \\Uparrow \\rightarrow \\longrightarrow \\downarrow \\Rightarrow\n     \\Longrightarrow \\Downarrow \\leftrightarrow \\updownarrow\n     \\longleftrightarrow \\updownarrow \\Leftrightarrow\n     \\Longleftrightarrow \\Updownarrow \\mapsto \\longmapsto \\nearrow\n     \\hookleftarrow \\hookrightarrow \\searrow \\leftharpoonup\n     \\rightharpoonup \\swarrow \\leftharpoondown \\rightharpoondown\n     \\nwarrow \\rightleftharpoons \\leadsto \\dashrightarrow\n     \\dashleftarrow \\leftleftarrows \\leftrightarrows \\Lleftarrow\n     \\Rrightarrow \\twoheadleftarrow \\leftarrowtail \\looparrowleft\n     \\leftrightharpoons \\curvearrowleft \\circlearrowleft \\Lsh\n     \\upuparrows \\upharpoonleft \\downharpoonleft \\multimap\n     \\leftrightsquigarrow \\rightrightarrows \\rightleftarrows\n     \\rightrightarrows \\rightleftarrows \\twoheadrightarrow\n     \\rightarrowtail \\looparrowright \\rightleftharpoons\n     \\curvearrowright \\circlearrowright \\Rsh \\downdownarrows\n     \\upharpoonright \\downharpoonright \\rightsquigarrow \\nleftarrow\n     \\nrightarrow \\nLeftarrow \\nRightarrow \\nleftrightarrow\n     \\nLeftrightarrow \\to \\Swarrow \\Searrow \\Nwarrow \\Nearrow\n     \\leftsquigarrow \\overleftarrow \\overleftrightarrow \\cwopencirclearrow\n     \\downzigzagarrow \\cupleftarrow \\rightzigzagarrow \\twoheaddownarrow\n     \\updownarrowbar \\twoheaduparrow \\rightarrowbar \\updownarrows\n     \\barleftarrow \\mapsfrom \\mapsdown \\mapsup \\Ldsh \\Rdsh\n     '.split())
    _spaced_symbols = _binary_operators | _relation_symbols | _arrow_symbols
    _punctuation_symbols = set(', ; . ! \\ldotp \\cdotp'.split())
    _overunder_symbols = set('\n       \\sum \\prod \\coprod \\bigcap \\bigcup \\bigsqcup \\bigvee\n       \\bigwedge \\bigodot \\bigotimes \\bigoplus \\biguplus\n       '.split())
    _overunder_functions = set('lim liminf limsup sup max min'.split())
    _dropsub_symbols = set('\\int \\oint \\iint \\oiint \\iiint \\oiiint \\iiiint'.split())
    _fontnames = set('rm cal it tt sf bf bfit default bb frak scr regular'.split())
    _function_names = set('\n      arccos csc ker min arcsin deg lg Pr arctan det lim sec arg dim\n      liminf sin cos exp limsup sinh cosh gcd ln sup cot hom log tan\n      coth inf max tanh'.split())
    _ambi_delims = set('\n      | \\| / \\backslash \\uparrow \\downarrow \\updownarrow \\Uparrow\n      \\Downarrow \\Updownarrow . \\vert \\Vert'.split())
    _left_delims = set('\n      ( [ \\{ < \\lfloor \\langle \\lceil \\lbrace \\leftbrace \\lbrack \\leftparen \\lgroup\n      '.split())
    _right_delims = set('\n      ) ] \\} > \\rfloor \\rangle \\rceil \\rbrace \\rightbrace \\rbrack \\rightparen \\rgroup\n      '.split())
    _delims = _left_delims | _right_delims | _ambi_delims
    _small_greek = set([unicodedata.name(chr(i)).split()[-1].lower() for i in range(ord('α'), ord('ω') + 1)])
    _latin_alphabets = set(string.ascii_letters)

    def __init__(self) -> None:
        p = types.SimpleNamespace()

        def set_names_and_parse_actions() -> None:
            for (key, val) in vars(p).items():
                if not key.startswith('_'):
                    if key not in ('token', 'placeable', 'auto_delim'):
                        val.setName(key)
                    if hasattr(self, key):
                        val.setParseAction(getattr(self, key))

        def csnames(group: str, names: Iterable[str]) -> Regex:
            ends_with_alpha = []
            ends_with_nonalpha = []
            for name in names:
                if name[-1].isalpha():
                    ends_with_alpha.append(name)
                else:
                    ends_with_nonalpha.append(name)
            return Regex('\\\\(?P<{group}>(?:{alpha})(?![A-Za-z]){additional}{nonalpha})'.format(group=group, alpha='|'.join(map(re.escape, ends_with_alpha)), additional='|' if ends_with_nonalpha else '', nonalpha='|'.join(map(re.escape, ends_with_nonalpha))))
        p.float_literal = Regex('[-+]?([0-9]+\\.?[0-9]*|\\.[0-9]+)')
        p.space = oneOf(self._space_widths)('space')
        p.style_literal = oneOf([str(e.value) for e in self._MathStyle])('style_literal')
        p.symbol = Regex("[a-zA-Z0-9 +\\-*/<>=:,.;!\\?&'@()\\[\\]|\\U00000080-\\U0001ffff]|\\\\[%${}\\[\\]_|]" + '|\\\\(?:{})(?![A-Za-z])'.format('|'.join(map(re.escape, tex2uni))))('sym').leaveWhitespace()
        p.unknown_symbol = Regex('\\\\[A-Za-z]+')('name')
        p.font = csnames('font', self._fontnames)
        p.start_group = Optional('\\math' + oneOf(self._fontnames)('font')) + '{'
        p.end_group = Literal('}')
        p.delim = oneOf(self._delims)
        p.auto_delim = Forward()
        p.placeable = Forward()
        p.named_placeable = Forward()
        p.required_group = Forward()
        p.optional_group = Forward()
        p.token = Forward()
        p.named_placeable <<= p.placeable
        set_names_and_parse_actions()
        p.optional_group <<= '{' + ZeroOrMore(p.token)('group') + '}'
        p.required_group <<= '{' + OneOrMore(p.token)('group') + '}'
        p.customspace = cmd('\\hspace', '{' + p.float_literal('space') + '}')
        p.accent = csnames('accent', [*self._accent_map, *self._wide_accents]) - p.named_placeable('sym')
        p.function = csnames('name', self._function_names)
        p.group = p.start_group + ZeroOrMore(p.token)('group') + p.end_group
        p.unclosed_group = p.start_group + ZeroOrMore(p.token)('group') + StringEnd()
        p.frac = cmd('\\frac', p.required_group('num') + p.required_group('den'))
        p.dfrac = cmd('\\dfrac', p.required_group('num') + p.required_group('den'))
        p.binom = cmd('\\binom', p.required_group('num') + p.required_group('den'))
        p.genfrac = cmd('\\genfrac', '{' + Optional(p.delim)('ldelim') + '}' + '{' + Optional(p.delim)('rdelim') + '}' + '{' + p.float_literal('rulesize') + '}' + '{' + Optional(p.style_literal)('style') + '}' + p.required_group('num') + p.required_group('den'))
        p.sqrt = cmd('\\sqrt{value}', Optional('[' + OneOrMore(NotAny(']') + p.token)('root') + ']') + p.required_group('value'))
        p.overline = cmd('\\overline', p.required_group('body'))
        p.overset = cmd('\\overset', p.optional_group('annotation') + p.optional_group('body'))
        p.underset = cmd('\\underset', p.optional_group('annotation') + p.optional_group('body'))
        p.text = cmd('\\text', QuotedString('{', '\\', endQuoteChar='}'))
        p.substack = cmd('\\substack', nested_expr(opener='{', closer='}', content=Group(OneOrMore(p.token)) + ZeroOrMore(Literal('\\\\').suppress()))('parts'))
        p.subsuper = Optional(p.placeable)('nucleus') + OneOrMore(oneOf(['_', '^']) - p.placeable)('subsuper') + Regex("'*")('apostrophes') | Regex("'+")('apostrophes') | p.named_placeable('nucleus') + Regex("'*")('apostrophes')
        p.simple = p.space | p.customspace | p.font | p.subsuper
        p.token <<= p.simple | p.auto_delim | p.unclosed_group | p.unknown_symbol
        p.operatorname = cmd('\\operatorname', '{' + ZeroOrMore(p.simple)('name') + '}')
        p.boldsymbol = cmd('\\boldsymbol', '{' + ZeroOrMore(p.simple)('value') + '}')
        p.placeable <<= p.accent | p.symbol | p.function | p.operatorname | p.group | p.frac | p.dfrac | p.binom | p.genfrac | p.overset | p.underset | p.sqrt | p.overline | p.text | p.boldsymbol | p.substack
        mdelim = '\\middle' - (p.delim('mdelim') | Error('Expected a delimiter'))
        p.auto_delim <<= '\\left' - (p.delim('left') | Error('Expected a delimiter')) + ZeroOrMore(p.simple | p.auto_delim | mdelim)('mid') + '\\right' - (p.delim('right') | Error('Expected a delimiter'))
        p.math = OneOrMore(p.token)
        p.math_string = QuotedString('$', '\\', unquoteResults=False)
        p.non_math = Regex('(?:(?:\\\\[$])|[^$])*').leaveWhitespace()
        p.main = p.non_math + ZeroOrMore(p.math_string + p.non_math) + StringEnd()
        set_names_and_parse_actions()
        self._expression = p.main
        self._math_expression = p.math
        self._in_subscript_or_superscript = False

    def parse(self, s: str, fonts_object: Fonts, fontsize: float, dpi: float) -> Hlist:
        self._state_stack = [ParserState(fonts_object, 'default', 'rm', fontsize, dpi)]
        self._em_width_cache: dict[tuple[str, float, float], float] = {}
        try:
            result = self._expression.parseString(s)
        except ParseBaseException as err:
            raise ValueError('\n' + ParseException.explain(err, 0)) from None
        self._state_stack = []
        self._in_subscript_or_superscript = False
        self._em_width_cache = {}
        ParserElement.resetCache()
        return T.cast(Hlist, result[0])

    def get_state(self) -> ParserState:
        return self._state_stack[-1]

    def pop_state(self) -> None:
        self._state_stack.pop()

    def push_state(self) -> None:
        self._state_stack.append(self.get_state().copy())

    def main(self, toks: ParseResults) -> list[Hlist]:
        return [Hlist(toks.asList())]

    def math_string(self, toks: ParseResults) -> ParseResults:
        return self._math_expression.parseString(toks[0][1:-1], parseAll=True)

    def math(self, toks: ParseResults) -> T.Any:
        hlist = Hlist(toks.asList())
        self.pop_state()
        return [hlist]

    def non_math(self, toks: ParseResults) -> T.Any:
        s = toks[0].replace('\\$', '$')
        symbols = [Char(c, self.get_state()) for c in s]
        hlist = Hlist(symbols)
        self.push_state()
        self.get_state().font = mpl.rcParams['mathtext.default']
        return [hlist]
    float_literal = staticmethod(pyparsing_common.convertToFloat)

    def text(self, toks: ParseResults) -> T.Any:
        self.push_state()
        state = self.get_state()
        state.font = 'rm'
        hlist = Hlist([Char(c, state) for c in toks[1]])
        self.pop_state()
        return [hlist]

    def _make_space(self, percentage: float) -> Kern:
        state = self.get_state()
        key = (state.font, state.fontsize, state.dpi)
        width = self._em_width_cache.get(key)
        if width is None:
            metrics = state.fontset.get_metrics('it', mpl.rcParams['mathtext.default'], 'm', state.fontsize, state.dpi)
            width = metrics.advance
            self._em_width_cache[key] = width
        return Kern(width * percentage)
    _space_widths = {'\\,': 0.16667, '\\thinspace': 0.16667, '\\/': 0.16667, '\\>': 0.22222, '\\:': 0.22222, '\\;': 0.27778, '\\ ': 0.33333, '~': 0.33333, '\\enspace': 0.5, '\\quad': 1, '\\qquad': 2, '\\!': -0.16667}

    def space(self, toks: ParseResults) -> T.Any:
        num = self._space_widths[toks['space']]
        box = self._make_space(num)
        return [box]

    def customspace(self, toks: ParseResults) -> T.Any:
        return [self._make_space(toks['space'])]

    def symbol(self, s: str, loc: int, toks: ParseResults | dict[str, str]) -> T.Any:
        c = toks['sym']
        if c == '-':
            c = '−'
        try:
            char = Char(c, self.get_state())
        except ValueError as err:
            raise ParseFatalException(s, loc, 'Unknown symbol: %s' % c) from err
        if c in self._spaced_symbols:
            prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
            if self._in_subscript_or_superscript or (c in self._binary_operators and (len(s[:loc].split()) == 0 or prev_char in {'{', *self._left_delims, *self._relation_symbols})):
                return [char]
            else:
                return [Hlist([self._make_space(0.2), char, self._make_space(0.2)], do_kern=True)]
        elif c in self._punctuation_symbols:
            prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
            next_char = next((c for c in s[loc + 1:] if c != ' '), '')
            if c == ',':
                if prev_char == '{' and next_char == '}':
                    return [char]
            if c == '.' and prev_char.isdigit() and next_char.isdigit():
                return [char]
            else:
                return [Hlist([char, self._make_space(0.2)], do_kern=True)]
        return [char]

    def unknown_symbol(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        raise ParseFatalException(s, loc, f"Unknown symbol: {toks['name']}")
    _accent_map = {'hat': '\\circumflexaccent', 'breve': '\\combiningbreve', 'bar': '\\combiningoverline', 'grave': '\\combininggraveaccent', 'acute': '\\combiningacuteaccent', 'tilde': '\\combiningtilde', 'dot': '\\combiningdotabove', 'ddot': '\\combiningdiaeresis', 'dddot': '\\combiningthreedotsabove', 'ddddot': '\\combiningfourdotsabove', 'vec': '\\combiningrightarrowabove', '"': '\\combiningdiaeresis', '`': '\\combininggraveaccent', "'": '\\combiningacuteaccent', '~': '\\combiningtilde', '.': '\\combiningdotabove', '^': '\\circumflexaccent', 'overrightarrow': '\\rightarrow', 'overleftarrow': '\\leftarrow', 'mathring': '\\circ'}
    _wide_accents = set('widehat widetilde widebar'.split())

    def accent(self, toks: ParseResults) -> T.Any:
        state = self.get_state()
        thickness = state.get_current_underline_thickness()
        accent = toks['accent']
        sym = toks['sym']
        accent_box: Node
        if accent in self._wide_accents:
            accent_box = AutoWidthChar('\\' + accent, sym.width, state, char_class=Accent)
        else:
            accent_box = Accent(self._accent_map[accent], state)
        if accent == 'mathring':
            accent_box.shrink()
            accent_box.shrink()
        centered = HCentered([Hbox(sym.width / 4.0), accent_box])
        centered.hpack(sym.width, 'exactly')
        return Vlist([centered, Vbox(0.0, thickness * 2.0), Hlist([sym])])

    def function(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        hlist = self.operatorname(s, loc, toks)
        hlist.function_name = toks['name']
        return hlist

    def operatorname(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        self.push_state()
        state = self.get_state()
        state.font = 'rm'
        hlist_list: list[Node] = []
        name = toks['name']
        for c in name:
            if isinstance(c, Char):
                c.font = 'rm'
                c._update_metrics()
                hlist_list.append(c)
            elif isinstance(c, str):
                hlist_list.append(Char(c, state))
            else:
                hlist_list.append(c)
        next_char_loc = loc + len(name) + 1
        if isinstance(name, ParseResults):
            next_char_loc += len('operatorname{}')
        next_char = next((c for c in s[next_char_loc:] if c != ' '), '')
        delimiters = self._delims | {'^', '_'}
        if next_char not in delimiters and name not in self._overunder_functions:
            hlist_list += [self._make_space(self._space_widths['\\,'])]
        self.pop_state()
        if next_char in {'^', '_'}:
            self._in_subscript_or_superscript = True
        else:
            self._in_subscript_or_superscript = False
        return Hlist(hlist_list)

    def start_group(self, toks: ParseResults) -> T.Any:
        self.push_state()
        if toks.get('font'):
            self.get_state().font = toks.get('font')
        return []

    def group(self, toks: ParseResults) -> T.Any:
        grp = Hlist(toks.get('group', []))
        return [grp]

    def required_group(self, toks: ParseResults) -> T.Any:
        return Hlist(toks.get('group', []))
    optional_group = required_group

    def end_group(self) -> T.Any:
        self.pop_state()
        return []

    def unclosed_group(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        raise ParseFatalException(s, len(s), "Expected '}'")

    def font(self, toks: ParseResults) -> T.Any:
        self.get_state().font = toks['font']
        return []

    def is_overunder(self, nucleus: Node) -> bool:
        if isinstance(nucleus, Char):
            return nucleus.c in self._overunder_symbols
        elif isinstance(nucleus, Hlist) and hasattr(nucleus, 'function_name'):
            return nucleus.function_name in self._overunder_functions
        return False

    def is_dropsub(self, nucleus: Node) -> bool:
        if isinstance(nucleus, Char):
            return nucleus.c in self._dropsub_symbols
        return False

    def is_slanted(self, nucleus: Node) -> bool:
        if isinstance(nucleus, Char):
            return nucleus.is_slanted()
        return False

    def subsuper(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        nucleus = toks.get('nucleus', Hbox(0))
        subsuper = toks.get('subsuper', [])
        napostrophes = len(toks.get('apostrophes', []))
        if not subsuper and (not napostrophes):
            return nucleus
        sub = super = None
        while subsuper:
            (op, arg, *subsuper) = subsuper
            if op == '_':
                if sub is not None:
                    raise ParseFatalException('Double subscript')
                sub = arg
            else:
                if super is not None:
                    raise ParseFatalException('Double superscript')
                super = arg
        state = self.get_state()
        rule_thickness = state.fontset.get_underline_thickness(state.font, state.fontsize, state.dpi)
        xHeight = state.fontset.get_xheight(state.font, state.fontsize, state.dpi)
        if napostrophes:
            if super is None:
                super = Hlist([])
            for i in range(napostrophes):
                super.children.extend(self.symbol(s, loc, {'sym': '\\prime'}))
            super.kern()
            super.hpack()
        if self.is_overunder(nucleus):
            vlist = []
            shift = 0.0
            width = nucleus.width
            if super is not None:
                super.shrink()
                width = max(width, super.width)
            if sub is not None:
                sub.shrink()
                width = max(width, sub.width)
            vgap = rule_thickness * 3.0
            if super is not None:
                hlist = HCentered([super])
                hlist.hpack(width, 'exactly')
                vlist.extend([hlist, Vbox(0, vgap)])
            hlist = HCentered([nucleus])
            hlist.hpack(width, 'exactly')
            vlist.append(hlist)
            if sub is not None:
                hlist = HCentered([sub])
                hlist.hpack(width, 'exactly')
                vlist.extend([Vbox(0, vgap), hlist])
                shift = hlist.height + vgap + nucleus.depth
            vlt = Vlist(vlist)
            vlt.shift_amount = shift
            result = Hlist([vlt])
            return [result]
        last_char = nucleus
        if isinstance(nucleus, Hlist):
            new_children = nucleus.children
            if len(new_children):
                if isinstance(new_children[-1], Kern) and hasattr(new_children[-2], '_metrics'):
                    new_children = new_children[:-1]
                last_char = new_children[-1]
                if hasattr(last_char, '_metrics'):
                    last_char.width = last_char._metrics.advance
            nucleus = Hlist(new_children, do_kern=False)
        else:
            if isinstance(nucleus, Char):
                last_char.width = last_char._metrics.advance
            nucleus = Hlist([nucleus])
        constants = _get_font_constant_set(state)
        lc_height = last_char.height
        lc_baseline = 0
        if self.is_dropsub(last_char):
            lc_baseline = last_char.depth
        superkern = constants.delta * xHeight
        subkern = constants.delta * xHeight
        if self.is_slanted(last_char):
            superkern += constants.delta * xHeight
            superkern += constants.delta_slanted * (lc_height - xHeight * 2.0 / 3.0)
            if self.is_dropsub(last_char):
                subkern = (3 * constants.delta - constants.delta_integral) * lc_height
                superkern = (3 * constants.delta + constants.delta_integral) * lc_height
            else:
                subkern = 0
        x: List
        if super is None:
            x = Hlist([Kern(subkern), T.cast(Node, sub)])
            x.shrink()
            if self.is_dropsub(last_char):
                shift_down = lc_baseline + constants.subdrop * xHeight
            else:
                shift_down = constants.sub1 * xHeight
            x.shift_amount = shift_down
        else:
            x = Hlist([Kern(superkern), super])
            x.shrink()
            if self.is_dropsub(last_char):
                shift_up = lc_height - constants.subdrop * xHeight
            else:
                shift_up = constants.sup1 * xHeight
            if sub is None:
                x.shift_amount = -shift_up
            else:
                y = Hlist([Kern(subkern), sub])
                y.shrink()
                if self.is_dropsub(last_char):
                    shift_down = lc_baseline + constants.subdrop * xHeight
                else:
                    shift_down = constants.sub2 * xHeight
                clr = 2.0 * rule_thickness - (shift_up - x.depth - (y.height - shift_down))
                if clr > 0.0:
                    shift_up += clr
                x = Vlist([x, Kern(shift_up - x.depth - (y.height - shift_down)), y])
                x.shift_amount = shift_down
        if not self.is_dropsub(last_char):
            x.width += constants.script_space * xHeight
        spaced_nucleus = [nucleus, x]
        if self._in_subscript_or_superscript:
            spaced_nucleus += [self._make_space(self._space_widths['\\,'])]
            self._in_subscript_or_superscript = False
        result = Hlist(spaced_nucleus)
        return [result]

    def _genfrac(self, ldelim: str, rdelim: str, rule: float | None, style: _MathStyle, num: Hlist, den: Hlist) -> T.Any:
        state = self.get_state()
        thickness = state.get_current_underline_thickness()
        for _ in range(style.value):
            num.shrink()
            den.shrink()
        cnum = HCentered([num])
        cden = HCentered([den])
        width = max(num.width, den.width)
        cnum.hpack(width, 'exactly')
        cden.hpack(width, 'exactly')
        vlist = Vlist([cnum, Vbox(0, thickness * 2.0), Hrule(state, rule), Vbox(0, thickness * 2.0), cden])
        metrics = state.fontset.get_metrics(state.font, mpl.rcParams['mathtext.default'], '=', state.fontsize, state.dpi)
        shift = cden.height - ((metrics.ymax + metrics.ymin) / 2 - thickness * 3.0)
        vlist.shift_amount = shift
        result = [Hlist([vlist, Hbox(thickness * 2.0)])]
        if ldelim or rdelim:
            if ldelim == '':
                ldelim = '.'
            if rdelim == '':
                rdelim = '.'
            return self._auto_sized_delimiter(ldelim, T.cast(list[Box | Char | str], result), rdelim)
        return result

    def style_literal(self, toks: ParseResults) -> T.Any:
        return self._MathStyle(int(toks['style_literal']))

    def genfrac(self, toks: ParseResults) -> T.Any:
        return self._genfrac(toks.get('ldelim', ''), toks.get('rdelim', ''), toks['rulesize'], toks.get('style', self._MathStyle.TEXTSTYLE), toks['num'], toks['den'])

    def frac(self, toks: ParseResults) -> T.Any:
        return self._genfrac('', '', self.get_state().get_current_underline_thickness(), self._MathStyle.TEXTSTYLE, toks['num'], toks['den'])

    def dfrac(self, toks: ParseResults) -> T.Any:
        return self._genfrac('', '', self.get_state().get_current_underline_thickness(), self._MathStyle.DISPLAYSTYLE, toks['num'], toks['den'])

    def binom(self, toks: ParseResults) -> T.Any:
        return self._genfrac('(', ')', 0, self._MathStyle.TEXTSTYLE, toks['num'], toks['den'])

    def _genset(self, s: str, loc: int, toks: ParseResults) -> T.Any:
        annotation = toks['annotation']
        body = toks['body']
        thickness = self.get_state().get_current_underline_thickness()
        annotation.shrink()
        centered_annotation = HCentered([annotation])
        centered_body = HCentered([body])
        width = max(centered_annotation.width, centered_body.width)
        centered_annotation.hpack(width, 'exactly')
        centered_body.hpack(width, 'exactly')
        vgap = thickness * 3
        if s[loc + 1] == 'u':
            vlist = Vlist([centered_body, Vbox(0, vgap), centered_annotation])
            vlist.shift_amount = centered_body.depth + centered_annotation.height + vgap
        else:
            vlist = Vlist([centered_annotation, Vbox(0, vgap), centered_body])
        return vlist
    overset = underset = _genset

    def sqrt(self, toks: ParseResults) -> T.Any:
        root = toks.get('root')
        body = toks['value']
        state = self.get_state()
        thickness = state.get_current_underline_thickness()
        height = body.height - body.shift_amount + thickness * 5.0
        depth = body.depth + body.shift_amount
        check = AutoHeightChar('\\__sqrt__', height, depth, state, always=True)
        height = check.height - check.shift_amount
        depth = check.depth + check.shift_amount
        padded_body = Hlist([Hbox(2 * thickness), body, Hbox(2 * thickness)])
        rightside = Vlist([Hrule(state), Glue('fill'), padded_body])
        rightside.vpack(height + state.fontsize * state.dpi / (100.0 * 12.0), 'exactly', depth)
        if not root:
            root = Box(check.width * 0.5, 0.0, 0.0)
        else:
            root = Hlist(root)
            root.shrink()
            root.shrink()
        root_vlist = Vlist([Hlist([root])])
        root_vlist.shift_amount = -height * 0.6
        hlist = Hlist([root_vlist, Kern(-check.width * 0.5), check, rightside])
        return [hlist]

    def overline(self, toks: ParseResults) -> T.Any:
        body = toks['body']
        state = self.get_state()
        thickness = state.get_current_underline_thickness()
        height = body.height - body.shift_amount + thickness * 3.0
        depth = body.depth + body.shift_amount
        rightside = Vlist([Hrule(state), Glue('fill'), Hlist([body])])
        rightside.vpack(height + state.fontsize * state.dpi / (100.0 * 12.0), 'exactly', depth)
        hlist = Hlist([rightside])
        return [hlist]

    def _auto_sized_delimiter(self, front: str, middle: list[Box | Char | str], back: str) -> T.Any:
        state = self.get_state()
        if len(middle):
            height = max([x.height for x in middle if not isinstance(x, str)])
            depth = max([x.depth for x in middle if not isinstance(x, str)])
            factor = None
            for (idx, el) in enumerate(middle):
                if el == '\\middle':
                    c = T.cast(str, middle[idx + 1])
                    if c != '.':
                        middle[idx + 1] = AutoHeightChar(c, height, depth, state, factor=factor)
                    else:
                        middle.remove(c)
                    del middle[idx]
            middle_part = T.cast(list[Box | Char], middle)
        else:
            height = 0
            depth = 0
            factor = 1.0
            middle_part = []
        parts: list[Node] = []
        if front != '.':
            parts.append(AutoHeightChar(front, height, depth, state, factor=factor))
        parts.extend(middle_part)
        if back != '.':
            parts.append(AutoHeightChar(back, height, depth, state, factor=factor))
        hlist = Hlist(parts)
        return hlist

    def auto_delim(self, toks: ParseResults) -> T.Any:
        return self._auto_sized_delimiter(toks['left'], toks['mid'].asList() if 'mid' in toks else [], toks['right'])

    def boldsymbol(self, toks: ParseResults) -> T.Any:
        self.push_state()
        state = self.get_state()
        hlist: list[Node] = []
        name = toks['value']
        for c in name:
            if isinstance(c, Hlist):
                k = c.children[1]
                if isinstance(k, Char):
                    k.font = 'bf'
                    k._update_metrics()
                hlist.append(c)
            elif isinstance(c, Char):
                c.font = 'bf'
                if c.c in self._latin_alphabets or c.c[1:] in self._small_greek:
                    c.font = 'bfit'
                    c._update_metrics()
                c._update_metrics()
                hlist.append(c)
            else:
                hlist.append(c)
        self.pop_state()
        return Hlist(hlist)

    def substack(self, toks: ParseResults) -> T.Any:
        parts = toks['parts']
        state = self.get_state()
        thickness = state.get_current_underline_thickness()
        hlist = [Hlist(k) for k in parts[0]]
        max_width = max(map(lambda c: c.width, hlist))
        vlist = []
        for sub in hlist:
            cp = HCentered([sub])
            cp.hpack(max_width, 'exactly')
            vlist.append(cp)
        stack = [val for pair in zip(vlist, [Vbox(0, thickness * 2)] * len(vlist)) for val in pair]
        del stack[-1]
        vlt = Vlist(stack)
        result = [Hlist([vlt])]
        return result

# File: matplotlib-main/lib/matplotlib/_mathtext_data.py
""""""
from __future__ import annotations
from typing import overload
latex_to_bakoma = {'\\__sqrt__': ('cmex10', 112), '\\bigcap': ('cmex10', 92), '\\bigcup': ('cmex10', 91), '\\bigodot': ('cmex10', 75), '\\bigoplus': ('cmex10', 77), '\\bigotimes': ('cmex10', 79), '\\biguplus': ('cmex10', 93), '\\bigvee': ('cmex10', 95), '\\bigwedge': ('cmex10', 94), '\\coprod': ('cmex10', 97), '\\int': ('cmex10', 90), '\\langle': ('cmex10', 173), '\\leftangle': ('cmex10', 173), '\\leftbrace': ('cmex10', 169), '\\oint': ('cmex10', 73), '\\prod': ('cmex10', 89), '\\rangle': ('cmex10', 174), '\\rightangle': ('cmex10', 174), '\\rightbrace': ('cmex10', 170), '\\sum': ('cmex10', 88), '\\widehat': ('cmex10', 98), '\\widetilde': ('cmex10', 101), '\\{': ('cmex10', 169), '\\}': ('cmex10', 170), '{': ('cmex10', 169), '}': ('cmex10', 170), ',': ('cmmi10', 59), '.': ('cmmi10', 58), '/': ('cmmi10', 61), '<': ('cmmi10', 60), '>': ('cmmi10', 62), '\\alpha': ('cmmi10', 174), '\\beta': ('cmmi10', 175), '\\chi': ('cmmi10', 194), '\\combiningrightarrowabove': ('cmmi10', 126), '\\delta': ('cmmi10', 177), '\\ell': ('cmmi10', 96), '\\epsilon': ('cmmi10', 178), '\\eta': ('cmmi10', 180), '\\flat': ('cmmi10', 91), '\\frown': ('cmmi10', 95), '\\gamma': ('cmmi10', 176), '\\imath': ('cmmi10', 123), '\\iota': ('cmmi10', 182), '\\jmath': ('cmmi10', 124), '\\kappa': ('cmmi10', 8729), '\\lambda': ('cmmi10', 184), '\\leftharpoondown': ('cmmi10', 41), '\\leftharpoonup': ('cmmi10', 40), '\\mu': ('cmmi10', 185), '\\natural': ('cmmi10', 92), '\\nu': ('cmmi10', 186), '\\omega': ('cmmi10', 33), '\\phi': ('cmmi10', 193), '\\pi': ('cmmi10', 188), '\\psi': ('cmmi10', 195), '\\rho': ('cmmi10', 189), '\\rightharpoondown': ('cmmi10', 43), '\\rightharpoonup': ('cmmi10', 42), '\\sharp': ('cmmi10', 93), '\\sigma': ('cmmi10', 190), '\\smile': ('cmmi10', 94), '\\tau': ('cmmi10', 191), '\\theta': ('cmmi10', 181), '\\triangleleft': ('cmmi10', 47), '\\triangleright': ('cmmi10', 46), '\\upsilon': ('cmmi10', 192), '\\varepsilon': ('cmmi10', 34), '\\varphi': ('cmmi10', 39), '\\varrho': ('cmmi10', 37), '\\varsigma': ('cmmi10', 38), '\\vartheta': ('cmmi10', 35), '\\wp': ('cmmi10', 125), '\\xi': ('cmmi10', 187), '\\zeta': ('cmmi10', 179), '!': ('cmr10', 33), '%': ('cmr10', 37), '&': ('cmr10', 38), '(': ('cmr10', 40), ')': ('cmr10', 41), '+': ('cmr10', 43), '0': ('cmr10', 48), '1': ('cmr10', 49), '2': ('cmr10', 50), '3': ('cmr10', 51), '4': ('cmr10', 52), '5': ('cmr10', 53), '6': ('cmr10', 54), '7': ('cmr10', 55), '8': ('cmr10', 56), '9': ('cmr10', 57), ':': ('cmr10', 58), ';': ('cmr10', 59), '=': ('cmr10', 61), '?': ('cmr10', 63), '@': ('cmr10', 64), '[': ('cmr10', 91), '\\#': ('cmr10', 35), '\\$': ('cmr10', 36), '\\%': ('cmr10', 37), '\\Delta': ('cmr10', 162), '\\Gamma': ('cmr10', 161), '\\Lambda': ('cmr10', 164), '\\Omega': ('cmr10', 173), '\\Phi': ('cmr10', 169), '\\Pi': ('cmr10', 166), '\\Psi': ('cmr10', 170), '\\Sigma': ('cmr10', 167), '\\Theta': ('cmr10', 163), '\\Upsilon': ('cmr10', 168), '\\Xi': ('cmr10', 165), '\\circumflexaccent': ('cmr10', 94), '\\combiningacuteaccent': ('cmr10', 182), '\\combiningbreve': ('cmr10', 184), '\\combiningdiaeresis': ('cmr10', 196), '\\combiningdotabove': ('cmr10', 95), '\\combininggraveaccent': ('cmr10', 181), '\\combiningoverline': ('cmr10', 185), '\\combiningtilde': ('cmr10', 126), '\\leftbracket': ('cmr10', 91), '\\leftparen': ('cmr10', 40), '\\rightbracket': ('cmr10', 93), '\\rightparen': ('cmr10', 41), '\\widebar': ('cmr10', 185), ']': ('cmr10', 93), '*': ('cmsy10', 164), '−': ('cmsy10', 161), '\\Downarrow': ('cmsy10', 43), '\\Im': ('cmsy10', 61), '\\Leftarrow': ('cmsy10', 40), '\\Leftrightarrow': ('cmsy10', 44), '\\P': ('cmsy10', 123), '\\Re': ('cmsy10', 60), '\\Rightarrow': ('cmsy10', 41), '\\S': ('cmsy10', 120), '\\Uparrow': ('cmsy10', 42), '\\Updownarrow': ('cmsy10', 109), '\\Vert': ('cmsy10', 107), '\\aleph': ('cmsy10', 64), '\\approx': ('cmsy10', 188), '\\ast': ('cmsy10', 164), '\\asymp': ('cmsy10', 179), '\\backslash': ('cmsy10', 110), '\\bigcirc': ('cmsy10', 176), '\\bigtriangledown': ('cmsy10', 53), '\\bigtriangleup': ('cmsy10', 52), '\\bot': ('cmsy10', 63), '\\bullet': ('cmsy10', 178), '\\cap': ('cmsy10', 92), '\\cdot': ('cmsy10', 162), '\\circ': ('cmsy10', 177), '\\clubsuit': ('cmsy10', 124), '\\cup': ('cmsy10', 91), '\\dag': ('cmsy10', 121), '\\dashv': ('cmsy10', 97), '\\ddag': ('cmsy10', 122), '\\diamond': ('cmsy10', 166), '\\diamondsuit': ('cmsy10', 125), '\\div': ('cmsy10', 165), '\\downarrow': ('cmsy10', 35), '\\emptyset': ('cmsy10', 59), '\\equiv': ('cmsy10', 180), '\\exists': ('cmsy10', 57), '\\forall': ('cmsy10', 56), '\\geq': ('cmsy10', 184), '\\gg': ('cmsy10', 192), '\\heartsuit': ('cmsy10', 126), '\\in': ('cmsy10', 50), '\\infty': ('cmsy10', 49), '\\lbrace': ('cmsy10', 102), '\\lceil': ('cmsy10', 100), '\\leftarrow': ('cmsy10', 195), '\\leftrightarrow': ('cmsy10', 36), '\\leq': ('cmsy10', 8729), '\\lfloor': ('cmsy10', 98), '\\ll': ('cmsy10', 191), '\\mid': ('cmsy10', 106), '\\mp': ('cmsy10', 168), '\\nabla': ('cmsy10', 114), '\\nearrow': ('cmsy10', 37), '\\neg': ('cmsy10', 58), '\\ni': ('cmsy10', 51), '\\nwarrow': ('cmsy10', 45), '\\odot': ('cmsy10', 175), '\\ominus': ('cmsy10', 170), '\\oplus': ('cmsy10', 169), '\\oslash': ('cmsy10', 174), '\\otimes': ('cmsy10', 173), '\\pm': ('cmsy10', 167), '\\prec': ('cmsy10', 193), '\\preceq': ('cmsy10', 185), '\\prime': ('cmsy10', 48), '\\propto': ('cmsy10', 47), '\\rbrace': ('cmsy10', 103), '\\rceil': ('cmsy10', 101), '\\rfloor': ('cmsy10', 99), '\\rightarrow': ('cmsy10', 33), '\\searrow': ('cmsy10', 38), '\\sim': ('cmsy10', 187), '\\simeq': ('cmsy10', 39), '\\slash': ('cmsy10', 54), '\\spadesuit': ('cmsy10', 196), '\\sqcap': ('cmsy10', 117), '\\sqcup': ('cmsy10', 116), '\\sqsubseteq': ('cmsy10', 118), '\\sqsupseteq': ('cmsy10', 119), '\\subset': ('cmsy10', 189), '\\subseteq': ('cmsy10', 181), '\\succ': ('cmsy10', 194), '\\succeq': ('cmsy10', 186), '\\supset': ('cmsy10', 190), '\\supseteq': ('cmsy10', 182), '\\swarrow': ('cmsy10', 46), '\\times': ('cmsy10', 163), '\\to': ('cmsy10', 33), '\\top': ('cmsy10', 62), '\\uparrow': ('cmsy10', 34), '\\updownarrow': ('cmsy10', 108), '\\uplus': ('cmsy10', 93), '\\vdash': ('cmsy10', 96), '\\vee': ('cmsy10', 95), '\\vert': ('cmsy10', 106), '\\wedge': ('cmsy10', 94), '\\wr': ('cmsy10', 111), '\\|': ('cmsy10', 107), '|': ('cmsy10', 106), '\\_': ('cmtt10', 95)}
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()}
tex2uni = {'#': 35, '$': 36, '%': 37, 'AA': 197, 'AE': 198, 'BbbC': 8450, 'BbbN': 8469, 'BbbP': 8473, 'BbbQ': 8474, 'BbbR': 8477, 'BbbZ': 8484, 'Bumpeq': 8782, 'Cap': 8914, 'Colon': 8759, 'Cup': 8915, 'DH': 208, 'Delta': 916, 'Doteq': 8785, 'Downarrow': 8659, 'Equiv': 8803, 'Finv': 8498, 'Game': 8513, 'Gamma': 915, 'H': 779, 'Im': 8465, 'Join': 10781, 'L': 321, 'Lambda': 923, 'Ldsh': 8626, 'Leftarrow': 8656, 'Leftrightarrow': 8660, 'Lleftarrow': 8666, 'Longleftarrow': 10232, 'Longleftrightarrow': 10234, 'Longrightarrow': 10233, 'Lsh': 8624, 'Nearrow': 8663, 'Nwarrow': 8662, 'O': 216, 'OE': 338, 'Omega': 937, 'P': 182, 'Phi': 934, 'Pi': 928, 'Psi': 936, 'QED': 8718, 'Rdsh': 8627, 'Re': 8476, 'Rightarrow': 8658, 'Rrightarrow': 8667, 'Rsh': 8625, 'S': 167, 'Searrow': 8664, 'Sigma': 931, 'Subset': 8912, 'Supset': 8913, 'Swarrow': 8665, 'Theta': 920, 'Thorn': 222, 'Uparrow': 8657, 'Updownarrow': 8661, 'Upsilon': 933, 'Vdash': 8873, 'Vert': 8214, 'Vvdash': 8874, 'Xi': 926, '_': 95, '__sqrt__': 8730, 'aa': 229, 'ac': 8766, 'acute': 769, 'acwopencirclearrow': 8634, 'adots': 8944, 'ae': 230, 'aleph': 8501, 'alpha': 945, 'amalg': 10815, 'angle': 8736, 'approx': 8776, 'approxeq': 8778, 'approxident': 8779, 'arceq': 8792, 'ast': 8727, 'asterisk': 42, 'asymp': 8781, 'backcong': 8780, 'backepsilon': 1014, 'backprime': 8245, 'backsim': 8765, 'backsimeq': 8909, 'backslash': 92, 'bagmember': 8959, 'bar': 772, 'barleftarrow': 8676, 'barvee': 8893, 'barwedge': 8892, 'because': 8757, 'beta': 946, 'beth': 8502, 'between': 8812, 'bigcap': 8898, 'bigcirc': 9675, 'bigcup': 8899, 'bigodot': 10752, 'bigoplus': 10753, 'bigotimes': 10754, 'bigsqcup': 10758, 'bigstar': 9733, 'bigtriangledown': 9661, 'bigtriangleup': 9651, 'biguplus': 10756, 'bigvee': 8897, 'bigwedge': 8896, 'blacksquare': 9632, 'blacktriangle': 9652, 'blacktriangledown': 9662, 'blacktriangleleft': 9664, 'blacktriangleright': 9654, 'bot': 8869, 'bowtie': 8904, 'boxbar': 9707, 'boxdot': 8865, 'boxminus': 8863, 'boxplus': 8862, 'boxtimes': 8864, 'breve': 774, 'bullet': 8729, 'bumpeq': 8783, 'c': 807, 'candra': 784, 'cap': 8745, 'carriagereturn': 8629, 'cdot': 8901, 'cdotp': 183, 'cdots': 8943, 'cent': 162, 'check': 780, 'checkmark': 10003, 'chi': 967, 'circ': 8728, 'circeq': 8791, 'circlearrowleft': 8634, 'circlearrowright': 8635, 'circledR': 174, 'circledS': 9416, 'circledast': 8859, 'circledcirc': 8858, 'circleddash': 8861, 'circumflexaccent': 770, 'clubsuit': 9827, 'clubsuitopen': 9831, 'colon': 58, 'coloneq': 8788, 'combiningacuteaccent': 769, 'combiningbreve': 774, 'combiningdiaeresis': 776, 'combiningdotabove': 775, 'combiningfourdotsabove': 8412, 'combininggraveaccent': 768, 'combiningoverline': 772, 'combiningrightarrowabove': 8407, 'combiningthreedotsabove': 8411, 'combiningtilde': 771, 'complement': 8705, 'cong': 8773, 'coprod': 8720, 'copyright': 169, 'cup': 8746, 'cupdot': 8845, 'cupleftarrow': 8844, 'curlyeqprec': 8926, 'curlyeqsucc': 8927, 'curlyvee': 8910, 'curlywedge': 8911, 'curvearrowleft': 8630, 'curvearrowright': 8631, 'cwopencirclearrow': 8635, 'd': 803, 'dag': 8224, 'dagger': 8224, 'daleth': 8504, 'danger': 9761, 'dashleftarrow': 10510, 'dashrightarrow': 10511, 'dashv': 8867, 'ddag': 8225, 'ddagger': 8225, 'ddddot': 8412, 'dddot': 8411, 'ddot': 776, 'ddots': 8945, 'degree': 176, 'delta': 948, 'dh': 240, 'diamond': 8900, 'diamondsuit': 9826, 'digamma': 989, 'disin': 8946, 'div': 247, 'divideontimes': 8903, 'dot': 775, 'doteq': 8784, 'doteqdot': 8785, 'dotminus': 8760, 'dotplus': 8724, 'dots': 8230, 'dotsminusdots': 8762, 'doublebarwedge': 8966, 'downarrow': 8595, 'downdownarrows': 8650, 'downharpoonleft': 8643, 'downharpoonright': 8642, 'downzigzagarrow': 8623, 'ell': 8467, 'emdash': 8212, 'emptyset': 8709, 'endash': 8211, 'epsilon': 949, 'eqcirc': 8790, 'eqcolon': 8789, 'eqdef': 8797, 'eqgtr': 8925, 'eqless': 8924, 'eqsim': 8770, 'eqslantgtr': 10902, 'eqslantless': 10901, 'equal': 61, 'equalparallel': 8917, 'equiv': 8801, 'eta': 951, 'eth': 240, 'exists': 8707, 'fallingdotseq': 8786, 'flat': 9837, 'forall': 8704, 'frakC': 8493, 'frakZ': 8488, 'frown': 8994, 'gamma': 947, 'geq': 8805, 'geqq': 8807, 'geqslant': 10878, 'gg': 8811, 'ggg': 8921, 'gimel': 8503, 'gnapprox': 10890, 'gneqq': 8809, 'gnsim': 8935, 'grave': 768, 'greater': 62, 'gtrapprox': 10886, 'gtrdot': 8919, 'gtreqless': 8923, 'gtreqqless': 10892, 'gtrless': 8823, 'gtrsim': 8819, 'guillemotleft': 171, 'guillemotright': 187, 'guilsinglleft': 8249, 'guilsinglright': 8250, 'hat': 770, 'hbar': 295, 'heartsuit': 9825, 'hermitmatrix': 8889, 'hookleftarrow': 8617, 'hookrightarrow': 8618, 'hslash': 8463, 'i': 305, 'iiiint': 10764, 'iiint': 8749, 'iint': 8748, 'imageof': 8887, 'imath': 305, 'in': 8712, 'increment': 8710, 'infty': 8734, 'int': 8747, 'intercal': 8890, 'invnot': 8976, 'iota': 953, 'isinE': 8953, 'isindot': 8949, 'isinobar': 8951, 'isins': 8948, 'isinvb': 8952, 'jmath': 567, 'k': 808, 'kappa': 954, 'kernelcontraction': 8763, 'l': 322, 'lambda': 955, 'lambdabar': 411, 'langle': 10216, 'lasp': 701, 'lbrace': 123, 'lbrack': 91, 'lceil': 8968, 'ldots': 8230, 'leadsto': 8669, 'leftarrow': 8592, 'leftarrowtail': 8610, 'leftbrace': 123, 'leftharpoonaccent': 8400, 'leftharpoondown': 8637, 'leftharpoonup': 8636, 'leftleftarrows': 8647, 'leftparen': 40, 'leftrightarrow': 8596, 'leftrightarrows': 8646, 'leftrightharpoons': 8651, 'leftrightsquigarrow': 8621, 'leftsquigarrow': 8604, 'leftthreetimes': 8907, 'leq': 8804, 'leqq': 8806, 'leqslant': 10877, 'less': 60, 'lessapprox': 10885, 'lessdot': 8918, 'lesseqgtr': 8922, 'lesseqqgtr': 10891, 'lessgtr': 8822, 'lesssim': 8818, 'lfloor': 8970, 'lgroup': 10222, 'lhd': 9665, 'll': 8810, 'llcorner': 8990, 'lll': 8920, 'lnapprox': 10889, 'lneqq': 8808, 'lnsim': 8934, 'longleftarrow': 10229, 'longleftrightarrow': 10231, 'longmapsto': 10236, 'longrightarrow': 10230, 'looparrowleft': 8619, 'looparrowright': 8620, 'lq': 8216, 'lrcorner': 8991, 'ltimes': 8905, 'macron': 175, 'maltese': 10016, 'mapsdown': 8615, 'mapsfrom': 8612, 'mapsto': 8614, 'mapsup': 8613, 'measeq': 8798, 'measuredangle': 8737, 'measuredrightangle': 8894, 'merge': 10837, 'mho': 8487, 'mid': 8739, 'minus': 8722, 'minuscolon': 8761, 'models': 8871, 'mp': 8723, 'mu': 956, 'multimap': 8888, 'nLeftarrow': 8653, 'nLeftrightarrow': 8654, 'nRightarrow': 8655, 'nVDash': 8879, 'nVdash': 8878, 'nabla': 8711, 'napprox': 8777, 'natural': 9838, 'ncong': 8775, 'ne': 8800, 'nearrow': 8599, 'neg': 172, 'neq': 8800, 'nequiv': 8802, 'nexists': 8708, 'ngeq': 8817, 'ngtr': 8815, 'ngtrless': 8825, 'ngtrsim': 8821, 'ni': 8715, 'niobar': 8958, 'nis': 8956, 'nisd': 8954, 'nleftarrow': 8602, 'nleftrightarrow': 8622, 'nleq': 8816, 'nless': 8814, 'nlessgtr': 8824, 'nlesssim': 8820, 'nmid': 8740, 'not': 824, 'notin': 8713, 'notsmallowns': 8716, 'nparallel': 8742, 'nprec': 8832, 'npreccurlyeq': 8928, 'nrightarrow': 8603, 'nsim': 8769, 'nsimeq': 8772, 'nsqsubseteq': 8930, 'nsqsupseteq': 8931, 'nsubset': 8836, 'nsubseteq': 8840, 'nsucc': 8833, 'nsucccurlyeq': 8929, 'nsupset': 8837, 'nsupseteq': 8841, 'ntriangleleft': 8938, 'ntrianglelefteq': 8940, 'ntriangleright': 8939, 'ntrianglerighteq': 8941, 'nu': 957, 'nvDash': 8877, 'nvdash': 8876, 'nwarrow': 8598, 'o': 248, 'obar': 9021, 'ocirc': 778, 'odot': 8857, 'oe': 339, 'oequal': 8860, 'oiiint': 8752, 'oiint': 8751, 'oint': 8750, 'omega': 969, 'ominus': 8854, 'oplus': 8853, 'origof': 8886, 'oslash': 8856, 'otimes': 8855, 'overarc': 785, 'overleftarrow': 8406, 'overleftrightarrow': 8417, 'parallel': 8741, 'partial': 8706, 'perp': 10178, 'perthousand': 8240, 'phi': 981, 'pi': 960, 'pitchfork': 8916, 'plus': 43, 'pm': 177, 'prec': 8826, 'precapprox': 10935, 'preccurlyeq': 8828, 'preceq': 8828, 'precnapprox': 10937, 'precnsim': 8936, 'precsim': 8830, 'prime': 8242, 'prod': 8719, 'propto': 8733, 'prurel': 8880, 'psi': 968, 'quad': 8195, 'questeq': 8799, 'rangle': 10217, 'rasp': 700, 'ratio': 8758, 'rbrace': 125, 'rbrack': 93, 'rceil': 8969, 'rfloor': 8971, 'rgroup': 10223, 'rhd': 9655, 'rho': 961, 'rightModels': 8875, 'rightangle': 8735, 'rightarrow': 8594, 'rightarrowbar': 8677, 'rightarrowtail': 8611, 'rightassert': 8870, 'rightbrace': 125, 'rightharpoonaccent': 8401, 'rightharpoondown': 8641, 'rightharpoonup': 8640, 'rightleftarrows': 8644, 'rightleftharpoons': 8652, 'rightparen': 41, 'rightrightarrows': 8649, 'rightsquigarrow': 8605, 'rightthreetimes': 8908, 'rightzigzagarrow': 8669, 'ring': 730, 'risingdotseq': 8787, 'rq': 8217, 'rtimes': 8906, 'scrB': 8492, 'scrE': 8496, 'scrF': 8497, 'scrH': 8459, 'scrI': 8464, 'scrL': 8466, 'scrM': 8499, 'scrR': 8475, 'scre': 8495, 'scrg': 8458, 'scro': 8500, 'scurel': 8881, 'searrow': 8600, 'setminus': 8726, 'sharp': 9839, 'sigma': 963, 'sim': 8764, 'simeq': 8771, 'simneqq': 8774, 'sinewave': 8767, 'slash': 8725, 'smallin': 8714, 'smallintclockwise': 8753, 'smallointctrcclockwise': 8755, 'smallowns': 8717, 'smallsetminus': 8726, 'smallvarointclockwise': 8754, 'smile': 8995, 'solbar': 9023, 'spadesuit': 9824, 'spadesuitopen': 9828, 'sphericalangle': 8738, 'sqcap': 8851, 'sqcup': 8852, 'sqsubset': 8847, 'sqsubseteq': 8849, 'sqsubsetneq': 8932, 'sqsupset': 8848, 'sqsupseteq': 8850, 'sqsupsetneq': 8933, 'ss': 223, 'star': 8902, 'stareq': 8795, 'sterling': 163, 'subset': 8834, 'subseteq': 8838, 'subseteqq': 10949, 'subsetneq': 8842, 'subsetneqq': 10955, 'succ': 8827, 'succapprox': 10936, 'succcurlyeq': 8829, 'succeq': 8829, 'succnapprox': 10938, 'succnsim': 8937, 'succsim': 8831, 'sum': 8721, 'supset': 8835, 'supseteq': 8839, 'supseteqq': 10950, 'supsetneq': 8843, 'supsetneqq': 10956, 'swarrow': 8601, 't': 865, 'tau': 964, 'textasciiacute': 180, 'textasciicircum': 94, 'textasciigrave': 96, 'textasciitilde': 126, 'textexclamdown': 161, 'textquestiondown': 191, 'textquotedblleft': 8220, 'textquotedblright': 8221, 'therefore': 8756, 'theta': 952, 'thickspace': 8197, 'thorn': 254, 'tilde': 771, 'times': 215, 'to': 8594, 'top': 8868, 'triangle': 9651, 'triangledown': 9663, 'triangleeq': 8796, 'triangleleft': 9665, 'trianglelefteq': 8884, 'triangleq': 8796, 'triangleright': 9655, 'trianglerighteq': 8885, 'turnednot': 8985, 'twoheaddownarrow': 8609, 'twoheadleftarrow': 8606, 'twoheadrightarrow': 8608, 'twoheaduparrow': 8607, 'ulcorner': 8988, 'underbar': 817, 'unlhd': 8884, 'unrhd': 8885, 'uparrow': 8593, 'updownarrow': 8597, 'updownarrowbar': 8616, 'updownarrows': 8645, 'upharpoonleft': 8639, 'upharpoonright': 8638, 'uplus': 8846, 'upsilon': 965, 'upuparrows': 8648, 'urcorner': 8989, 'vDash': 8872, 'varepsilon': 949, 'varisinobar': 8950, 'varisins': 8947, 'varkappa': 1008, 'varlrtriangle': 8895, 'varniobar': 8957, 'varnis': 8955, 'varnothing': 8709, 'varphi': 966, 'varpi': 982, 'varpropto': 8733, 'varrho': 1009, 'varsigma': 962, 'vartheta': 977, 'vartriangle': 9653, 'vartriangleleft': 8882, 'vartriangleright': 8883, 'vdash': 8866, 'vdots': 8942, 'vec': 8407, 'vee': 8744, 'veebar': 8891, 'veeeq': 8794, 'vert': 124, 'wedge': 8743, 'wedgeq': 8793, 'widebar': 773, 'widehat': 770, 'widetilde': 771, 'wp': 8472, 'wr': 8768, 'xi': 958, 'yen': 165, 'zeta': 950, '{': 123, '|': 8214, '}': 125}
_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': [('0', '9', 'rm', '𝟘'), ('A', 'B', 'rm', '𝔸'), ('C', 'C', 'rm', 'ℂ'), ('D', 'G', 'rm', '𝔻'), ('H', 'H', 'rm', 'ℍ'), ('I', 'M', 'rm', '𝕀'), ('N', 'N', 'rm', 'ℕ'), ('O', 'O', 'rm', '𝕆'), ('P', 'Q', 'rm', 'ℙ'), ('R', 'R', 'rm', 'ℝ'), ('S', 'Y', 'rm', '𝕊'), ('Z', 'Z', 'rm', 'ℤ'), ('a', 'z', 'rm', '𝕒'), ('Γ', 'Γ', 'rm', 'ℾ'), ('Π', 'Π', 'rm', 'ℿ'), ('Σ', 'Σ', 'rm', '⅀'), ('γ', 'γ', 'rm', 'ℽ'), ('π', 'π', 'rm', 'ℼ')], 'it': [('0', '9', 'rm', '𝟘'), ('A', 'B', 'it', 57684), ('C', 'C', 'it', 'ℂ'), ('D', 'D', 'it', 'ⅅ'), ('E', 'G', 'it', 57686), ('H', 'H', 'it', 'ℍ'), ('I', 'M', 'it', 57689), ('N', 'N', 'it', 'ℕ'), ('O', 'O', 'it', 57694), ('P', 'Q', 'it', 'ℙ'), ('R', 'R', 'it', 'ℝ'), ('S', 'Y', 'it', 57695), ('Z', 'Z', 'it', 'ℤ'), ('a', 'c', 'it', 57702), ('d', 'e', 'it', 'ⅆ'), ('f', 'h', 'it', 57705), ('i', 'j', 'it', 'ⅈ'), ('k', 'z', 'it', 57708), ('Γ', 'Γ', 'it', 'ℾ'), ('Π', 'Π', 'it', 'ℿ'), ('Σ', 'Σ', 'it', '⅀'), ('γ', 'γ', 'it', 'ℽ'), ('π', 'π', 'it', 'ℼ')], 'bf': [('0', '9', 'rm', '𝟘'), ('A', 'B', 'bf', 58250), ('C', 'C', 'bf', 'ℂ'), ('D', 'D', 'bf', 'ⅅ'), ('E', 'G', 'bf', 58253), ('H', 'H', 'bf', 'ℍ'), ('I', 'M', 'bf', 58256), ('N', 'N', 'bf', 'ℕ'), ('O', 'O', 'bf', 58261), ('P', 'Q', 'bf', 'ℙ'), ('R', 'R', 'bf', 'ℝ'), ('S', 'Y', 'bf', 58262), ('Z', 'Z', 'bf', 'ℤ'), ('a', 'c', 'bf', 58269), ('d', 'e', 'bf', 'ⅆ'), ('f', 'h', 'bf', 58274), ('i', 'j', 'bf', 'ⅈ'), ('k', 'z', 'bf', 58279), ('Γ', 'Γ', 'bf', 'ℾ'), ('Π', 'Π', 'bf', 'ℿ'), ('Σ', 'Σ', 'bf', '⅀'), ('γ', 'γ', 'bf', 'ℽ'), ('π', 'π', 'bf', 'ℼ')]}, 'cal': [('A', 'Z', 'it', 57901)], 'frak': {'rm': [('A', 'B', 'rm', '𝔄'), ('C', 'C', 'rm', 'ℭ'), ('D', 'G', 'rm', '𝔇'), ('H', 'H', 'rm', 'ℌ'), ('I', 'I', 'rm', 'ℑ'), ('J', 'Q', 'rm', '𝔍'), ('R', 'R', 'rm', 'ℜ'), ('S', 'Y', 'rm', '𝔖'), ('Z', 'Z', 'rm', 'ℨ'), ('a', 'z', 'rm', '𝔞')], 'bf': [('A', 'Z', 'bf', '𝕬'), ('a', 'z', 'bf', '𝖆')]}, 'scr': [('A', 'A', 'it', '𝒜'), ('B', 'B', 'it', 'ℬ'), ('C', 'D', 'it', '𝒞'), ('E', 'F', 'it', 'ℰ'), ('G', 'G', 'it', '𝒢'), ('H', 'H', 'it', 'ℋ'), ('I', 'I', 'it', 'ℐ'), ('J', 'K', 'it', '𝒥'), ('L', 'L', 'it', 'ℒ'), ('M', 'M', 'it', 'ℳ'), ('N', 'Q', 'it', '𝒩'), ('R', 'R', 'it', 'ℛ'), ('S', 'Z', 'it', '𝒮'), ('a', 'd', 'it', '𝒶'), ('e', 'e', 'it', 'ℯ'), ('f', 'f', 'it', '𝒻'), ('g', 'g', 'it', 'ℊ'), ('h', 'n', 'it', '𝒽'), ('o', 'o', 'it', 'ℴ'), ('p', 'z', 'it', '𝓅')], 'sf': {'rm': [('0', '9', 'rm', '𝟢'), ('A', 'Z', 'rm', '𝖠'), ('a', 'z', 'rm', '𝖺'), ('Α', 'Ω', 'rm', 57725), ('α', 'ω', 'rm', 57750), ('ϑ', 'ϑ', 'rm', 57776), ('ϕ', 'ϕ', 'rm', 57777), ('ϖ', 'ϖ', 'rm', 57779), ('ϱ', 'ϱ', 'rm', 57778), ('ϵ', 'ϵ', 'rm', 57775), ('∂', '∂', 'rm', 57724)], 'it': [('0', '9', 'rm', '𝟢'), ('A', 'Z', 'it', '𝘈'), ('a', 'z', 'it', '𝘢'), ('Α', 'Ω', 'rm', 57725), ('α', 'ω', 'it', 57816), ('ϑ', 'ϑ', 'it', 57842), ('ϕ', 'ϕ', 'it', 57843), ('ϖ', 'ϖ', 'it', 57845), ('ϱ', 'ϱ', 'it', 57844), ('ϵ', 'ϵ', 'it', 57841)], 'bf': [('0', '9', 'bf', '𝟬'), ('A', 'Z', 'bf', '𝗔'), ('a', 'z', 'bf', '𝗮'), ('Α', 'Ω', 'bf', '𝝖'), ('α', 'ω', 'bf', '𝝰'), ('ϑ', 'ϑ', 'bf', '𝞋'), ('ϕ', 'ϕ', 'bf', '𝞍'), ('ϖ', 'ϖ', 'bf', '𝞏'), ('ϰ', 'ϰ', 'bf', '𝞌'), ('ϱ', 'ϱ', 'bf', '𝞎'), ('ϵ', 'ϵ', 'bf', '𝞊'), ('∂', '∂', 'bf', '𝞉'), ('∇', '∇', 'bf', '𝝯')], 'bfit': [('A', 'Z', 'bfit', '𝑨'), ('a', 'z', 'bfit', '𝒂'), ('Γ', 'Ω', 'bfit', '𝜞'), ('α', 'ω', 'bfit', '𝜶')]}, 'tt': [('0', '9', 'rm', '𝟶'), ('A', 'Z', 'rm', '𝙰'), ('a', 'z', 'rm', '𝚊')]}

@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)
del _stix_virtual_fonts
stix_glyph_fixes = {8914: 8915, 8915: 8914}

# File: matplotlib-main/lib/matplotlib/_pylab_helpers.py
""""""
import atexit
from collections import OrderedDict

class Gcf:
    figs = OrderedDict()

    @classmethod
    def get_fig_manager(cls, num):
        manager = cls.figs.get(num, None)
        if manager is not None:
            cls.set_active(manager)
        return manager

    @classmethod
    def destroy(cls, num):
        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):
        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):
        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 num in cls.figs

    @classmethod
    def get_all_fig_managers(cls):
        return list(cls.figs.values())

    @classmethod
    def get_num_fig_managers(cls):
        return len(cls.figs)

    @classmethod
    def get_active(cls):
        return next(reversed(cls.figs.values())) if cls.figs else None

    @classmethod
    def _set_new_active_manager(cls, 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):
        cls.figs[manager.num] = manager
        cls.figs.move_to_end(manager.num)

    @classmethod
    def draw_all(cls, force=False):
        for manager in cls.get_all_fig_managers():
            if force or manager.canvas.figure.stale:
                manager.canvas.draw_idle()
atexit.register(Gcf.destroy_all)

# File: matplotlib-main/lib/matplotlib/_text_helpers.py
""""""
from __future__ import annotations
import dataclasses
from . import _api
from .ft2font import KERNING_DEFAULT, LOAD_NO_HINTING, FT2Font

@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} ({chr(codepoint).encode('ascii', 'namereplace').decode('ascii')}) missing from font(s) {fontnames}.")
    block = 'Hebrew' if 1424 <= codepoint <= 1535 else 'Arabic' if 1536 <= codepoint <= 1791 else 'Devanagari' if 2304 <= codepoint <= 2431 else 'Bengali' if 2432 <= codepoint <= 2559 else 'Gurmukhi' if 2560 <= codepoint <= 2687 else 'Gujarati' if 2688 <= codepoint <= 2815 else 'Oriya' if 2816 <= codepoint <= 2943 else 'Tamil' if 2944 <= codepoint <= 3071 else 'Telugu' if 3072 <= codepoint <= 3199 else 'Kannada' if 3200 <= codepoint <= 3327 else 'Malayalam' if 3328 <= codepoint <= 3455 else 'Sinhala' if 3456 <= codepoint <= 3583 else None
    if block:
        _api.warn_external(f'Matplotlib currently does not support {block} natively.')

def layout(string, font, *, kern_mode=KERNING_DEFAULT):
    x = 0
    prev_glyph_idx = None
    char_to_font = font._get_fontmap(string)
    base_font = font
    for char in string:
        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.0
        x += kern
        glyph = font.load_glyph(glyph_idx, flags=LOAD_NO_HINTING)
        yield LayoutItem(font, char, glyph_idx, x, kern)
        x += glyph.linearHoriAdvance / 65536
        prev_glyph_idx = glyph_idx

# File: matplotlib-main/lib/matplotlib/_tight_bbox.py
""""""
from matplotlib.transforms import Bbox, TransformedBbox, Affine2D

def adjust_bbox(fig, bbox_inches, fixed_dpi=None):
    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)
        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:
                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):
    (bbox_inches, restore_bbox) = bbox_inches_restore
    restore_bbox()
    r = adjust_bbox(fig, bbox_inches, fixed_dpi)
    return (bbox_inches, r)

# File: matplotlib-main/lib/matplotlib/_tight_layout.py
""""""
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):
    (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
        hspaces[rowspan, colspan.stop] += tight_bbox.xmax - ax_bbox.xmax
        vspaces[rowspan.start, colspan] += tight_bbox.ymax - ax_bbox.ymax
        vspaces[rowspan.stop, colspan] += ax_bbox.ymin - tight_bbox.ymin
    (fig_width_inch, fig_height_inch) = fig.get_size_inches()
    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
        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):
    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):
    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:
        (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)
    if rect is not None and kwargs is not None:
        (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

# File: matplotlib-main/lib/matplotlib/_type1font.py
""""""
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:
    __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):
        return self.pos + len(self.raw)

    def is_keyword(self, *names):
        return False

    def is_slash_name(self):
        return False

    def is_delim(self):
        return False

    def is_number(self):
        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('\\\\([\\\\()nrtbf]|[0-7]{1,3})')
    _replacements = {'\\': '\\', '(': '(', ')': ')', 'n': '\n', 'r': '\r', 't': '\t', 'b': '\x08', 'f': '\x0c'}
    _ws_re = re.compile('[\x00\t\r\x0c\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]:
    text = data.decode('ascii', 'replace')
    whitespace_or_comment_re = re.compile('[\\0\\t\\r\\f\\n ]+|%[^\\r\\n]*')
    token_re = re.compile('/{0,2}[^]\\0\\t\\r\\f\\n ()<>{}/%[]+')
    instring_re = re.compile('[()\\\\]')
    hex_re = re.compile('^<[0-9a-fA-F\\0\\t\\r\\f\\n ]*>$')
    oct_re = re.compile('[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] == '(':
            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:
                    char = text[pos]
                    if char in '\\()nrtbf':
                        pos += 1
                    else:
                        octal = oct_re.match(text, pos)
                        if octal:
                            pos = octal.end()
                        else:
                            pass
            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):
    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:
    __slots__ = ('parts', 'decrypted', 'prop', '_pos', '_abbr')

    def __init__(self, input):
        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):
        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:
                data += segment
            elif type == 2:
                data += binascii.hexlify(segment)
            elif type == 3:
                break
            else:
                raise RuntimeError('Unknown segment type %d in pfb file' % type)
        return data

    def _split(self, data):
        idx = data.index(b'eexec')
        idx += len(b'eexec')
        while data[idx] in b' \t\r\n':
            idx += 1
        len1 = idx
        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:
            _log.info('Insufficiently many zeros in Type 1 font')
        idx1 = len1 + (idx - len1 + 2 & ~1)
        binary = binascii.unhexlify(data[len1:idx1])
        return (data[:len1], binary, data[idx + 1:])

    @staticmethod
    def _decrypt(ciphertext, key, ndiscard=4):
        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 & 65535
        return bytes(plaintext[ndiscard:])

    @staticmethod
    def _encrypt(plaintext, key, ndiscard=4):
        key = _api.check_getitem({'eexec': 55665, 'charstring': 4330}, key=key)
        ciphertext = []
        for byte in b'\x00' * ndiscard + plaintext:
            c = byte ^ key >> 8
            ciphertext.append(c)
            key = (key + c) * 52845 + 22719 & 65535
        return bytes(ciphertext)

    def _parse(self):
        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:
            try:
                token = next(source)
            except StopIteration:
                break
            if token.is_delim():
                _expression(token, source, data)
            if token.is_slash_name():
                key = token.value()
                keypos = token.pos
            else:
                continue
            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):
                continue
            if token.is_delim():
                value = _expression(token, source, data).raw
            else:
                value = token.value()
            try:
                kw = next((kw for kw in source if not kw.is_keyword('readonly', 'noaccess', 'executeonly')))
            except StopIteration:
                break
            if kw.is_keyword('def', self._abbr['ND'], self._abbr['NP']):
                prop[key] = value
                pos.setdefault(key, []).append((keypos, kw.endpos()))
            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
        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'])
        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(f'Token following dup in Subrs definition must be a number, was {index_token}')
            nbytes_token = next(tokens)
            if not nbytes_token.is_number():
                raise RuntimeError(f'Second token following dup in Subrs definition must 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']}, 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(f'Token following /CharStrings must be a number, 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 must be a number, was {nbytes_token}')
            next(tokens)
            binary_token = tokens.send(1 + nbytes_token.value())
            charstrings[glyphname] = binary_token.value()

    @staticmethod
    def _parse_encoding(tokens, _data):
        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):
        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'}

# File: matplotlib-main/lib/matplotlib/animation.py
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__)
subprocess_creation_flags = subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0

def adjusted_figsize(w, h, dpi, n):

    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:

    def __init__(self):
        self._registered = dict()

    def register(self, name):

        def wrapper(writer_cls):
            self._registered[name] = writer_cls
            return writer_cls
        return wrapper

    def is_available(self, name):
        try:
            cls = self._registered[name]
        except KeyError:
            return False
        return cls.isAvailable()

    def __iter__(self):
        for name in self._registered:
            if self.is_available(name):
                yield name

    def list(self):
        return [*self]

    def __getitem__(self, name):
        if self.is_available(name):
            return self._registered[name]
        raise RuntimeError(f'Requested MovieWriter ({name}) not available')
writers = MovieWriterRegistry()

class AbstractMovieWriter(abc.ABC):

    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):
        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):
        (w, h) = self.fig.get_size_inches()
        return (int(w * self.dpi), int(h * self.dpi))

    @abc.abstractmethod
    def grab_frame(self, **savefig_kwargs):

    @abc.abstractmethod
    def finish(self):

    @contextlib.contextmanager
    def saving(self, fig, outfile, dpi, *args, **kwargs):
        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.")
        self.setup(fig, outfile, dpi, *args, **kwargs)
        with mpl.rc_context({'savefig.bbox': None}):
            try:
                yield self
            finally:
                self.finish()

class MovieWriter(AbstractMovieWriter):
    supported_formats = ['rgba']

    def __init__(self, fps=5, codec=None, bitrate=None, extra_args=None, metadata=None):
        if type(self) is MovieWriter:
            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):
        super().setup(fig, outfile, dpi=dpi)
        (self._w, self._h) = self._adjust_frame_size()
        self._run()

    def _run(self):
        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):
        (out, err) = self._proc.communicate()
        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):
        _validate_grabframe_kwargs(savefig_kwargs)
        _log.debug('MovieWriter.grab_frame: Grabbing frame.')
        self.fig.set_size_inches(self._w, self._h)
        self.fig.savefig(self._proc.stdin, format=self.frame_format, dpi=self.dpi, **savefig_kwargs)

    def _args(self):
        return NotImplementedError('args needs to be implemented by subclass.')

    @classmethod
    def bin_path(cls):
        return str(mpl.rcParams[cls._exec_key])

    @classmethod
    def isAvailable(cls):
        return shutil.which(cls.bin_path()) is not None

class FileMovieWriter(MovieWriter):

    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):
        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
        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):
        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 supported by {type(self).__name__}; using {self.supported_formats[0]} instead.')
            self._frame_format = self.supported_formats[0]

    def _base_temp_name(self):
        return self.fname_format_str % (self.temp_prefix, self.frame_format)

    def grab_frame(self, **savefig_kwargs):
        _validate_grabframe_kwargs(savefig_kwargs)
        path = Path(self._base_temp_name() % self._frame_counter)
        self._temp_paths.append(path)
        self._frame_counter += 1
        _log.debug('FileMovieWriter.grab_frame: Grabbing frame %d to path=%s', self._frame_counter, path)
        with open(path, 'wb') as sink:
            self.fig.savefig(sink, format=self.frame_format, dpi=self.dpi, **savefig_kwargs)

    def finish(self):
        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):

    @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})
        self._frames.append(Image.frombuffer('RGBA', self.frame_size, buf.getbuffer(), 'raw', 'RGBA', 0, 1))

    def finish(self):
        self._frames[0].save(self.outfile, save_all=True, append_images=self._frames[1:], duration=int(1000 / self.fps), loop=0)

class FFMpegBase:
    _exec_key = 'animation.ffmpeg_path'
    _args_key = 'animation.ffmpeg_args'

    @property
    def output_args(self):
        args = []
        if Path(self.outfile).suffix == '.gif':
            self.codec = 'gif'
        else:
            args.extend(['-vcodec', self.codec])
        extra_args = self.extra_args if self.extra_args is not None else mpl.rcParams[self._args_key]
        if self.codec == 'h264' and '-pix_fmt' not in extra_args:
            args.extend(['-pix_fmt', 'yuv420p'])
        elif self.codec == 'gif' and '-filter_complex' not in extra_args:
            args.extend(['-filter_complex', 'split [a][b];[a] palettegen [p];[b][p] paletteuse'])
        if self.bitrate > 0:
            args.extend(['-b', '%dk' % self.bitrate])
        for (k, v) in self.metadata.items():
            args.extend(['-metadata', f'{k}={v}'])
        args.extend(extra_args)
        return args + ['-y', self.outfile]

@writers.register('ffmpeg')
class FFMpegWriter(FFMpegBase, MovieWriter):

    def _args(self):
        args = [self.bin_path(), '-f', 'rawvideo', '-vcodec', 'rawvideo', '-s', '%dx%d' % self.frame_size, '-pix_fmt', self.frame_format, '-framerate', str(self.fps)]
        if _log.getEffectiveLevel() > logging.DEBUG:
            args += ['-loglevel', 'error']
        args += ['-i', 'pipe:'] + self.output_args
        return args

@writers.register('ffmpeg_file')
class FFMpegFileWriter(FFMpegBase, FileMovieWriter):
    supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']

    def _args(self):
        args = []
        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)]
        if _log.getEffectiveLevel() > logging.DEBUG:
            args += ['-loglevel', 'error']
        return [self.bin_path(), *args, *self.output_args]

class ImageMagickBase:
    _exec_key = 'animation.convert_path'
    _args_key = 'animation.convert_args'

    def _args(self):
        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:
            _log.debug('ImageMagick unavailable due to: %s', _enf)
            return False

@writers.register('imagemagick')
class ImageMagickWriter(ImageMagickBase, MovieWriter):
    input_names = '-'

@writers.register('imagemagick_file')
class ImageMagickFileWriter(ImageMagickBase, FileMovieWriter):
    supported_formats = ['png', 'jpeg', 'tiff', 'raw', 'rgba']
    input_names = property(lambda self: f'{self.temp_prefix}*.{self.frame_format}')

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):
    if frame_format == '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):
    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 = ()
        self.embed_frames = embed_frames
        self.default_mode = default_mode.lower()
        _api.check_in_list(['loop', 'once', 'reflect'], default_mode=self.default_mode)
        self._bytes_limit = mpl._val_or_rc(embed_limit, 'animation.embed_limit')
        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:
            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):
        if self.embed_frames:
            fill_frames = _embedded_frames(self._saved_frames, self.frame_format)
            frame_count = len(self._saved_frames)
        else:
            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))
        if self._tmpdir:
            _log.debug('MovieWriter: clearing temporary path=%s', self._tmpdir)
            self._tmpdir.cleanup()

class Animation:

    def __init__(self, fig, event_source=None, blit=False):
        self._draw_was_started = False
        self._fig = fig
        self._blit = blit and fig.canvas.supports_blit
        self.frame_seq = self.new_frame_seq()
        self.event_source = event_source
        self._first_draw_id = fig.canvas.mpl_connect('draw_event', self._start)
        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):
        if self._fig.canvas.is_saving():
            return
        self._fig.canvas.mpl_disconnect(self._first_draw_id)
        self._init_draw()
        self.event_source.add_callback(self._step)
        self.event_source.start()

    def _stop(self, *args):
        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):
        all_anim = [self]
        if extra_anim is not None:
            all_anim.extend((anim for anim in extra_anim if anim._fig is self._fig))
        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:
            savefig_kwargs = dict(savefig_kwargs)
        if fps is None and hasattr(self, '_interval'):
            fps = 1000.0 / self._interval
        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 isinstance(writer, str):
            try:
                writer_cls = writers[writer]
            except RuntimeError:
                writer_cls = PillowWriter
                _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')
        facecolor = savefig_kwargs.get('facecolor', mpl.rcParams['savefig.facecolor'])
        if facecolor == 'auto':
            facecolor = self._fig.get_facecolor()

        def _pre_composite_to_white(color):
            (r, g, b, a) = mcolors.to_rgba(color)
            return a * np.array([r, g, b]) + 1 - a
        savefig_kwargs['facecolor'] = _pre_composite_to_white(facecolor)
        savefig_kwargs['transparent'] = False
        with writer.saving(self._fig, filename, dpi), cbook._setattr_cm(self._fig.canvas, _is_saving=True, manager=None):
            for anim in all_anim:
                anim._init_draw()
            frame_number = 0
            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):
                    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):
        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 iter(self._framedata)

    def new_saved_frame_seq(self):
        return self.new_frame_seq()

    def _draw_next_frame(self, framedata, blit):
        self._pre_draw(framedata, blit)
        self._draw_frame(framedata)
        self._post_draw(framedata, blit)

    def _init_draw(self):
        self._draw_was_started = True

    def _pre_draw(self, framedata, blit):
        if blit:
            self._blit_clear(self._drawn_artists)

    def _draw_frame(self, framedata):
        raise NotImplementedError('Needs to be implemented by subclasses to actually make an animation.')

    def _post_draw(self, framedata, blit):
        if blit and self._drawn_artists:
            self._blit_draw(self._drawn_artists)
        else:
            self._fig.canvas.draw_idle()

    def _blit_draw(self, artists):
        updated_ax = {a.axes for a in artists}
        for ax in updated_ax:
            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))
        for a in artists:
            a.axes.draw_artist(a)
        for ax in updated_ax:
            ax.figure.canvas.blit(ax.bbox)

    def _blit_clear(self, artists):
        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):
        self._blit_cache = dict()
        self._drawn_artists = []
        self._post_draw(None, self._blit)
        self._init_draw()
        self._resize_id = self._fig.canvas.mpl_connect('resize_event', self._on_resize)

    def _on_resize(self, event):
        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):
        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):
        VIDEO_TAG = '<video {size} {options}>\n  <source type="video/mp4" src="data:video/mp4;base64,{video}">\n  Your browser does not support the video tag.\n</video>'
        if not hasattr(self, '_base64_video'):
            embed_limit = mpl._val_or_rc(embed_limit, 'animation.embed_limit')
            embed_limit *= 1024 * 1024
            with TemporaryDirectory() as tmpdir:
                path = Path(tmpdir, 'temp.m4v')
                Writer = writers[mpl.rcParams['animation.writer']]
                writer = Writer(codec='h264', bitrate=mpl.rcParams['animation.bitrate'], fps=1000.0 / self._interval)
                self.save(str(path), writer=writer)
                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 hasattr(self, '_base64_video'):
            options = ['controls', 'autoplay']
            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):
        if fps is None and hasattr(self, '_interval'):
            fps = 1000 / self._interval
        if default_mode is None:
            default_mode = 'loop' if getattr(self, '_repeat', False) else 'once'
        if not hasattr(self, '_html_representation'):
            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):
        fmt = mpl.rcParams['animation.html']
        if fmt == 'html5':
            return self.to_html5_video()
        elif fmt == 'jshtml':
            return self.to_jshtml()

    def pause(self):
        self.event_source.stop()
        if self._blit:
            for artist in self._drawn_artists:
                artist.set_animated(False)

    def resume(self):
        self.event_source.start()
        if self._blit:
            for artist in self._drawn_artists:
                artist.set_animated(True)

class TimedAnimation(Animation):

    def __init__(self, fig, interval=200, repeat_delay=0, repeat=True, event_source=None, *args, **kwargs):
        self._interval = interval
        self._repeat_delay = repeat_delay if repeat_delay is not None else 0
        self._repeat = repeat
        if event_source is None:
            event_source = fig.canvas.new_timer(interval=self._interval)
        super().__init__(fig, *args, event_source=event_source, **kwargs)

    def _step(self, *args):
        still_going = super()._step(*args)
        if not still_going:
            if self._repeat:
                self._init_draw()
                self.frame_seq = self.new_frame_seq()
                self.event_source.interval = self._repeat_delay
                return True
            else:
                self.pause()
                if self._blit:
                    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):

    def __init__(self, fig, artists, *args, **kwargs):
        self._drawn_artists = []
        self._framedata = artists
        super().__init__(fig, *args, **kwargs)

    def _init_draw(self):
        super()._init_draw()
        figs = set()
        for f in self.new_frame_seq():
            for artist in f:
                artist.set_visible(False)
                artist.set_animated(self._blit)
                if artist.get_figure() not in figs:
                    figs.add(artist.get_figure())
        for fig in figs:
            fig.canvas.draw_idle()

    def _pre_draw(self, framedata, blit):
        if blit:
            self._blit_clear(self._drawn_artists)
        else:
            for artist in self._drawn_artists:
                artist.set_visible(False)

    def _draw_frame(self, artists):
        self._drawn_artists = artists
        for artist in artists:
            artist.set_visible(True)

class FuncAnimation(TimedAnimation):

    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
        self._save_count = save_count
        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={save_count!r} which is being ignored in favor of len(frames)={len(frames)!r}.')
        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={save_count!r} which is being ignored in favor of frames={frames!r}.')
        if self._save_count is None and cache_frame_data:
            _api.warn_external(f'frames={frames!r} which we can infer the length of, did not pass an explicit *save_count* and passed cache_frame_data={cache_frame_data!r}.  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
        self._save_seq = []
        super().__init__(fig, **kwargs)
        self._save_seq = []

    def new_frame_seq(self):
        return self._iter_gen()

    def new_saved_frame_seq(self):
        if self._save_seq:
            self._old_saved_seq = list(self._save_seq)
            return iter(self._old_saved_seq)
        elif 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()
        if self._init_func is None:
            try:
                frame_data = next(self.new_frame_seq())
            except StopIteration:
                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\nIf 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:
            self._save_seq.append(framedata)
            self._save_seq = self._save_seq[-self._save_count:]
        self._drawn_artists = self._func(framedata, *self._args)
        if self._blit:
            err = RuntimeError('The animation function must return a sequence of Artist objects.')
            try:
                iter(self._drawn_artists)
            except TypeError:
                raise err from None
            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']={mpl.rcParams['savefig.bbox']!r} 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}')

# File: matplotlib-main/lib/matplotlib/artist.py
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):

    @wraps(draw)
    def draw_wrapper(artist, renderer, *args, **kwargs):
        if renderer._raster_depth == 0 and renderer._rasterizing:
            renderer.stop_rasterizing()
            renderer._rasterizing = False
        return draw(artist, renderer, *args, **kwargs)
    draw_wrapper._supports_rasterization = False
    return draw_wrapper

def allow_rasterization(draw):

    @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
            elif renderer._raster_depth == 0 and renderer._rasterizing:
                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:
                renderer.stop_rasterizing()
                renderer.start_rasterizing()
    draw_wrapper._supports_rasterization = True
    return draw_wrapper

def _finalize_rasterization(draw):

    @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:
    zorder = 0

    def __init_subclass__(cls):
        if not hasattr(cls.draw, '_supports_rasterization'):
            cls.draw = _prevent_rasterization(cls.draw)
        if not hasattr(cls.set, '_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', 'figure', '3d_properties']

    @classmethod
    def _update_set_signature_and_docstring(cls):
        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\nSupported 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
        self._mouseover = type(self).get_cursor_data != Artist.get_cursor_data
        self._callbacks = cbook.CallbackRegistry(signals=['pchanged'])
        try:
            self.axes = None
        except AttributeError:
            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):
        if self._remove_method is not None:
            self._remove_method(self)
            self.stale_callback = None
            _ax_flag = False
            if hasattr(self, 'axes') and self.axes:
                self.axes._mouseover_set.discard(self)
                self.axes.stale = True
                self.axes = None
                _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')

    def have_units(self):
        ax = self.axes
        return ax and any((axis.have_units() for axis in ax._axis_map.values()))

    def convert_xunits(self, x):
        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):
        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):
        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):
        return self._stale

    @stale.setter
    def stale(self, val):
        self._stale = val
        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):
        return Bbox([[0, 0], [0, 0]])

    def get_tightbbox(self, renderer=None):
        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):
        return self._callbacks.connect('pchanged', lambda : func(self))

    def remove_callback(self, oid):
        self._callbacks.disconnect(oid)

    def pchanged(self):
        self._callbacks.process('pchanged')

    def is_transform_set(self):
        return self._transformSet

    def set_transform(self, t):
        self._transform = t
        self._transformSet = True
        self.pchanged()
        self.stale = True

    def get_transform(self):
        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):
        return []

    def _different_canvas(self, event):
        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):
        _log.warning("%r needs 'contains' method", self.__class__.__name__)
        return (False, {})

    def pickable(self):
        return self.get_figure(root=False) is not None and self._picker is not None

    def pick(self, mouseevent):
        from .backend_bases import PickEvent
        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()
        for a in self.get_children():
            ax = getattr(a, 'axes', None)
            if isinstance(a, mpl.figure.SubFigure) or mouseevent.inaxes is None or ax is None or (mouseevent.inaxes == ax):
                a.pick(mouseevent)

    def set_picker(self, picker):
        self._picker = picker

    def get_picker(self):
        return self._picker

    def get_url(self):
        return self._url

    def set_url(self, url):
        self._url = url

    def get_gid(self):
        return self._gid

    def set_gid(self, gid):
        self._gid = gid

    def get_snap(self):
        if mpl.rcParams['path.snap']:
            return self._snap
        else:
            return False

    def set_snap(self, snap):
        self._snap = snap
        self.stale = True

    def get_sketch_params(self):
        return self._sketch

    def set_sketch_params(self, scale=None, length=None, randomness=None):
        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):
        self._path_effects = path_effects
        self.stale = True

    def get_path_effects(self):
        return self._path_effects

    def get_figure(self, root=False):
        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):
        if self._parent_figure is fig:
            return
        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):
        _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):
        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(f'Invalid arguments to set_clip_path, of type {type(path).__name__} and {type(transform).__name__}')
        self.pchanged()
        self.stale = True

    def get_alpha(self):
        return self._alpha

    def get_visible(self):
        return self._visible

    def get_animated(self):
        return self._animated

    def get_in_layout(self):
        return self._in_layout

    def _fully_clipped_to_axes(self):
        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 self._clipon

    def get_clip_box(self):
        return self.clipbox

    def get_clip_path(self):
        return self._clippath

    def get_transformed_clip_path_and_affine(self):
        if self._clippath is not None:
            return self._clippath.get_transformed_path_and_affine()
        return (None, None)

    def set_clip_on(self, b):
        self._clipon = b
        self.pchanged()
        self.stale = True

    def _set_gc_clip(self, 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 self._rasterized

    def set_rasterized(self, rasterized):
        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 self._agg_filter

    def set_agg_filter(self, filter_func):
        self._agg_filter = filter_func
        self.stale = True

    def draw(self, renderer):
        if not self.get_visible():
            return
        self.stale = False

    def set_alpha(self, alpha):
        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):
        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(f'alpha must be between 0 and 1, inclusive, but min is {alpha.min()}, max is {alpha.max()}')
        self._alpha = alpha
        self.pchanged()
        self.stale = True

    def set_visible(self, b):
        if b != self._visible:
            self._visible = b
            self.pchanged()
            self.stale = True

    def set_animated(self, b):
        if self._animated != b:
            self._animated = b
            self.pchanged()

    def set_in_layout(self, in_layout):
        self._in_layout = in_layout

    def get_label(self):
        return self._label

    def set_label(self, s):
        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 self.zorder

    def set_zorder(self, level):
        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):
        return self._sticky_edges

    def update_from(self, other):
        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 ArtistInspector(self).properties()

    def _update_props(self, props, errfmt):
        ret = []
        with cbook._setattr_cm(self, eventson=False):
            for (k, v) in props.items():
                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):
        return self._update_props(props, '{cls.__name__!r} object has no property {prop_name!r}')

    def _internal_update(self, kwargs):
        return self._update_props(kwargs, '{cls.__name__}.set() got an unexpected keyword argument {prop_name!r}')

    def set(self, **kwargs):
        return self._internal_update(cbook.normalize_kwargs(kwargs, self))

    @contextlib.contextmanager
    def _cm_set(self, **kwargs):
        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):
        if match is None:

            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 None

    def format_cursor_data(self, data):
        if np.ndim(data) == 0 and hasattr(self, '_format_cursor_data_override'):
            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 self._mouseover

    def set_mouseover(self, mouseover):
        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)

def _get_tightbbox_for_layout_only(obj, *args, **kwargs):
    try:
        return obj.get_tightbbox(*args, **{**kwargs, 'for_layout_only': True})
    except TypeError:
        return obj.get_tightbbox(*args, **kwargs)

class ArtistInspector:

    def __init__(self, o):
        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):
        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]}.*)`', inspect.getdoc(func)).group(1)
            aliases.setdefault(propname[4:], set()).add(name[4:])
        return aliases
    _get_valid_values_regex = re.compile('\\n\\s*(?:\\.\\.\\s+)?ACCEPTS:\\s*((?:.|\\n)*?)(?:$|(?:\\n\\n))')

    def get_valid_values(self, attr):
        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))
        param_name = func.__code__.co_varnames[1]
        match = re.search(f'(?m)^ *\\*?{param_name} : (.+)', docstring)
        if match:
            return match.group(1)
        return 'unknown'

    def _replace_path(self, source_class):
        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):
        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 len(inspect.signature(func).parameters)

    @staticmethod
    @cache
    def is_alias(method):
        ds = inspect.getdoc(method)
        if ds is None:
            return False
        return ds.startswith('Alias for ')

    def aliased_name(self, s):
        aliases = ''.join((' or %s' % x for x in sorted(self.aliasd.get(s, []))))
        return s + aliases
    _NOT_LINKABLE = {'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):
        if target in self._NOT_LINKABLE:
            return f'``{s}``'
        aliases = ''.join((' or %s' % x for x in sorted(self.aliasd.get(s, []))))
        return f':meth:`{s} <{target}>`{aliases}'

    def pprint_setters(self, prop=None, leadingspace=2):
        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 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()):
            for cls in self.o.__mro__:
                method = getattr(cls, f'set_{prop}', None)
                if method and method.__doc__ is not None:
                    break
            else:
                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):
        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):
        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):
    if property is None:
        insp = ArtistInspector(obj)
        ret = insp.pprint_getters()
        print('\n'.join(ret))
        return
    return getattr(obj, 'get_' + property)()
get = getp

def setp(obj, *args, file=None, **kwargs):
    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):
    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))
Artist._update_set_signature_and_docstring()

# File: matplotlib-main/lib/matplotlib/axes/__init__.py
from . import _base
from ._axes import Axes
Subplot = Axes

class _SubplotBaseMeta(type):

    def __instancecheck__(self, obj):
        return isinstance(obj, _base._AxesBase) and obj.get_subplotspec() is not None

class SubplotBase(metaclass=_SubplotBaseMeta):
    pass

def subplot_class_factory(cls):
    return cls

# File: matplotlib-main/lib/matplotlib/axes/_axes.py
import functools
import itertools
import logging
import math
from numbers import Integral, Number, Real
import re
import numpy as np
from numpy import ma
import matplotlib as mpl
import matplotlib.category
import matplotlib.cbook as cbook
import matplotlib.collections as mcoll
import matplotlib.colors as mcolors
import matplotlib.contour as mcontour
import matplotlib.dates
import matplotlib.image as mimage
import matplotlib.legend as mlegend
import matplotlib.lines as mlines
import matplotlib.markers as mmarkers
import matplotlib.mlab as mlab
import matplotlib.patches as mpatches
import matplotlib.path as mpath
import matplotlib.quiver as mquiver
import matplotlib.stackplot as mstack
import matplotlib.streamplot as mstream
import matplotlib.table as mtable
import matplotlib.text as mtext
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
import matplotlib.tri as mtri
import matplotlib.units as munits
from matplotlib import _api, _docstring, _preprocess_data
from matplotlib.axes._base import _AxesBase, _TransformedBoundsLocator, _process_plot_format
from matplotlib.axes._secondary_axes import SecondaryAxis
from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer
_log = logging.getLogger(__name__)

def _make_axes_method(func):
    func.__qualname__ = f'Axes.{func.__name__}'
    return func

@_docstring.interpd
class Axes(_AxesBase):

    def get_title(self, loc='center'):
        titles = {'left': self._left_title, 'center': self.title, 'right': self._right_title}
        title = _api.check_getitem(titles, loc=loc.lower())
        return title.get_text()

    def set_title(self, label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs):
        if loc is None:
            loc = mpl.rcParams['axes.titlelocation']
        if y is None:
            y = mpl.rcParams['axes.titley']
        if y is None:
            y = 1.0
        else:
            self._autotitlepos = False
        kwargs['y'] = y
        titles = {'left': self._left_title, 'center': self.title, 'right': self._right_title}
        title = _api.check_getitem(titles, loc=loc.lower())
        default = {'fontsize': mpl.rcParams['axes.titlesize'], 'fontweight': mpl.rcParams['axes.titleweight'], 'verticalalignment': 'baseline', 'horizontalalignment': loc.lower()}
        titlecolor = mpl.rcParams['axes.titlecolor']
        if not cbook._str_lower_equal(titlecolor, 'auto'):
            default['color'] = titlecolor
        if pad is None:
            pad = mpl.rcParams['axes.titlepad']
        self._set_title_offset_trans(float(pad))
        title.set_text(label)
        title.update(default)
        if fontdict is not None:
            title.update(fontdict)
        title._internal_update(kwargs)
        return title

    def get_legend_handles_labels(self, legend_handler_map=None):
        (handles, labels) = mlegend._get_legend_handles_labels([self], legend_handler_map)
        return (handles, labels)

    @_docstring.dedent_interpd
    def legend(self, *args, **kwargs):
        (handles, labels, kwargs) = mlegend._parse_legend_args([self], *args, **kwargs)
        self.legend_ = mlegend.Legend(self, handles, labels, **kwargs)
        self.legend_._remove_method = self._remove_legend
        return self.legend_

    def _remove_legend(self, legend):
        self.legend_ = None

    def inset_axes(self, bounds, *, transform=None, zorder=5, **kwargs):
        if transform is None:
            transform = self.transAxes
        kwargs.setdefault('label', 'inset_axes')
        inset_locator = _TransformedBoundsLocator(bounds, transform)
        bounds = inset_locator(self, None).bounds
        fig = self.get_figure(root=False)
        (projection_class, pkw) = fig._process_projection_requirements(**kwargs)
        inset_ax = projection_class(fig, bounds, zorder=zorder, **pkw)
        inset_ax.set_axes_locator(inset_locator)
        self.add_child_axes(inset_ax)
        return inset_ax

    @_docstring.dedent_interpd
    def indicate_inset(self, bounds, inset_ax=None, *, transform=None, facecolor='none', edgecolor='0.5', alpha=0.5, zorder=4.99, **kwargs):
        self.apply_aspect()
        if transform is None:
            transform = self.transData
        kwargs.setdefault('label', '_indicate_inset')
        (x, y, width, height) = bounds
        rectangle_patch = mpatches.Rectangle((x, y), width, height, facecolor=facecolor, edgecolor=edgecolor, alpha=alpha, zorder=zorder, transform=transform, **kwargs)
        self.add_patch(rectangle_patch)
        connects = []
        if inset_ax is not None:
            for xy_inset_ax in [(0, 0), (0, 1), (1, 0), (1, 1)]:
                (ex, ey) = xy_inset_ax
                if self.xaxis.get_inverted():
                    ex = 1 - ex
                if self.yaxis.get_inverted():
                    ey = 1 - ey
                xy_data = (x + ex * width, y + ey * height)
                p = mpatches.ConnectionPatch(xyA=xy_inset_ax, coordsA=inset_ax.transAxes, xyB=xy_data, coordsB=self.transData, arrowstyle='-', zorder=zorder, edgecolor=edgecolor, alpha=alpha)
                connects.append(p)
                self.add_patch(p)
            pos = inset_ax.get_position()
            bboxins = pos.transformed(self.get_figure(root=False).transSubfigure)
            rectbbox = mtransforms.Bbox.from_bounds(*bounds).transformed(transform)
            x0 = rectbbox.x0 < bboxins.x0
            x1 = rectbbox.x1 < bboxins.x1
            y0 = rectbbox.y0 < bboxins.y0
            y1 = rectbbox.y1 < bboxins.y1
            connects[0].set_visible(x0 ^ y0)
            connects[1].set_visible(x0 == y1)
            connects[2].set_visible(x1 == y0)
            connects[3].set_visible(x1 ^ y1)
        return (rectangle_patch, tuple(connects) if connects else None)

    def indicate_inset_zoom(self, inset_ax, **kwargs):
        xlim = inset_ax.get_xlim()
        ylim = inset_ax.get_ylim()
        rect = (xlim[0], ylim[0], xlim[1] - xlim[0], ylim[1] - ylim[0])
        return self.indicate_inset(rect, inset_ax, **kwargs)

    @_docstring.dedent_interpd
    def secondary_xaxis(self, location, functions=None, *, transform=None, **kwargs):
        if not (location in ['top', 'bottom'] or isinstance(location, Real)):
            raise ValueError('secondary_xaxis location must be either a float or "top"/"bottom"')
        secondary_ax = SecondaryAxis(self, 'x', location, functions, transform, **kwargs)
        self.add_child_axes(secondary_ax)
        return secondary_ax

    @_docstring.dedent_interpd
    def secondary_yaxis(self, location, functions=None, *, transform=None, **kwargs):
        if not (location in ['left', 'right'] or isinstance(location, Real)):
            raise ValueError('secondary_yaxis location must be either a float or "left"/"right"')
        secondary_ax = SecondaryAxis(self, 'y', location, functions, transform, **kwargs)
        self.add_child_axes(secondary_ax)
        return secondary_ax

    @_docstring.dedent_interpd
    def text(self, x, y, s, fontdict=None, **kwargs):
        effective_kwargs = {'verticalalignment': 'baseline', 'horizontalalignment': 'left', 'transform': self.transData, 'clip_on': False, **(fontdict if fontdict is not None else {}), **kwargs}
        t = mtext.Text(x, y, text=s, **effective_kwargs)
        if t.get_clip_path() is None:
            t.set_clip_path(self.patch)
        self._add_text(t)
        return t

    @_docstring.dedent_interpd
    def annotate(self, text, xy, xytext=None, xycoords='data', textcoords=None, arrowprops=None, annotation_clip=None, **kwargs):
        a = mtext.Annotation(text, xy, xytext=xytext, xycoords=xycoords, textcoords=textcoords, arrowprops=arrowprops, annotation_clip=annotation_clip, **kwargs)
        a.set_transform(mtransforms.IdentityTransform())
        if kwargs.get('clip_on', False) and a.get_clip_path() is None:
            a.set_clip_path(self.patch)
        self._add_text(a)
        return a
    annotate.__doc__ = mtext.Annotation.__init__.__doc__

    @_docstring.dedent_interpd
    def axhline(self, y=0, xmin=0, xmax=1, **kwargs):
        self._check_no_units([xmin, xmax], ['xmin', 'xmax'])
        if 'transform' in kwargs:
            raise ValueError("'transform' is not allowed as a keyword argument; axhline generates its own transform.")
        (ymin, ymax) = self.get_ybound()
        (yy,) = self._process_unit_info([('y', y)], kwargs)
        scaley = yy < ymin or yy > ymax
        trans = self.get_yaxis_transform(which='grid')
        l = mlines.Line2D([xmin, xmax], [y, y], transform=trans, **kwargs)
        self.add_line(l)
        l.get_path()._interpolation_steps = mpl.axis.GRIDLINE_INTERPOLATION_STEPS
        if scaley:
            self._request_autoscale_view('y')
        return l

    @_docstring.dedent_interpd
    def axvline(self, x=0, ymin=0, ymax=1, **kwargs):
        self._check_no_units([ymin, ymax], ['ymin', 'ymax'])
        if 'transform' in kwargs:
            raise ValueError("'transform' is not allowed as a keyword argument; axvline generates its own transform.")
        (xmin, xmax) = self.get_xbound()
        (xx,) = self._process_unit_info([('x', x)], kwargs)
        scalex = xx < xmin or xx > xmax
        trans = self.get_xaxis_transform(which='grid')
        l = mlines.Line2D([x, x], [ymin, ymax], transform=trans, **kwargs)
        self.add_line(l)
        l.get_path()._interpolation_steps = mpl.axis.GRIDLINE_INTERPOLATION_STEPS
        if scalex:
            self._request_autoscale_view('x')
        return l

    @staticmethod
    def _check_no_units(vals, names):
        for (val, name) in zip(vals, names):
            if not munits._is_natively_supported(val):
                raise ValueError(f'{name} must be a single scalar value, but got {val}')

    @_docstring.dedent_interpd
    def axline(self, xy1, xy2=None, *, slope=None, **kwargs):
        if slope is not None and (self.get_xscale() != 'linear' or self.get_yscale() != 'linear'):
            raise TypeError("'slope' cannot be used with non-linear scales")
        datalim = [xy1] if xy2 is None else [xy1, xy2]
        if 'transform' in kwargs:
            datalim = []
        line = mlines.AxLine(xy1, xy2, slope, **kwargs)
        self._set_artist_props(line)
        if line.get_clip_path() is None:
            line.set_clip_path(self.patch)
        if not line.get_label():
            line.set_label(f'_child{len(self._children)}')
        self._children.append(line)
        line._remove_method = self._children.remove
        self.update_datalim(datalim)
        self._request_autoscale_view()
        return line

    @_docstring.dedent_interpd
    def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
        self._check_no_units([xmin, xmax], ['xmin', 'xmax'])
        ((ymin, ymax),) = self._process_unit_info([('y', [ymin, ymax])], kwargs)
        p = mpatches.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, **kwargs)
        p.set_transform(self.get_yaxis_transform(which='grid'))
        ix = self.dataLim.intervalx.copy()
        mx = self.dataLim.minposx
        self.add_patch(p)
        self.dataLim.intervalx = ix
        self.dataLim.minposx = mx
        p.get_path()._interpolation_steps = mpl.axis.GRIDLINE_INTERPOLATION_STEPS
        self._request_autoscale_view('y')
        return p

    @_docstring.dedent_interpd
    def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
        self._check_no_units([ymin, ymax], ['ymin', 'ymax'])
        ((xmin, xmax),) = self._process_unit_info([('x', [xmin, xmax])], kwargs)
        p = mpatches.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, **kwargs)
        p.set_transform(self.get_xaxis_transform(which='grid'))
        iy = self.dataLim.intervaly.copy()
        my = self.dataLim.minposy
        self.add_patch(p)
        self.dataLim.intervaly = iy
        self.dataLim.minposy = my
        p.get_path()._interpolation_steps = mpl.axis.GRIDLINE_INTERPOLATION_STEPS
        self._request_autoscale_view('x')
        return p

    @_api.make_keyword_only('3.9', 'label')
    @_preprocess_data(replace_names=['y', 'xmin', 'xmax', 'colors'], label_namer='y')
    def hlines(self, y, xmin, xmax, colors=None, linestyles='solid', label='', **kwargs):
        (xmin, xmax, y) = self._process_unit_info([('x', xmin), ('x', xmax), ('y', y)], kwargs)
        if not np.iterable(y):
            y = [y]
        if not np.iterable(xmin):
            xmin = [xmin]
        if not np.iterable(xmax):
            xmax = [xmax]
        (y, xmin, xmax) = cbook._combine_masks(y, xmin, xmax)
        y = np.ravel(y)
        xmin = np.ravel(xmin)
        xmax = np.ravel(xmax)
        masked_verts = np.ma.empty((len(y), 2, 2))
        masked_verts[:, 0, 0] = xmin
        masked_verts[:, 0, 1] = y
        masked_verts[:, 1, 0] = xmax
        masked_verts[:, 1, 1] = y
        lines = mcoll.LineCollection(masked_verts, colors=colors, linestyles=linestyles, label=label)
        self.add_collection(lines, autolim=False)
        lines._internal_update(kwargs)
        if len(y) > 0:
            updatex = True
            updatey = True
            if self.name == 'rectilinear':
                datalim = lines.get_datalim(self.transData)
                t = lines.get_transform()
                (updatex, updatey) = t.contains_branch_seperately(self.transData)
                minx = np.nanmin(datalim.xmin)
                maxx = np.nanmax(datalim.xmax)
                miny = np.nanmin(datalim.ymin)
                maxy = np.nanmax(datalim.ymax)
            else:
                minx = np.nanmin(masked_verts[..., 0])
                maxx = np.nanmax(masked_verts[..., 0])
                miny = np.nanmin(masked_verts[..., 1])
                maxy = np.nanmax(masked_verts[..., 1])
            corners = ((minx, miny), (maxx, maxy))
            self.update_datalim(corners, updatex, updatey)
            self._request_autoscale_view()
        return lines

    @_api.make_keyword_only('3.9', 'label')
    @_preprocess_data(replace_names=['x', 'ymin', 'ymax', 'colors'], label_namer='x')
    def vlines(self, x, ymin, ymax, colors=None, linestyles='solid', label='', **kwargs):
        (x, ymin, ymax) = self._process_unit_info([('x', x), ('y', ymin), ('y', ymax)], kwargs)
        if not np.iterable(x):
            x = [x]
        if not np.iterable(ymin):
            ymin = [ymin]
        if not np.iterable(ymax):
            ymax = [ymax]
        (x, ymin, ymax) = cbook._combine_masks(x, ymin, ymax)
        x = np.ravel(x)
        ymin = np.ravel(ymin)
        ymax = np.ravel(ymax)
        masked_verts = np.ma.empty((len(x), 2, 2))
        masked_verts[:, 0, 0] = x
        masked_verts[:, 0, 1] = ymin
        masked_verts[:, 1, 0] = x
        masked_verts[:, 1, 1] = ymax
        lines = mcoll.LineCollection(masked_verts, colors=colors, linestyles=linestyles, label=label)
        self.add_collection(lines, autolim=False)
        lines._internal_update(kwargs)
        if len(x) > 0:
            updatex = True
            updatey = True
            if self.name == 'rectilinear':
                datalim = lines.get_datalim(self.transData)
                t = lines.get_transform()
                (updatex, updatey) = t.contains_branch_seperately(self.transData)
                minx = np.nanmin(datalim.xmin)
                maxx = np.nanmax(datalim.xmax)
                miny = np.nanmin(datalim.ymin)
                maxy = np.nanmax(datalim.ymax)
            else:
                minx = np.nanmin(masked_verts[..., 0])
                maxx = np.nanmax(masked_verts[..., 0])
                miny = np.nanmin(masked_verts[..., 1])
                maxy = np.nanmax(masked_verts[..., 1])
            corners = ((minx, miny), (maxx, maxy))
            self.update_datalim(corners, updatex, updatey)
            self._request_autoscale_view()
        return lines

    @_api.make_keyword_only('3.9', 'orientation')
    @_preprocess_data(replace_names=['positions', 'lineoffsets', 'linelengths', 'linewidths', 'colors', 'linestyles'])
    @_docstring.dedent_interpd
    def eventplot(self, positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, alpha=None, linestyles='solid', **kwargs):
        (lineoffsets, linelengths) = self._process_unit_info([('y', lineoffsets), ('y', linelengths)], kwargs)
        if not np.iterable(positions):
            positions = [positions]
        elif any((np.iterable(position) for position in positions)):
            positions = [np.asanyarray(position) for position in positions]
        else:
            positions = [np.asanyarray(positions)]
        poss = []
        for position in positions:
            poss += self._process_unit_info([('x', position)], kwargs)
        positions = poss
        colors = cbook._local_over_kwdict(colors, kwargs, 'color')
        linewidths = cbook._local_over_kwdict(linewidths, kwargs, 'linewidth')
        linestyles = cbook._local_over_kwdict(linestyles, kwargs, 'linestyle')
        if not np.iterable(lineoffsets):
            lineoffsets = [lineoffsets]
        if not np.iterable(linelengths):
            linelengths = [linelengths]
        if not np.iterable(linewidths):
            linewidths = [linewidths]
        if not np.iterable(colors):
            colors = [colors]
        if not np.iterable(alpha):
            alpha = [alpha]
        if hasattr(linestyles, 'lower') or not np.iterable(linestyles):
            linestyles = [linestyles]
        lineoffsets = np.asarray(lineoffsets)
        linelengths = np.asarray(linelengths)
        linewidths = np.asarray(linewidths)
        if len(lineoffsets) == 0:
            raise ValueError('lineoffsets cannot be empty')
        if len(linelengths) == 0:
            raise ValueError('linelengths cannot be empty')
        if len(linestyles) == 0:
            raise ValueError('linestyles cannot be empty')
        if len(linewidths) == 0:
            raise ValueError('linewidths cannot be empty')
        if len(alpha) == 0:
            raise ValueError('alpha cannot be empty')
        if len(colors) == 0:
            colors = [None]
        try:
            colors = mcolors.to_rgba_array(colors)
        except ValueError:
            pass
        if len(lineoffsets) == 1 and len(positions) != 1:
            lineoffsets = np.tile(lineoffsets, len(positions))
            lineoffsets[0] = 0
            lineoffsets = np.cumsum(lineoffsets)
        if len(linelengths) == 1:
            linelengths = np.tile(linelengths, len(positions))
        if len(linewidths) == 1:
            linewidths = np.tile(linewidths, len(positions))
        if len(colors) == 1:
            colors = list(colors) * len(positions)
        if len(alpha) == 1:
            alpha = list(alpha) * len(positions)
        if len(linestyles) == 1:
            linestyles = [linestyles] * len(positions)
        if len(lineoffsets) != len(positions):
            raise ValueError('lineoffsets and positions are unequal sized sequences')
        if len(linelengths) != len(positions):
            raise ValueError('linelengths and positions are unequal sized sequences')
        if len(linewidths) != len(positions):
            raise ValueError('linewidths and positions are unequal sized sequences')
        if len(colors) != len(positions):
            raise ValueError('colors and positions are unequal sized sequences')
        if len(alpha) != len(positions):
            raise ValueError('alpha and positions are unequal sized sequences')
        if len(linestyles) != len(positions):
            raise ValueError('linestyles and positions are unequal sized sequences')
        colls = []
        for (position, lineoffset, linelength, linewidth, color, alpha_, linestyle) in zip(positions, lineoffsets, linelengths, linewidths, colors, alpha, linestyles):
            coll = mcoll.EventCollection(position, orientation=orientation, lineoffset=lineoffset, linelength=linelength, linewidth=linewidth, color=color, alpha=alpha_, linestyle=linestyle)
            self.add_collection(coll, autolim=False)
            coll._internal_update(kwargs)
            colls.append(coll)
        if len(positions) > 0:
            min_max = [(np.min(_p), np.max(_p)) for _p in positions if len(_p) > 0]
            if len(min_max) > 0:
                (mins, maxes) = zip(*min_max)
                minpos = np.min(mins)
                maxpos = np.max(maxes)
                minline = (lineoffsets - linelengths).min()
                maxline = (lineoffsets + linelengths).max()
                if orientation == 'vertical':
                    corners = ((minline, minpos), (maxline, maxpos))
                else:
                    corners = ((minpos, minline), (maxpos, maxline))
                self.update_datalim(corners)
                self._request_autoscale_view()
        return colls

    @_docstring.dedent_interpd
    def plot(self, *args, scalex=True, scaley=True, data=None, **kwargs):
        kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
        lines = [*self._get_lines(self, *args, data=data, **kwargs)]
        for line in lines:
            self.add_line(line)
        if scalex:
            self._request_autoscale_view('x')
        if scaley:
            self._request_autoscale_view('y')
        return lines

    @_api.deprecated('3.9', alternative='plot')
    @_preprocess_data(replace_names=['x', 'y'], label_namer='y')
    @_docstring.dedent_interpd
    def plot_date(self, x, y, fmt='o', tz=None, xdate=True, ydate=False, **kwargs):
        if xdate:
            self.xaxis_date(tz)
        if ydate:
            self.yaxis_date(tz)
        return self.plot(x, y, fmt, **kwargs)

    @_docstring.dedent_interpd
    def loglog(self, *args, **kwargs):
        dx = {k: v for (k, v) in kwargs.items() if k in ['base', 'subs', 'nonpositive', 'basex', 'subsx', 'nonposx']}
        self.set_xscale('log', **dx)
        dy = {k: v for (k, v) in kwargs.items() if k in ['base', 'subs', 'nonpositive', 'basey', 'subsy', 'nonposy']}
        self.set_yscale('log', **dy)
        return self.plot(*args, **{k: v for (k, v) in kwargs.items() if k not in {*dx, *dy}})

    @_docstring.dedent_interpd
    def semilogx(self, *args, **kwargs):
        d = {k: v for (k, v) in kwargs.items() if k in ['base', 'subs', 'nonpositive', 'basex', 'subsx', 'nonposx']}
        self.set_xscale('log', **d)
        return self.plot(*args, **{k: v for (k, v) in kwargs.items() if k not in d})

    @_docstring.dedent_interpd
    def semilogy(self, *args, **kwargs):
        d = {k: v for (k, v) in kwargs.items() if k in ['base', 'subs', 'nonpositive', 'basey', 'subsy', 'nonposy']}
        self.set_yscale('log', **d)
        return self.plot(*args, **{k: v for (k, v) in kwargs.items() if k not in d})

    @_preprocess_data(replace_names=['x'], label_namer='x')
    def acorr(self, x, **kwargs):
        return self.xcorr(x, x, **kwargs)

    @_api.make_keyword_only('3.9', 'normed')
    @_preprocess_data(replace_names=['x', 'y'], label_namer='y')
    def xcorr(self, x, y, normed=True, detrend=mlab.detrend_none, usevlines=True, maxlags=10, **kwargs):
        Nx = len(x)
        if Nx != len(y):
            raise ValueError('x and y must be equal length')
        x = detrend(np.asarray(x))
        y = detrend(np.asarray(y))
        correls = np.correlate(x, y, mode='full')
        if normed:
            correls = correls / np.sqrt(np.dot(x, x) * np.dot(y, y))
        if maxlags is None:
            maxlags = Nx - 1
        if maxlags >= Nx or maxlags < 1:
            raise ValueError('maxlags must be None or strictly positive < %d' % Nx)
        lags = np.arange(-maxlags, maxlags + 1)
        correls = correls[Nx - 1 - maxlags:Nx + maxlags]
        if usevlines:
            a = self.vlines(lags, [0], correls, **kwargs)
            kwargs.pop('label', '')
            b = self.axhline(**kwargs)
        else:
            kwargs.setdefault('marker', 'o')
            kwargs.setdefault('linestyle', 'None')
            (a,) = self.plot(lags, correls, **kwargs)
            b = None
        return (lags, correls, a, b)

    def step(self, x, y, *args, where='pre', data=None, **kwargs):
        _api.check_in_list(('pre', 'post', 'mid'), where=where)
        kwargs['drawstyle'] = 'steps-' + where
        return self.plot(x, y, *args, data=data, **kwargs)

    @staticmethod
    def _convert_dx(dx, x0, xconv, convert):
        assert type(xconv) is np.ndarray
        if xconv.size == 0:
            return convert(dx)
        try:
            try:
                x0 = cbook._safe_first_finite(x0)
            except (TypeError, IndexError, KeyError):
                pass
            try:
                x = cbook._safe_first_finite(xconv)
            except (TypeError, IndexError, KeyError):
                x = xconv
            delist = False
            if not np.iterable(dx):
                dx = [dx]
                delist = True
            dx = [convert(x0 + ddx) - x for ddx in dx]
            if delist:
                dx = dx[0]
        except (ValueError, TypeError, AttributeError):
            dx = convert(dx)
        return dx

    @_preprocess_data()
    @_docstring.dedent_interpd
    def bar(self, x, height, width=0.8, bottom=None, *, align='center', **kwargs):
        kwargs = cbook.normalize_kwargs(kwargs, mpatches.Patch)
        color = kwargs.pop('color', None)
        if color is None:
            color = self._get_patches_for_fill.get_next_color()
        edgecolor = kwargs.pop('edgecolor', None)
        linewidth = kwargs.pop('linewidth', None)
        hatch = kwargs.pop('hatch', None)
        xerr = kwargs.pop('xerr', None)
        yerr = kwargs.pop('yerr', None)
        error_kw = kwargs.pop('error_kw', None)
        error_kw = {} if error_kw is None else error_kw.copy()
        ezorder = error_kw.pop('zorder', None)
        if ezorder is None:
            ezorder = kwargs.get('zorder', None)
            if ezorder is not None:
                ezorder += 0.01
        error_kw.setdefault('zorder', ezorder)
        ecolor = kwargs.pop('ecolor', 'k')
        capsize = kwargs.pop('capsize', mpl.rcParams['errorbar.capsize'])
        error_kw.setdefault('ecolor', ecolor)
        error_kw.setdefault('capsize', capsize)
        orientation = kwargs.pop('orientation', 'vertical')
        _api.check_in_list(['vertical', 'horizontal'], orientation=orientation)
        log = kwargs.pop('log', False)
        label = kwargs.pop('label', '')
        tick_labels = kwargs.pop('tick_label', None)
        y = bottom
        if orientation == 'vertical':
            if y is None:
                y = 0
        elif x is None:
            x = 0
        if orientation == 'vertical':
            self._process_unit_info([('x', x), ('y', y), ('y', height)], kwargs, convert=False)
            if log:
                self.set_yscale('log', nonpositive='clip')
        else:
            self._process_unit_info([('x', x), ('x', width), ('y', y)], kwargs, convert=False)
            if log:
                self.set_xscale('log', nonpositive='clip')
        if self.xaxis is not None:
            x0 = x
            x = np.asarray(self.convert_xunits(x))
            width = self._convert_dx(width, x0, x, self.convert_xunits)
            if xerr is not None:
                xerr = self._convert_dx(xerr, x0, x, self.convert_xunits)
        if self.yaxis is not None:
            y0 = y
            y = np.asarray(self.convert_yunits(y))
            height = self._convert_dx(height, y0, y, self.convert_yunits)
            if yerr is not None:
                yerr = self._convert_dx(yerr, y0, y, self.convert_yunits)
        (x, height, width, y, linewidth, hatch) = np.broadcast_arrays(np.atleast_1d(x), height, width, y, linewidth, hatch)
        if orientation == 'vertical':
            tick_label_axis = self.xaxis
            tick_label_position = x
        else:
            tick_label_axis = self.yaxis
            tick_label_position = y
        if not isinstance(label, str) and np.iterable(label):
            bar_container_label = '_nolegend_'
            patch_labels = label
        else:
            bar_container_label = label
            patch_labels = ['_nolegend_'] * len(x)
        if len(patch_labels) != len(x):
            raise ValueError(f'number of labels ({len(patch_labels)}) does not match number of bars ({len(x)}).')
        linewidth = itertools.cycle(np.atleast_1d(linewidth))
        hatch = itertools.cycle(np.atleast_1d(hatch))
        color = itertools.chain(itertools.cycle(mcolors.to_rgba_array(color)), itertools.repeat('none'))
        if edgecolor is None:
            edgecolor = itertools.repeat(None)
        else:
            edgecolor = itertools.chain(itertools.cycle(mcolors.to_rgba_array(edgecolor)), itertools.repeat('none'))
        _api.check_in_list(['center', 'edge'], align=align)
        if align == 'center':
            if orientation == 'vertical':
                try:
                    left = x - width / 2
                except TypeError as e:
                    raise TypeError(f'the dtypes of parameters x ({x.dtype}) and width ({width.dtype}) are incompatible') from e
                bottom = y
            else:
                try:
                    bottom = y - height / 2
                except TypeError as e:
                    raise TypeError(f'the dtypes of parameters y ({y.dtype}) and height ({height.dtype}) are incompatible') from e
                left = x
        else:
            left = x
            bottom = y
        patches = []
        args = zip(left, bottom, width, height, color, edgecolor, linewidth, hatch, patch_labels)
        for (l, b, w, h, c, e, lw, htch, lbl) in args:
            r = mpatches.Rectangle(xy=(l, b), width=w, height=h, facecolor=c, edgecolor=e, linewidth=lw, label=lbl, hatch=htch)
            r._internal_update(kwargs)
            r.get_path()._interpolation_steps = 100
            if orientation == 'vertical':
                r.sticky_edges.y.append(b)
            else:
                r.sticky_edges.x.append(l)
            self.add_patch(r)
            patches.append(r)
        if xerr is not None or yerr is not None:
            if orientation == 'vertical':
                ex = [l + 0.5 * w for (l, w) in zip(left, width)]
                ey = [b + h for (b, h) in zip(bottom, height)]
            else:
                ex = [l + w for (l, w) in zip(left, width)]
                ey = [b + 0.5 * h for (b, h) in zip(bottom, height)]
            error_kw.setdefault('label', '_nolegend_')
            errorbar = self.errorbar(ex, ey, yerr=yerr, xerr=xerr, fmt='none', **error_kw)
        else:
            errorbar = None
        self._request_autoscale_view()
        if orientation == 'vertical':
            datavalues = height
        else:
            datavalues = width
        bar_container = BarContainer(patches, errorbar, datavalues=datavalues, orientation=orientation, label=bar_container_label)
        self.add_container(bar_container)
        if tick_labels is not None:
            tick_labels = np.broadcast_to(tick_labels, len(patches))
            tick_label_axis.set_ticks(tick_label_position)
            tick_label_axis.set_ticklabels(tick_labels)
        return bar_container

    @_docstring.dedent_interpd
    def barh(self, y, width, height=0.8, left=None, *, align='center', data=None, **kwargs):
        kwargs.setdefault('orientation', 'horizontal')
        patches = self.bar(x=left, height=height, width=width, bottom=y, align=align, data=data, **kwargs)
        return patches

    def bar_label(self, container, labels=None, *, fmt='%g', label_type='edge', padding=0, **kwargs):
        for key in ['horizontalalignment', 'ha', 'verticalalignment', 'va']:
            if key in kwargs:
                raise ValueError(f'Passing {key!r} to bar_label() is not supported.')
        (a, b) = self.yaxis.get_view_interval()
        y_inverted = a > b
        (c, d) = self.xaxis.get_view_interval()
        x_inverted = c > d

        def sign(x):
            return 1 if x >= 0 else -1
        _api.check_in_list(['edge', 'center'], label_type=label_type)
        bars = container.patches
        errorbar = container.errorbar
        datavalues = container.datavalues
        orientation = container.orientation
        if errorbar:
            lines = errorbar.lines
            barlinecols = lines[2]
            barlinecol = barlinecols[0]
            errs = barlinecol.get_segments()
        else:
            errs = []
        if labels is None:
            labels = []
        annotations = []
        for (bar, err, dat, lbl) in itertools.zip_longest(bars, errs, datavalues, labels):
            ((x0, y0), (x1, y1)) = bar.get_bbox().get_points()
            (xc, yc) = ((x0 + x1) / 2, (y0 + y1) / 2)
            if orientation == 'vertical':
                extrema = max(y0, y1) if dat >= 0 else min(y0, y1)
                length = abs(y0 - y1)
            else:
                extrema = max(x0, x1) if dat >= 0 else min(x0, x1)
                length = abs(x0 - x1)
            if err is None or np.size(err) == 0:
                endpt = extrema
            elif orientation == 'vertical':
                endpt = err[:, 1].max() if dat >= 0 else err[:, 1].min()
            else:
                endpt = err[:, 0].max() if dat >= 0 else err[:, 0].min()
            if label_type == 'center':
                value = sign(dat) * length
            else:
                value = extrema
            if label_type == 'center':
                xy = (0.5, 0.5)
                kwargs['xycoords'] = lambda r, b=bar: mtransforms.Bbox.intersection(b.get_window_extent(r), b.get_clip_box()) or mtransforms.Bbox.null()
            elif orientation == 'vertical':
                xy = (xc, endpt)
            else:
                xy = (endpt, yc)
            if orientation == 'vertical':
                y_direction = -1 if y_inverted else 1
                xytext = (0, y_direction * sign(dat) * padding)
            else:
                x_direction = -1 if x_inverted else 1
                xytext = (x_direction * sign(dat) * padding, 0)
            if label_type == 'center':
                (ha, va) = ('center', 'center')
            elif orientation == 'vertical':
                ha = 'center'
                if y_inverted:
                    va = 'top' if dat > 0 else 'bottom'
                else:
                    va = 'top' if dat < 0 else 'bottom'
            else:
                if x_inverted:
                    ha = 'right' if dat > 0 else 'left'
                else:
                    ha = 'right' if dat < 0 else 'left'
                va = 'center'
            if np.isnan(dat):
                lbl = ''
            if lbl is None:
                if isinstance(fmt, str):
                    lbl = cbook._auto_format_str(fmt, value)
                elif callable(fmt):
                    lbl = fmt(value)
                else:
                    raise TypeError('fmt must be a str or callable')
            annotation = self.annotate(lbl, xy, xytext, textcoords='offset points', ha=ha, va=va, **kwargs)
            annotations.append(annotation)
        return annotations

    @_preprocess_data()
    @_docstring.dedent_interpd
    def broken_barh(self, xranges, yrange, **kwargs):
        xdata = cbook._safe_first_finite(xranges) if len(xranges) else None
        ydata = cbook._safe_first_finite(yrange) if len(yrange) else None
        self._process_unit_info([('x', xdata), ('y', ydata)], kwargs, convert=False)
        vertices = []
        (y0, dy) = yrange
        (y0, y1) = self.convert_yunits((y0, y0 + dy))
        for xr in xranges:
            try:
                (x0, dx) = xr
            except Exception:
                raise ValueError('each range in xrange must be a sequence with two elements (i.e. xrange must be an (N, 2) array)') from None
            (x0, x1) = self.convert_xunits((x0, x0 + dx))
            vertices.append([(x0, y0), (x0, y1), (x1, y1), (x1, y0)])
        col = mcoll.PolyCollection(np.array(vertices), **kwargs)
        self.add_collection(col, autolim=True)
        self._request_autoscale_view()
        return col

    @_preprocess_data()
    def stem(self, *args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, label=None, orientation='vertical'):
        if not 1 <= len(args) <= 3:
            raise _api.nargs_error('stem', '1-3', len(args))
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        if len(args) == 1:
            (heads,) = args
            locs = np.arange(len(heads))
            args = ()
        elif isinstance(args[1], str):
            (heads, *args) = args
            locs = np.arange(len(heads))
        else:
            (locs, heads, *args) = args
        if orientation == 'vertical':
            (locs, heads) = self._process_unit_info([('x', locs), ('y', heads)])
        else:
            (heads, locs) = self._process_unit_info([('x', heads), ('y', locs)])
        if linefmt is None:
            linefmt = args[0] if len(args) > 0 else 'C0-'
        (linestyle, linemarker, linecolor) = _process_plot_format(linefmt)
        if markerfmt is None:
            markerfmt = 'o'
        if markerfmt == '':
            markerfmt = ' '
        (markerstyle, markermarker, markercolor) = _process_plot_format(markerfmt)
        if markermarker is None:
            markermarker = 'o'
        if markerstyle is None:
            markerstyle = 'None'
        if markercolor is None:
            markercolor = linecolor
        if basefmt is None:
            basefmt = 'C2-' if mpl.rcParams['_internal.classic_mode'] else 'C3-'
        (basestyle, basemarker, basecolor) = _process_plot_format(basefmt)
        if linestyle is None:
            linestyle = mpl.rcParams['lines.linestyle']
        xlines = self.vlines if orientation == 'vertical' else self.hlines
        stemlines = xlines(locs, bottom, heads, colors=linecolor, linestyles=linestyle, label='_nolegend_')
        if orientation == 'horizontal':
            marker_x = heads
            marker_y = locs
            baseline_x = [bottom, bottom]
            baseline_y = [np.min(locs), np.max(locs)]
        else:
            marker_x = locs
            marker_y = heads
            baseline_x = [np.min(locs), np.max(locs)]
            baseline_y = [bottom, bottom]
        (markerline,) = self.plot(marker_x, marker_y, color=markercolor, linestyle=markerstyle, marker=markermarker, label='_nolegend_')
        (baseline,) = self.plot(baseline_x, baseline_y, color=basecolor, linestyle=basestyle, marker=basemarker, label='_nolegend_')
        stem_container = StemContainer((markerline, stemlines, baseline), label=label)
        self.add_container(stem_container)
        return stem_container

    @_api.make_keyword_only('3.9', 'explode')
    @_preprocess_data(replace_names=['x', 'explode', 'labels', 'colors'])
    def pie(self, x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, normalize=True, hatch=None):
        self.set_aspect('equal')
        x = np.asarray(x, np.float32)
        if x.ndim > 1:
            raise ValueError('x must be 1D')
        if np.any(x < 0):
            raise ValueError("Wedge sizes 'x' must be non negative values")
        sx = x.sum()
        if normalize:
            x = x / sx
        elif sx > 1:
            raise ValueError('Cannot plot an unnormalized pie with sum(x) > 1')
        if labels is None:
            labels = [''] * len(x)
        if explode is None:
            explode = [0] * len(x)
        if len(x) != len(labels):
            raise ValueError("'label' must be of length 'x'")
        if len(x) != len(explode):
            raise ValueError("'explode' must be of length 'x'")
        if colors is None:
            get_next_color = self._get_patches_for_fill.get_next_color
        else:
            color_cycle = itertools.cycle(colors)

            def get_next_color():
                return next(color_cycle)
        hatch_cycle = itertools.cycle(np.atleast_1d(hatch))
        _api.check_isinstance(Real, radius=radius, startangle=startangle)
        if radius <= 0:
            raise ValueError(f'radius must be a positive number, not {radius}')
        theta1 = startangle / 360
        if wedgeprops is None:
            wedgeprops = {}
        if textprops is None:
            textprops = {}
        texts = []
        slices = []
        autotexts = []
        for (frac, label, expl) in zip(x, labels, explode):
            (x, y) = center
            theta2 = theta1 + frac if counterclock else theta1 - frac
            thetam = 2 * np.pi * 0.5 * (theta1 + theta2)
            x += expl * math.cos(thetam)
            y += expl * math.sin(thetam)
            w = mpatches.Wedge((x, y), radius, 360.0 * min(theta1, theta2), 360.0 * max(theta1, theta2), facecolor=get_next_color(), hatch=next(hatch_cycle), clip_on=False, label=label)
            w.set(**wedgeprops)
            slices.append(w)
            self.add_patch(w)
            if shadow:
                shadow_dict = {'ox': -0.02, 'oy': -0.02, 'label': '_nolegend_'}
                if isinstance(shadow, dict):
                    shadow_dict.update(shadow)
                self.add_patch(mpatches.Shadow(w, **shadow_dict))
            if labeldistance is not None:
                xt = x + labeldistance * radius * math.cos(thetam)
                yt = y + labeldistance * radius * math.sin(thetam)
                label_alignment_h = 'left' if xt > 0 else 'right'
                label_alignment_v = 'center'
                label_rotation = 'horizontal'
                if rotatelabels:
                    label_alignment_v = 'bottom' if yt > 0 else 'top'
                    label_rotation = np.rad2deg(thetam) + (0 if xt > 0 else 180)
                t = self.text(xt, yt, label, clip_on=False, horizontalalignment=label_alignment_h, verticalalignment=label_alignment_v, rotation=label_rotation, size=mpl.rcParams['xtick.labelsize'])
                t.set(**textprops)
                texts.append(t)
            if autopct is not None:
                xt = x + pctdistance * radius * math.cos(thetam)
                yt = y + pctdistance * radius * math.sin(thetam)
                if isinstance(autopct, str):
                    s = autopct % (100.0 * frac)
                elif callable(autopct):
                    s = autopct(100.0 * frac)
                else:
                    raise TypeError('autopct must be callable or a format string')
                if mpl._val_or_rc(textprops.get('usetex'), 'text.usetex'):
                    s = re.sub('([^\\\\])%', '\\1\\\\%', s)
                t = self.text(xt, yt, s, clip_on=False, horizontalalignment='center', verticalalignment='center')
                t.set(**textprops)
                autotexts.append(t)
            theta1 = theta2
        if frame:
            self._request_autoscale_view()
        else:
            self.set(frame_on=False, xticks=[], yticks=[], xlim=(-1.25 + center[0], 1.25 + center[0]), ylim=(-1.25 + center[1], 1.25 + center[1]))
        if autopct is None:
            return (slices, texts)
        else:
            return (slices, texts, autotexts)

    @staticmethod
    def _errorevery_to_mask(x, errorevery):
        if isinstance(errorevery, Integral):
            errorevery = (0, errorevery)
        if isinstance(errorevery, tuple):
            if len(errorevery) == 2 and isinstance(errorevery[0], Integral) and isinstance(errorevery[1], Integral):
                errorevery = slice(errorevery[0], None, errorevery[1])
            else:
                raise ValueError(f'errorevery={errorevery!r} is a not a tuple of two integers')
        elif isinstance(errorevery, slice):
            pass
        elif not isinstance(errorevery, str) and np.iterable(errorevery):
            try:
                x[errorevery]
            except (ValueError, IndexError) as err:
                raise ValueError(f"errorevery={errorevery!r} is iterable but not a valid NumPy fancy index to match 'xerr'/'yerr'") from err
        else:
            raise ValueError(f'errorevery={errorevery!r} is not a recognized value')
        everymask = np.zeros(len(x), bool)
        everymask[errorevery] = True
        return everymask

    @_api.make_keyword_only('3.9', 'ecolor')
    @_preprocess_data(replace_names=['x', 'y', 'xerr', 'yerr'], label_namer='y')
    @_docstring.dedent_interpd
    def errorbar(self, x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, **kwargs):
        kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
        kwargs = {k: v for (k, v) in kwargs.items() if v is not None}
        kwargs.setdefault('zorder', 2)
        if not isinstance(x, np.ndarray):
            x = np.asarray(x, dtype=object)
        if not isinstance(y, np.ndarray):
            y = np.asarray(y, dtype=object)

        def _upcast_err(err):
            if np.iterable(err) and len(err) > 0 and isinstance(cbook._safe_first_finite(err), np.ndarray):
                atype = type(cbook._safe_first_finite(err))
                if atype is np.ndarray:
                    return np.asarray(err, dtype=object)
                return atype(err)
            return np.asarray(err, dtype=object)
        if xerr is not None and (not isinstance(xerr, np.ndarray)):
            xerr = _upcast_err(xerr)
        if yerr is not None and (not isinstance(yerr, np.ndarray)):
            yerr = _upcast_err(yerr)
        (x, y) = np.atleast_1d(x, y)
        if len(x) != len(y):
            raise ValueError("'x' and 'y' must have the same size")
        everymask = self._errorevery_to_mask(x, errorevery)
        label = kwargs.pop('label', None)
        kwargs['label'] = '_nolegend_'
        ((data_line, base_style),) = self._get_lines._plot_args(self, (x, y) if fmt == '' else (x, y, fmt), kwargs, return_kwargs=True)
        if barsabove:
            data_line.set_zorder(kwargs['zorder'] - 0.1)
        else:
            data_line.set_zorder(kwargs['zorder'] + 0.1)
        if fmt.lower() != 'none':
            self.add_line(data_line)
        else:
            data_line = None
            base_style.pop('color')
            if 'color' in kwargs:
                base_style['color'] = kwargs.pop('color')
        if 'color' not in base_style:
            base_style['color'] = 'C0'
        if ecolor is None:
            ecolor = base_style['color']
        for key in ['marker', 'markersize', 'markerfacecolor', 'markerfacecoloralt', 'markeredgewidth', 'markeredgecolor', 'markevery', 'linestyle', 'fillstyle', 'drawstyle', 'dash_capstyle', 'dash_joinstyle', 'solid_capstyle', 'solid_joinstyle', 'dashes']:
            base_style.pop(key, None)
        eb_lines_style = {**base_style, 'color': ecolor}
        if elinewidth is not None:
            eb_lines_style['linewidth'] = elinewidth
        elif 'linewidth' in kwargs:
            eb_lines_style['linewidth'] = kwargs['linewidth']
        for key in ('transform', 'alpha', 'zorder', 'rasterized'):
            if key in kwargs:
                eb_lines_style[key] = kwargs[key]
        eb_cap_style = {**base_style, 'linestyle': 'none'}
        if capsize is None:
            capsize = mpl.rcParams['errorbar.capsize']
        if capsize > 0:
            eb_cap_style['markersize'] = 2.0 * capsize
        if capthick is not None:
            eb_cap_style['markeredgewidth'] = capthick
        for key in ('markeredgewidth', 'transform', 'alpha', 'zorder', 'rasterized'):
            if key in kwargs:
                eb_cap_style[key] = kwargs[key]
        eb_cap_style['color'] = ecolor
        barcols = []
        caplines = {'x': [], 'y': []}

        def apply_mask(arrays, mask):
            return [array[mask] for array in arrays]
        for (dep_axis, dep, err, lolims, uplims, indep, lines_func, marker, lomarker, himarker) in [('x', x, xerr, xlolims, xuplims, y, self.hlines, '|', mlines.CARETRIGHTBASE, mlines.CARETLEFTBASE), ('y', y, yerr, lolims, uplims, x, self.vlines, '_', mlines.CARETUPBASE, mlines.CARETDOWNBASE)]:
            if err is None:
                continue
            lolims = np.broadcast_to(lolims, len(dep)).astype(bool)
            uplims = np.broadcast_to(uplims, len(dep)).astype(bool)
            try:
                np.broadcast_to(err, (2, len(dep)))
            except ValueError:
                raise ValueError(f"'{dep_axis}err' (shape: {np.shape(err)}) must be a scalar or a 1D or (2, n) array-like whose shape matches '{dep_axis}' (shape: {np.shape(dep)})") from None
            if err.dtype is np.dtype(object) and np.any(err == None):
                raise ValueError(f"'{dep_axis}err' must not contain None. Use NaN if you want to skip a value.")
            res = np.zeros(err.shape, dtype=bool)
            if np.any(np.less(err, -err, out=res, where=err == err)):
                raise ValueError(f"'{dep_axis}err' must not contain negative values")
            (low, high) = dep + np.vstack([-(1 - lolims), 1 - uplims]) * err
            barcols.append(lines_func(*apply_mask([indep, low, high], everymask), **eb_lines_style))
            if self.name == 'polar' and dep_axis == 'x':
                for b in barcols:
                    for p in b.get_paths():
                        p._interpolation_steps = 2
            nolims = ~(lolims | uplims)
            if nolims.any() and capsize > 0:
                (indep_masked, lo_masked, hi_masked) = apply_mask([indep, low, high], nolims & everymask)
                for lh_masked in [lo_masked, hi_masked]:
                    line = mlines.Line2D(indep_masked, indep_masked, marker=marker, **eb_cap_style)
                    line.set(**{f'{dep_axis}data': lh_masked})
                    caplines[dep_axis].append(line)
            for (idx, (lims, hl)) in enumerate([(lolims, high), (uplims, low)]):
                if not lims.any():
                    continue
                hlmarker = himarker if self._axis_map[dep_axis].get_inverted() ^ idx else lomarker
                (x_masked, y_masked, hl_masked) = apply_mask([x, y, hl], lims & everymask)
                line = mlines.Line2D(x_masked, y_masked, marker=hlmarker, **eb_cap_style)
                line.set(**{f'{dep_axis}data': hl_masked})
                caplines[dep_axis].append(line)
                if capsize > 0:
                    caplines[dep_axis].append(mlines.Line2D(x_masked, y_masked, marker=marker, **eb_cap_style))
        if self.name == 'polar':
            for axis in caplines:
                for l in caplines[axis]:
                    for (theta, r) in zip(l.get_xdata(), l.get_ydata()):
                        rotation = mtransforms.Affine2D().rotate(theta)
                        if axis == 'y':
                            rotation.rotate(-np.pi / 2)
                        ms = mmarkers.MarkerStyle(marker=marker, transform=rotation)
                        self.add_line(mlines.Line2D([theta], [r], marker=ms, **eb_cap_style))
        else:
            for axis in caplines:
                for l in caplines[axis]:
                    self.add_line(l)
        self._request_autoscale_view()
        caplines = caplines['x'] + caplines['y']
        errorbar_container = ErrorbarContainer((data_line, tuple(caplines), tuple(barcols)), has_xerr=xerr is not None, has_yerr=yerr is not None, label=label)
        self.containers.append(errorbar_container)
        return errorbar_container

    @_api.make_keyword_only('3.9', 'notch')
    @_preprocess_data()
    @_api.rename_parameter('3.9', 'labels', 'tick_labels')
    def boxplot(self, x, notch=None, sym=None, vert=None, orientation='vertical', whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, tick_labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_ticks=True, autorange=False, zorder=None, capwidths=None, label=None):
        if whis is None:
            whis = mpl.rcParams['boxplot.whiskers']
        if bootstrap is None:
            bootstrap = mpl.rcParams['boxplot.bootstrap']
        bxpstats = cbook.boxplot_stats(x, whis=whis, bootstrap=bootstrap, labels=tick_labels, autorange=autorange)
        if notch is None:
            notch = mpl.rcParams['boxplot.notch']
        if patch_artist is None:
            patch_artist = mpl.rcParams['boxplot.patchartist']
        if meanline is None:
            meanline = mpl.rcParams['boxplot.meanline']
        if showmeans is None:
            showmeans = mpl.rcParams['boxplot.showmeans']
        if showcaps is None:
            showcaps = mpl.rcParams['boxplot.showcaps']
        if showbox is None:
            showbox = mpl.rcParams['boxplot.showbox']
        if showfliers is None:
            showfliers = mpl.rcParams['boxplot.showfliers']
        if boxprops is None:
            boxprops = {}
        if whiskerprops is None:
            whiskerprops = {}
        if capprops is None:
            capprops = {}
        if medianprops is None:
            medianprops = {}
        if meanprops is None:
            meanprops = {}
        if flierprops is None:
            flierprops = {}
        if patch_artist:
            boxprops['linestyle'] = 'solid'
            if 'color' in boxprops:
                boxprops['edgecolor'] = boxprops.pop('color')
        if sym is not None:
            if sym == '':
                flierprops = dict(linestyle='none', marker='', color='none')
                showfliers = False
            else:
                (_, marker, color) = _process_plot_format(sym)
                if marker is not None:
                    flierprops['marker'] = marker
                if color is not None:
                    flierprops['color'] = color
                    flierprops['markerfacecolor'] = color
                    flierprops['markeredgecolor'] = color
        if usermedians is not None:
            if len(np.ravel(usermedians)) != len(bxpstats) or np.shape(usermedians)[0] != len(bxpstats):
                raise ValueError("'usermedians' and 'x' have different lengths")
            else:
                for (stats, med) in zip(bxpstats, usermedians):
                    if med is not None:
                        stats['med'] = med
        if conf_intervals is not None:
            if len(conf_intervals) != len(bxpstats):
                raise ValueError("'conf_intervals' and 'x' have different lengths")
            else:
                for (stats, ci) in zip(bxpstats, conf_intervals):
                    if ci is not None:
                        if len(ci) != 2:
                            raise ValueError('each confidence interval must have two values')
                        else:
                            if ci[0] is not None:
                                stats['cilo'] = ci[0]
                            if ci[1] is not None:
                                stats['cihi'] = ci[1]
        artists = self.bxp(bxpstats, positions=positions, widths=widths, vert=vert, patch_artist=patch_artist, shownotches=notch, showmeans=showmeans, showcaps=showcaps, showbox=showbox, boxprops=boxprops, flierprops=flierprops, medianprops=medianprops, meanprops=meanprops, meanline=meanline, showfliers=showfliers, capprops=capprops, whiskerprops=whiskerprops, manage_ticks=manage_ticks, zorder=zorder, capwidths=capwidths, label=label, orientation=orientation)
        return artists

    @_api.make_keyword_only('3.9', 'widths')
    def bxp(self, bxpstats, positions=None, widths=None, vert=None, orientation='vertical', patch_artist=False, shownotches=False, showmeans=False, showcaps=True, showbox=True, showfliers=True, boxprops=None, whiskerprops=None, flierprops=None, medianprops=None, capprops=None, meanprops=None, meanline=False, manage_ticks=True, zorder=None, capwidths=None, label=None):
        medianprops = {'solid_capstyle': 'butt', 'dash_capstyle': 'butt', **(medianprops or {})}
        meanprops = {'solid_capstyle': 'butt', 'dash_capstyle': 'butt', **(meanprops or {})}
        whiskers = []
        caps = []
        boxes = []
        medians = []
        means = []
        fliers = []
        datalabels = []
        if zorder is None:
            zorder = mlines.Line2D.zorder
        zdelta = 0.1

        def merge_kw_rc(subkey, explicit, zdelta=0, usemarker=True):
            d = {k.split('.')[-1]: v for (k, v) in mpl.rcParams.items() if k.startswith(f'boxplot.{subkey}props')}
            d['zorder'] = zorder + zdelta
            if not usemarker:
                d['marker'] = ''
            d.update(cbook.normalize_kwargs(explicit, mlines.Line2D))
            return d
        box_kw = {'linestyle': mpl.rcParams['boxplot.boxprops.linestyle'], 'linewidth': mpl.rcParams['boxplot.boxprops.linewidth'], 'edgecolor': mpl.rcParams['boxplot.boxprops.color'], 'facecolor': 'white' if mpl.rcParams['_internal.classic_mode'] else mpl.rcParams['patch.facecolor'], 'zorder': zorder, **cbook.normalize_kwargs(boxprops, mpatches.PathPatch)} if patch_artist else merge_kw_rc('box', boxprops, usemarker=False)
        whisker_kw = merge_kw_rc('whisker', whiskerprops, usemarker=False)
        cap_kw = merge_kw_rc('cap', capprops, usemarker=False)
        flier_kw = merge_kw_rc('flier', flierprops)
        median_kw = merge_kw_rc('median', medianprops, zdelta, usemarker=False)
        mean_kw = merge_kw_rc('mean', meanprops, zdelta)
        removed_prop = 'marker' if meanline else 'linestyle'
        if meanprops is None or removed_prop not in meanprops:
            mean_kw[removed_prop] = ''
        if vert is None:
            vert = mpl.rcParams['boxplot.vertical']
        else:
            _api.warn_deprecated('3.10', name='vert: bool', alternative="orientation: {'vertical', 'horizontal'}")
        if vert is False:
            orientation = 'horizontal'
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        if not mpl.rcParams['boxplot.vertical']:
            _api.warn_deprecated('3.10', name='boxplot.vertical', obj_type='rcparam')
        maybe_swap = slice(None) if orientation == 'vertical' else slice(None, None, -1)

        def do_plot(xs, ys, **kwargs):
            return self.plot(*[xs, ys][maybe_swap], **kwargs)[0]

        def do_patch(xs, ys, **kwargs):
            path = mpath.Path._create_closed(np.column_stack([xs, ys][maybe_swap]))
            patch = mpatches.PathPatch(path, **kwargs)
            self.add_artist(patch)
            return patch
        N = len(bxpstats)
        datashape_message = 'List of boxplot statistics and `{0}` values must have same the length'
        if positions is None:
            positions = list(range(1, N + 1))
        elif len(positions) != N:
            raise ValueError(datashape_message.format('positions'))
        positions = np.array(positions)
        if len(positions) > 0 and (not all((isinstance(p, Real) for p in positions))):
            raise TypeError('positions should be an iterable of numbers')
        if widths is None:
            widths = [np.clip(0.15 * np.ptp(positions), 0.15, 0.5)] * N
        elif np.isscalar(widths):
            widths = [widths] * N
        elif len(widths) != N:
            raise ValueError(datashape_message.format('widths'))
        if capwidths is None:
            capwidths = 0.5 * np.array(widths)
        elif np.isscalar(capwidths):
            capwidths = [capwidths] * N
        elif len(capwidths) != N:
            raise ValueError(datashape_message.format('capwidths'))
        for (pos, width, stats, capwidth) in zip(positions, widths, bxpstats, capwidths):
            datalabels.append(stats.get('label', pos))
            whis_x = [pos, pos]
            whislo_y = [stats['q1'], stats['whislo']]
            whishi_y = [stats['q3'], stats['whishi']]
            cap_left = pos - capwidth * 0.5
            cap_right = pos + capwidth * 0.5
            cap_x = [cap_left, cap_right]
            cap_lo = np.full(2, stats['whislo'])
            cap_hi = np.full(2, stats['whishi'])
            box_left = pos - width * 0.5
            box_right = pos + width * 0.5
            med_y = [stats['med'], stats['med']]
            if shownotches:
                notch_left = pos - width * 0.25
                notch_right = pos + width * 0.25
                box_x = [box_left, box_right, box_right, notch_right, box_right, box_right, box_left, box_left, notch_left, box_left, box_left]
                box_y = [stats['q1'], stats['q1'], stats['cilo'], stats['med'], stats['cihi'], stats['q3'], stats['q3'], stats['cihi'], stats['med'], stats['cilo'], stats['q1']]
                med_x = [notch_left, notch_right]
            else:
                box_x = [box_left, box_right, box_right, box_left, box_left]
                box_y = [stats['q1'], stats['q1'], stats['q3'], stats['q3'], stats['q1']]
                med_x = [box_left, box_right]
            if showbox:
                do_box = do_patch if patch_artist else do_plot
                boxes.append(do_box(box_x, box_y, **box_kw))
                median_kw.setdefault('label', '_nolegend_')
            whisker_kw.setdefault('label', '_nolegend_')
            whiskers.append(do_plot(whis_x, whislo_y, **whisker_kw))
            whiskers.append(do_plot(whis_x, whishi_y, **whisker_kw))
            if showcaps:
                cap_kw.setdefault('label', '_nolegend_')
                caps.append(do_plot(cap_x, cap_lo, **cap_kw))
                caps.append(do_plot(cap_x, cap_hi, **cap_kw))
            medians.append(do_plot(med_x, med_y, **median_kw))
            if showmeans:
                if meanline:
                    means.append(do_plot([box_left, box_right], [stats['mean'], stats['mean']], **mean_kw))
                else:
                    means.append(do_plot([pos], [stats['mean']], **mean_kw))
            if showfliers:
                flier_kw.setdefault('label', '_nolegend_')
                flier_x = np.full(len(stats['fliers']), pos, dtype=np.float64)
                flier_y = stats['fliers']
                fliers.append(do_plot(flier_x, flier_y, **flier_kw))
        if label:
            box_or_med = boxes if showbox and patch_artist else medians
            if cbook.is_scalar_or_string(label):
                box_or_med[0].set_label(label)
            else:
                if len(box_or_med) != len(label):
                    raise ValueError(datashape_message.format('label'))
                for (artist, lbl) in zip(box_or_med, label):
                    artist.set_label(lbl)
        if manage_ticks:
            axis_name = 'x' if orientation == 'vertical' else 'y'
            interval = getattr(self.dataLim, f'interval{axis_name}')
            axis = self._axis_map[axis_name]
            positions = axis.convert_units(positions)
            interval[:] = (min(interval[0], min(positions) - 0.5), max(interval[1], max(positions) + 0.5))
            for (median, position) in zip(medians, positions):
                getattr(median.sticky_edges, axis_name).extend([position - 0.5, position + 0.5])
            locator = axis.get_major_locator()
            if not isinstance(axis.get_major_locator(), mticker.FixedLocator):
                locator = mticker.FixedLocator([])
                axis.set_major_locator(locator)
            locator.locs = np.array([*locator.locs, *positions])
            formatter = axis.get_major_formatter()
            if not isinstance(axis.get_major_formatter(), mticker.FixedFormatter):
                formatter = mticker.FixedFormatter([])
                axis.set_major_formatter(formatter)
            formatter.seq = [*formatter.seq, *datalabels]
            self._request_autoscale_view()
        return dict(whiskers=whiskers, caps=caps, boxes=boxes, medians=medians, fliers=fliers, means=means)

    @staticmethod
    def _parse_scatter_color_args(c, edgecolors, kwargs, xsize, get_next_color_func):
        facecolors = kwargs.pop('facecolors', None)
        facecolors = kwargs.pop('facecolor', facecolors)
        edgecolors = kwargs.pop('edgecolor', edgecolors)
        kwcolor = kwargs.pop('color', None)
        if kwcolor is not None and c is not None:
            raise ValueError("Supply a 'c' argument or a 'color' kwarg but not both; they differ but their functionalities overlap.")
        if kwcolor is not None:
            try:
                mcolors.to_rgba_array(kwcolor)
            except ValueError as err:
                raise ValueError("'color' kwarg must be a color or sequence of color specs.  For a sequence of values to be color-mapped, use the 'c' argument instead.") from err
            if edgecolors is None:
                edgecolors = kwcolor
            if facecolors is None:
                facecolors = kwcolor
        if edgecolors is None and (not mpl.rcParams['_internal.classic_mode']):
            edgecolors = mpl.rcParams['scatter.edgecolors']
        c_was_none = c is None
        if c is None:
            c = facecolors if facecolors is not None else 'b' if mpl.rcParams['_internal.classic_mode'] else get_next_color_func()
        c_is_string_or_strings = isinstance(c, str) or (np.iterable(c) and len(c) > 0 and isinstance(cbook._safe_first_finite(c), str))

        def invalid_shape_exception(csize, xsize):
            return ValueError(f"'c' argument has {csize} elements, which is inconsistent with 'x' and 'y' with size {xsize}.")
        c_is_mapped = False
        valid_shape = True
        if not c_was_none and kwcolor is None and (not c_is_string_or_strings):
            try:
                c = np.asanyarray(c, dtype=float)
            except ValueError:
                pass
            else:
                if c.shape == (1, 4) or c.shape == (1, 3):
                    c_is_mapped = False
                    if c.size != xsize:
                        valid_shape = False
                elif c.size == xsize:
                    c = c.ravel()
                    c_is_mapped = True
                else:
                    if c.shape in ((3,), (4,)):
                        _api.warn_external('*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.')
                    valid_shape = False
        if not c_is_mapped:
            try:
                colors = mcolors.to_rgba_array(c)
            except (TypeError, ValueError) as err:
                if 'RGBA values should be within 0-1 range' in str(err):
                    raise
                else:
                    if not valid_shape:
                        raise invalid_shape_exception(c.size, xsize) from err
                    raise ValueError(f"'c' argument must be a color, a sequence of colors, or a sequence of numbers, not {c!r}") from err
            else:
                if len(colors) not in (0, 1, xsize):
                    raise invalid_shape_exception(len(colors), xsize)
        else:
            colors = None
        return (c, colors, edgecolors)

    @_api.make_keyword_only('3.9', 'marker')
    @_preprocess_data(replace_names=['x', 'y', 's', 'linewidths', 'edgecolors', 'c', 'facecolor', 'facecolors', 'color'], label_namer='y')
    @_docstring.interpd
    def scatter(self, x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, *, edgecolors=None, plotnonfinite=False, **kwargs):
        if edgecolors is not None:
            kwargs.update({'edgecolors': edgecolors})
        if linewidths is not None:
            kwargs.update({'linewidths': linewidths})
        kwargs = cbook.normalize_kwargs(kwargs, mcoll.Collection)
        linewidths = kwargs.pop('linewidth', None)
        edgecolors = kwargs.pop('edgecolor', None)
        (x, y) = self._process_unit_info([('x', x), ('y', y)], kwargs)
        x = np.ma.ravel(x)
        y = np.ma.ravel(y)
        if x.size != y.size:
            raise ValueError('x and y must be the same size')
        if s is None:
            s = 20 if mpl.rcParams['_internal.classic_mode'] else mpl.rcParams['lines.markersize'] ** 2.0
        s = np.ma.ravel(s)
        if len(s) not in (1, x.size) or (not np.issubdtype(s.dtype, np.floating) and (not np.issubdtype(s.dtype, np.integer))):
            raise ValueError('s must be a scalar, or float array-like with the same size as x and y')
        orig_edgecolor = edgecolors
        if edgecolors is None:
            orig_edgecolor = kwargs.get('edgecolor', None)
        (c, colors, edgecolors) = self._parse_scatter_color_args(c, edgecolors, kwargs, x.size, get_next_color_func=self._get_patches_for_fill.get_next_color)
        if plotnonfinite and colors is None:
            c = np.ma.masked_invalid(c)
            (x, y, s, edgecolors, linewidths) = cbook._combine_masks(x, y, s, edgecolors, linewidths)
        else:
            (x, y, s, c, colors, edgecolors, linewidths) = cbook._combine_masks(x, y, s, c, colors, edgecolors, linewidths)
        if x.size in (3, 4) and np.ma.is_masked(edgecolors) and (not np.ma.is_masked(orig_edgecolor)):
            edgecolors = edgecolors.data
        scales = s
        if marker is None:
            marker = mpl.rcParams['scatter.marker']
        if isinstance(marker, mmarkers.MarkerStyle):
            marker_obj = marker
        else:
            marker_obj = mmarkers.MarkerStyle(marker)
        path = marker_obj.get_path().transformed(marker_obj.get_transform())
        if not marker_obj.is_filled():
            if orig_edgecolor is not None:
                _api.warn_external(f'You passed a edgecolor/edgecolors ({orig_edgecolor!r}) for an unfilled marker ({marker!r}).  Matplotlib is ignoring the edgecolor in favor of the facecolor.  This behavior may change in the future.')
            if marker_obj.get_fillstyle() == 'none':
                edgecolors = colors
                colors = 'none'
            else:
                edgecolors = 'face'
            if linewidths is None:
                linewidths = mpl.rcParams['lines.linewidth']
            elif np.iterable(linewidths):
                linewidths = [lw if lw is not None else mpl.rcParams['lines.linewidth'] for lw in linewidths]
        offsets = np.ma.column_stack([x, y])
        collection = mcoll.PathCollection((path,), scales, facecolors=colors, edgecolors=edgecolors, linewidths=linewidths, offsets=offsets, offset_transform=kwargs.pop('transform', self.transData), alpha=alpha)
        collection.set_transform(mtransforms.IdentityTransform())
        if colors is None:
            collection.set_array(c)
            collection.set_cmap(cmap)
            collection.set_norm(norm)
            collection._scale_norm(norm, vmin, vmax)
        else:
            extra_kwargs = {'cmap': cmap, 'norm': norm, 'vmin': vmin, 'vmax': vmax}
            extra_keys = [k for (k, v) in extra_kwargs.items() if v is not None]
            if any(extra_keys):
                keys_str = ', '.join((f"'{k}'" for k in extra_keys))
                _api.warn_external(f"No data for colormapping provided via 'c'. Parameters {keys_str} will be ignored")
        collection._internal_update(kwargs)
        if mpl.rcParams['_internal.classic_mode']:
            if self._xmargin < 0.05 and x.size > 0:
                self.set_xmargin(0.05)
            if self._ymargin < 0.05 and x.size > 0:
                self.set_ymargin(0.05)
        self.add_collection(collection)
        self._request_autoscale_view()
        return collection

    @_api.make_keyword_only('3.9', 'gridsize')
    @_preprocess_data(replace_names=['x', 'y', 'C'], label_namer='y')
    @_docstring.dedent_interpd
    def hexbin(self, x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=np.mean, mincnt=None, marginals=False, **kwargs):
        self._process_unit_info([('x', x), ('y', y)], kwargs, convert=False)
        (x, y, C) = cbook.delete_masked_points(x, y, C)
        if np.iterable(gridsize):
            (nx, ny) = gridsize
        else:
            nx = gridsize
            ny = int(nx / math.sqrt(3))
        x = np.asarray(x, float)
        y = np.asarray(y, float)
        tx = x
        ty = y
        if xscale == 'log':
            if np.any(x <= 0.0):
                raise ValueError('x contains non-positive values, so cannot be log-scaled')
            tx = np.log10(tx)
        if yscale == 'log':
            if np.any(y <= 0.0):
                raise ValueError('y contains non-positive values, so cannot be log-scaled')
            ty = np.log10(ty)
        if extent is not None:
            (xmin, xmax, ymin, ymax) = extent
            if xmin > xmax:
                raise ValueError('In extent, xmax must be greater than xmin')
            if ymin > ymax:
                raise ValueError('In extent, ymax must be greater than ymin')
        else:
            (xmin, xmax) = (tx.min(), tx.max()) if len(x) else (0, 1)
            (ymin, ymax) = (ty.min(), ty.max()) if len(y) else (0, 1)
            (xmin, xmax) = mtransforms.nonsingular(xmin, xmax, expander=0.1)
            (ymin, ymax) = mtransforms.nonsingular(ymin, ymax, expander=0.1)
        nx1 = nx + 1
        ny1 = ny + 1
        nx2 = nx
        ny2 = ny
        n = nx1 * ny1 + nx2 * ny2
        padding = 1e-09 * (xmax - xmin)
        xmin -= padding
        xmax += padding
        sx = (xmax - xmin) / nx
        sy = (ymax - ymin) / ny
        ix = (tx - xmin) / sx
        iy = (ty - ymin) / sy
        ix1 = np.round(ix).astype(int)
        iy1 = np.round(iy).astype(int)
        ix2 = np.floor(ix).astype(int)
        iy2 = np.floor(iy).astype(int)
        i1 = np.where((0 <= ix1) & (ix1 < nx1) & (0 <= iy1) & (iy1 < ny1), ix1 * ny1 + iy1 + 1, 0)
        i2 = np.where((0 <= ix2) & (ix2 < nx2) & (0 <= iy2) & (iy2 < ny2), ix2 * ny2 + iy2 + 1, 0)
        d1 = (ix - ix1) ** 2 + 3.0 * (iy - iy1) ** 2
        d2 = (ix - ix2 - 0.5) ** 2 + 3.0 * (iy - iy2 - 0.5) ** 2
        bdist = d1 < d2
        if C is None:
            counts1 = np.bincount(i1[bdist], minlength=1 + nx1 * ny1)[1:]
            counts2 = np.bincount(i2[~bdist], minlength=1 + nx2 * ny2)[1:]
            accum = np.concatenate([counts1, counts2]).astype(float)
            if mincnt is not None:
                accum[accum < mincnt] = np.nan
            C = np.ones(len(x))
        else:
            Cs_at_i1 = [[] for _ in range(1 + nx1 * ny1)]
            Cs_at_i2 = [[] for _ in range(1 + nx2 * ny2)]
            for i in range(len(x)):
                if bdist[i]:
                    Cs_at_i1[i1[i]].append(C[i])
                else:
                    Cs_at_i2[i2[i]].append(C[i])
            if mincnt is None:
                mincnt = 1
            accum = np.array([reduce_C_function(acc) if len(acc) >= mincnt else np.nan for Cs_at_i in [Cs_at_i1, Cs_at_i2] for acc in Cs_at_i[1:]], float)
        good_idxs = ~np.isnan(accum)
        offsets = np.zeros((n, 2), float)
        offsets[:nx1 * ny1, 0] = np.repeat(np.arange(nx1), ny1)
        offsets[:nx1 * ny1, 1] = np.tile(np.arange(ny1), nx1)
        offsets[nx1 * ny1:, 0] = np.repeat(np.arange(nx2) + 0.5, ny2)
        offsets[nx1 * ny1:, 1] = np.tile(np.arange(ny2), nx2) + 0.5
        offsets[:, 0] *= sx
        offsets[:, 1] *= sy
        offsets[:, 0] += xmin
        offsets[:, 1] += ymin
        offsets = offsets[good_idxs, :]
        accum = accum[good_idxs]
        polygon = [sx, sy / 3] * np.array([[0.5, -0.5], [0.5, 0.5], [0.0, 1.0], [-0.5, 0.5], [-0.5, -0.5], [0.0, -1.0]])
        if linewidths is None:
            linewidths = [mpl.rcParams['patch.linewidth']]
        if xscale == 'log' or yscale == 'log':
            polygons = np.expand_dims(polygon, 0)
            if xscale == 'log':
                polygons[:, :, 0] = 10.0 ** polygons[:, :, 0]
                xmin = 10.0 ** xmin
                xmax = 10.0 ** xmax
                self.set_xscale(xscale)
            if yscale == 'log':
                polygons[:, :, 1] = 10.0 ** polygons[:, :, 1]
                ymin = 10.0 ** ymin
                ymax = 10.0 ** ymax
                self.set_yscale(yscale)
        else:
            polygons = [polygon]
        collection = mcoll.PolyCollection(polygons, edgecolors=edgecolors, linewidths=linewidths, offsets=offsets, offset_transform=mtransforms.AffineDeltaTransform(self.transData))
        if cbook._str_equal(bins, 'log'):
            if norm is not None:
                _api.warn_external(f"Only one of 'bins' and 'norm' arguments can be supplied, ignoring bins={bins!r}")
            else:
                norm = mcolors.LogNorm(vmin=vmin, vmax=vmax)
                vmin = vmax = None
            bins = None
        if bins is not None:
            if not np.iterable(bins):
                (minimum, maximum) = (min(accum), max(accum))
                bins -= 1
                bins = minimum + (maximum - minimum) * np.arange(bins) / bins
            bins = np.sort(bins)
            accum = bins.searchsorted(accum)
        collection.set_array(accum)
        collection.set_cmap(cmap)
        collection.set_norm(norm)
        collection.set_alpha(alpha)
        collection._internal_update(kwargs)
        collection._scale_norm(norm, vmin, vmax)
        if norm is not None:
            if collection.norm.vmin is None and collection.norm.vmax is None:
                collection.norm.autoscale()
        corners = ((xmin, ymin), (xmax, ymax))
        self.update_datalim(corners)
        self._request_autoscale_view(tight=True)
        self.add_collection(collection, autolim=False)
        if not marginals:
            return collection
        bars = []
        for (zname, z, zmin, zmax, zscale, nbins) in [('x', x, xmin, xmax, xscale, nx), ('y', y, ymin, ymax, yscale, 2 * ny)]:
            if zscale == 'log':
                bin_edges = np.geomspace(zmin, zmax, nbins + 1)
            else:
                bin_edges = np.linspace(zmin, zmax, nbins + 1)
            verts = np.empty((nbins, 4, 2))
            verts[:, 0, 0] = verts[:, 1, 0] = bin_edges[:-1]
            verts[:, 2, 0] = verts[:, 3, 0] = bin_edges[1:]
            verts[:, 0, 1] = verts[:, 3, 1] = 0.0
            verts[:, 1, 1] = verts[:, 2, 1] = 0.05
            if zname == 'y':
                verts = verts[:, :, ::-1]
            bin_idxs = np.searchsorted(bin_edges, z) - 1
            values = np.empty(nbins)
            for i in range(nbins):
                ci = C[bin_idxs == i]
                values[i] = reduce_C_function(ci) if len(ci) > 0 else np.nan
            mask = ~np.isnan(values)
            verts = verts[mask]
            values = values[mask]
            trans = getattr(self, f'get_{zname}axis_transform')(which='grid')
            bar = mcoll.PolyCollection(verts, transform=trans, edgecolors='face')
            bar.set_array(values)
            bar.set_cmap(cmap)
            bar.set_norm(norm)
            bar.set_alpha(alpha)
            bar._internal_update(kwargs)
            bars.append(self.add_collection(bar, autolim=False))
        (collection.hbar, collection.vbar) = bars

        def on_changed(collection):
            collection.hbar.set_cmap(collection.get_cmap())
            collection.hbar.set_cmap(collection.get_cmap())
            collection.vbar.set_clim(collection.get_clim())
            collection.vbar.set_clim(collection.get_clim())
        collection.callbacks.connect('changed', on_changed)
        return collection

    @_docstring.dedent_interpd
    def arrow(self, x, y, dx, dy, **kwargs):
        x = self.convert_xunits(x)
        y = self.convert_yunits(y)
        dx = self.convert_xunits(dx)
        dy = self.convert_yunits(dy)
        a = mpatches.FancyArrow(x, y, dx, dy, **kwargs)
        self.add_patch(a)
        self._request_autoscale_view()
        return a

    @_docstring.copy(mquiver.QuiverKey.__init__)
    def quiverkey(self, Q, X, Y, U, label, **kwargs):
        qk = mquiver.QuiverKey(Q, X, Y, U, label, **kwargs)
        self.add_artist(qk)
        return qk

    def _quiver_units(self, args, kwargs):
        if len(args) > 3:
            (x, y) = args[0:2]
            (x, y) = self._process_unit_info([('x', x), ('y', y)], kwargs)
            return (x, y) + args[2:]
        return args

    @_preprocess_data()
    @_docstring.dedent_interpd
    def quiver(self, *args, **kwargs):
        args = self._quiver_units(args, kwargs)
        q = mquiver.Quiver(self, *args, **kwargs)
        self.add_collection(q, autolim=True)
        self._request_autoscale_view()
        return q

    @_preprocess_data()
    @_docstring.dedent_interpd
    def barbs(self, *args, **kwargs):
        args = self._quiver_units(args, kwargs)
        b = mquiver.Barbs(self, *args, **kwargs)
        self.add_collection(b, autolim=True)
        self._request_autoscale_view()
        return b

    def fill(self, *args, data=None, **kwargs):
        kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
        patches = [*self._get_patches_for_fill(self, *args, data=data, **kwargs)]
        for poly in patches:
            self.add_patch(poly)
        self._request_autoscale_view()
        return patches

    def _fill_between_x_or_y(self, ind_dir, ind, dep1, dep2=0, *, where=None, interpolate=False, step=None, **kwargs):
        dep_dir = {'x': 'y', 'y': 'x'}[ind_dir]
        if not mpl.rcParams['_internal.classic_mode']:
            kwargs = cbook.normalize_kwargs(kwargs, mcoll.Collection)
            if not any((c in kwargs for c in ('color', 'facecolor'))):
                kwargs['facecolor'] = self._get_patches_for_fill.get_next_color()
        (ind, dep1, dep2) = map(ma.masked_invalid, self._process_unit_info([(ind_dir, ind), (dep_dir, dep1), (dep_dir, dep2)], kwargs))
        for (name, array) in [(ind_dir, ind), (f'{dep_dir}1', dep1), (f'{dep_dir}2', dep2)]:
            if array.ndim > 1:
                raise ValueError(f'{name!r} is not 1-dimensional')
        if where is None:
            where = True
        else:
            where = np.asarray(where, dtype=bool)
            if where.size != ind.size:
                raise ValueError(f'where size ({where.size}) does not match {ind_dir} size ({ind.size})')
        where = where & ~functools.reduce(np.logical_or, map(np.ma.getmaskarray, [ind, dep1, dep2]))
        (ind, dep1, dep2) = np.broadcast_arrays(np.atleast_1d(ind), dep1, dep2, subok=True)
        polys = []
        for (idx0, idx1) in cbook.contiguous_regions(where):
            indslice = ind[idx0:idx1]
            dep1slice = dep1[idx0:idx1]
            dep2slice = dep2[idx0:idx1]
            if step is not None:
                step_func = cbook.STEP_LOOKUP_MAP['steps-' + step]
                (indslice, dep1slice, dep2slice) = step_func(indslice, dep1slice, dep2slice)
            if not len(indslice):
                continue
            N = len(indslice)
            pts = np.zeros((2 * N + 2, 2))
            if interpolate:

                def get_interp_point(idx):
                    im1 = max(idx - 1, 0)
                    ind_values = ind[im1:idx + 1]
                    diff_values = dep1[im1:idx + 1] - dep2[im1:idx + 1]
                    dep1_values = dep1[im1:idx + 1]
                    if len(diff_values) == 2:
                        if np.ma.is_masked(diff_values[1]):
                            return (ind[im1], dep1[im1])
                        elif np.ma.is_masked(diff_values[0]):
                            return (ind[idx], dep1[idx])
                    diff_order = diff_values.argsort()
                    diff_root_ind = np.interp(0, diff_values[diff_order], ind_values[diff_order])
                    ind_order = ind_values.argsort()
                    diff_root_dep = np.interp(diff_root_ind, ind_values[ind_order], dep1_values[ind_order])
                    return (diff_root_ind, diff_root_dep)
                start = get_interp_point(idx0)
                end = get_interp_point(idx1)
            else:
                start = (indslice[0], dep2slice[0])
                end = (indslice[-1], dep2slice[-1])
            pts[0] = start
            pts[N + 1] = end
            pts[1:N + 1, 0] = indslice
            pts[1:N + 1, 1] = dep1slice
            pts[N + 2:, 0] = indslice[::-1]
            pts[N + 2:, 1] = dep2slice[::-1]
            if ind_dir == 'y':
                pts = pts[:, ::-1]
            polys.append(pts)
        collection = mcoll.PolyCollection(polys, **kwargs)
        pts = np.vstack([np.hstack([ind[where, None], dep1[where, None]]), np.hstack([ind[where, None], dep2[where, None]])])
        if ind_dir == 'y':
            pts = pts[:, ::-1]
        up_x = up_y = True
        if 'transform' in kwargs:
            (up_x, up_y) = kwargs['transform'].contains_branch_seperately(self.transData)
        self.update_datalim(pts, updatex=up_x, updatey=up_y)
        self.add_collection(collection, autolim=False)
        self._request_autoscale_view()
        return collection

    def fill_between(self, x, y1, y2=0, where=None, interpolate=False, step=None, **kwargs):
        return self._fill_between_x_or_y('x', x, y1, y2, where=where, interpolate=interpolate, step=step, **kwargs)
    if _fill_between_x_or_y.__doc__:
        fill_between.__doc__ = _fill_between_x_or_y.__doc__.format(dir='horizontal', ind='x', dep='y')
    fill_between = _preprocess_data(_docstring.dedent_interpd(fill_between), replace_names=['x', 'y1', 'y2', 'where'])

    def fill_betweenx(self, y, x1, x2=0, where=None, step=None, interpolate=False, **kwargs):
        return self._fill_between_x_or_y('y', y, x1, x2, where=where, interpolate=interpolate, step=step, **kwargs)
    if _fill_between_x_or_y.__doc__:
        fill_betweenx.__doc__ = _fill_between_x_or_y.__doc__.format(dir='vertical', ind='y', dep='x')
    fill_betweenx = _preprocess_data(_docstring.dedent_interpd(fill_betweenx), replace_names=['y', 'x1', 'x2', 'where'])

    @_preprocess_data()
    @_docstring.interpd
    def imshow(self, X, cmap=None, norm=None, *, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, interpolation_stage=None, filternorm=True, filterrad=4.0, resample=None, url=None, **kwargs):
        im = mimage.AxesImage(self, cmap=cmap, norm=norm, interpolation=interpolation, origin=origin, extent=extent, filternorm=filternorm, filterrad=filterrad, resample=resample, interpolation_stage=interpolation_stage, **kwargs)
        if aspect is None and (not (im.is_transform_set() and (not im.get_transform().contains_branch(self.transData)))):
            aspect = mpl.rcParams['image.aspect']
        if aspect is not None:
            self.set_aspect(aspect)
        im.set_data(X)
        im.set_alpha(alpha)
        if im.get_clip_path() is None:
            im.set_clip_path(self.patch)
        im._scale_norm(norm, vmin, vmax)
        im.set_url(url)
        im.set_extent(im.get_extent())
        self.add_image(im)
        return im

    def _pcolorargs(self, funcname, *args, shading='auto', **kwargs):
        _valid_shading = ['gouraud', 'nearest', 'flat', 'auto']
        try:
            _api.check_in_list(_valid_shading, shading=shading)
        except ValueError:
            _api.warn_external(f"shading value '{shading}' not in list of valid values {_valid_shading}. Setting shading='auto'.")
            shading = 'auto'
        if len(args) == 1:
            C = np.asanyarray(args[0])
            (nrows, ncols) = C.shape[:2]
            if shading in ['gouraud', 'nearest']:
                (X, Y) = np.meshgrid(np.arange(ncols), np.arange(nrows))
            else:
                (X, Y) = np.meshgrid(np.arange(ncols + 1), np.arange(nrows + 1))
                shading = 'flat'
            C = cbook.safe_masked_invalid(C, copy=True)
            return (X, Y, C, shading)
        if len(args) == 3:
            C = np.asanyarray(args[2])
            (X, Y) = args[:2]
            (X, Y) = self._process_unit_info([('x', X), ('y', Y)], kwargs)
            (X, Y) = (cbook.safe_masked_invalid(a, copy=True) for a in [X, Y])
            if funcname == 'pcolormesh':
                if np.ma.is_masked(X) or np.ma.is_masked(Y):
                    raise ValueError('x and y arguments to pcolormesh cannot have non-finite values or be of type numpy.ma.MaskedArray with masked values')
            (nrows, ncols) = C.shape[:2]
        else:
            raise _api.nargs_error(funcname, takes='1 or 3', given=len(args))
        Nx = X.shape[-1]
        Ny = Y.shape[0]
        if X.ndim != 2 or X.shape[0] == 1:
            x = X.reshape(1, Nx)
            X = x.repeat(Ny, axis=0)
        if Y.ndim != 2 or Y.shape[1] == 1:
            y = Y.reshape(Ny, 1)
            Y = y.repeat(Nx, axis=1)
        if X.shape != Y.shape:
            raise TypeError(f'Incompatible X, Y inputs to {funcname}; see help({funcname})')
        if shading == 'auto':
            if ncols == Nx and nrows == Ny:
                shading = 'nearest'
            else:
                shading = 'flat'
        if shading == 'flat':
            if (Nx, Ny) != (ncols + 1, nrows + 1):
                raise TypeError(f"Dimensions of C {C.shape} should be one smaller than X({Nx}) and Y({Ny}) while using shading='flat' see help({funcname})")
        else:
            if (Nx, Ny) != (ncols, nrows):
                raise TypeError('Dimensions of C %s are incompatible with X (%d) and/or Y (%d); see help(%s)' % (C.shape, Nx, Ny, funcname))
            if shading == 'nearest':

                def _interp_grid(X):
                    if np.shape(X)[1] > 1:
                        dX = np.diff(X, axis=1) * 0.5
                        if not (np.all(dX >= 0) or np.all(dX <= 0)):
                            _api.warn_external(f'The input coordinates to {funcname} are interpreted as cell centers, but are not monotonically increasing or decreasing. This may lead to incorrectly calculated cell edges, in which case, please supply explicit cell edges to {funcname}.')
                        hstack = np.ma.hstack if np.ma.isMA(X) else np.hstack
                        X = hstack((X[:, [0]] - dX[:, [0]], X[:, :-1] + dX, X[:, [-1]] + dX[:, [-1]]))
                    else:
                        X = np.hstack((X, X))
                    return X
                if ncols == Nx:
                    X = _interp_grid(X)
                    Y = _interp_grid(Y)
                if nrows == Ny:
                    X = _interp_grid(X.T).T
                    Y = _interp_grid(Y.T).T
                shading = 'flat'
        C = cbook.safe_masked_invalid(C, copy=True)
        return (X, Y, C, shading)

    @_preprocess_data()
    @_docstring.dedent_interpd
    def pcolor(self, *args, shading=None, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, **kwargs):
        if shading is None:
            shading = mpl.rcParams['pcolor.shading']
        shading = shading.lower()
        (X, Y, C, shading) = self._pcolorargs('pcolor', *args, shading=shading, kwargs=kwargs)
        linewidths = (0.25,)
        if 'linewidth' in kwargs:
            kwargs['linewidths'] = kwargs.pop('linewidth')
        kwargs.setdefault('linewidths', linewidths)
        if 'edgecolor' in kwargs:
            kwargs['edgecolors'] = kwargs.pop('edgecolor')
        ec = kwargs.setdefault('edgecolors', 'none')
        if 'antialiaseds' in kwargs:
            kwargs['antialiased'] = kwargs.pop('antialiaseds')
        if 'antialiased' not in kwargs and cbook._str_lower_equal(ec, 'none'):
            kwargs['antialiased'] = False
        kwargs.setdefault('snap', False)
        if np.ma.isMaskedArray(X) or np.ma.isMaskedArray(Y):
            stack = np.ma.stack
            X = np.ma.asarray(X)
            Y = np.ma.asarray(Y)
            x = X.compressed()
            y = Y.compressed()
        else:
            stack = np.stack
            x = X
            y = Y
        coords = stack([X, Y], axis=-1)
        collection = mcoll.PolyQuadMesh(coords, array=C, cmap=cmap, norm=norm, alpha=alpha, **kwargs)
        collection._scale_norm(norm, vmin, vmax)
        t = collection._transform
        if not isinstance(t, mtransforms.Transform) and hasattr(t, '_as_mpl_transform'):
            t = t._as_mpl_transform(self.axes)
        if t and any(t.contains_branch_seperately(self.transData)):
            trans_to_data = t - self.transData
            pts = np.vstack([x, y]).T.astype(float)
            transformed_pts = trans_to_data.transform(pts)
            x = transformed_pts[..., 0]
            y = transformed_pts[..., 1]
        self.add_collection(collection, autolim=False)
        minx = np.min(x)
        maxx = np.max(x)
        miny = np.min(y)
        maxy = np.max(y)
        collection.sticky_edges.x[:] = [minx, maxx]
        collection.sticky_edges.y[:] = [miny, maxy]
        corners = ((minx, miny), (maxx, maxy))
        self.update_datalim(corners)
        self._request_autoscale_view()
        return collection

    @_preprocess_data()
    @_docstring.dedent_interpd
    def pcolormesh(self, *args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, shading=None, antialiased=False, **kwargs):
        if shading is None:
            shading = mpl.rcParams['pcolor.shading']
        shading = shading.lower()
        kwargs.setdefault('edgecolors', 'none')
        (X, Y, C, shading) = self._pcolorargs('pcolormesh', *args, shading=shading, kwargs=kwargs)
        coords = np.stack([X, Y], axis=-1)
        kwargs.setdefault('snap', mpl.rcParams['pcolormesh.snap'])
        collection = mcoll.QuadMesh(coords, antialiased=antialiased, shading=shading, array=C, cmap=cmap, norm=norm, alpha=alpha, **kwargs)
        collection._scale_norm(norm, vmin, vmax)
        coords = coords.reshape(-1, 2)
        t = collection._transform
        if not isinstance(t, mtransforms.Transform) and hasattr(t, '_as_mpl_transform'):
            t = t._as_mpl_transform(self.axes)
        if t and any(t.contains_branch_seperately(self.transData)):
            trans_to_data = t - self.transData
            coords = trans_to_data.transform(coords)
        self.add_collection(collection, autolim=False)
        (minx, miny) = np.min(coords, axis=0)
        (maxx, maxy) = np.max(coords, axis=0)
        collection.sticky_edges.x[:] = [minx, maxx]
        collection.sticky_edges.y[:] = [miny, maxy]
        corners = ((minx, miny), (maxx, maxy))
        self.update_datalim(corners)
        self._request_autoscale_view()
        return collection

    @_preprocess_data()
    @_docstring.dedent_interpd
    def pcolorfast(self, *args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, **kwargs):
        C = args[-1]
        (nr, nc) = np.shape(C)[:2]
        if len(args) == 1:
            style = 'image'
            x = [0, nc]
            y = [0, nr]
        elif len(args) == 3:
            (x, y) = args[:2]
            x = np.asarray(x)
            y = np.asarray(y)
            if x.ndim == 1 and y.ndim == 1:
                if x.size == 2 and y.size == 2:
                    style = 'image'
                else:
                    dx = np.diff(x)
                    dy = np.diff(y)
                    if np.ptp(dx) < 0.01 * abs(dx.mean()) and np.ptp(dy) < 0.01 * abs(dy.mean()):
                        style = 'image'
                    else:
                        style = 'pcolorimage'
            elif x.ndim == 2 and y.ndim == 2:
                style = 'quadmesh'
            else:
                raise TypeError(f'When 3 positional parameters are passed to pcolorfast, the first two (X and Y) must be both 1D or both 2D; the given X was {x.ndim}D and the given Y was {y.ndim}D')
        else:
            raise _api.nargs_error('pcolorfast', '1 or 3', len(args))
        if style == 'quadmesh':
            coords = np.stack([x, y], axis=-1)
            if np.ndim(C) not in {2, 3}:
                raise ValueError('C must be 2D or 3D')
            collection = mcoll.QuadMesh(coords, array=C, alpha=alpha, cmap=cmap, norm=norm, antialiased=False, edgecolors='none')
            self.add_collection(collection, autolim=False)
            (xl, xr, yb, yt) = (x.min(), x.max(), y.min(), y.max())
            ret = collection
        else:
            extent = (xl, xr, yb, yt) = (x[0], x[-1], y[0], y[-1])
            if style == 'image':
                im = mimage.AxesImage(self, cmap=cmap, norm=norm, data=C, alpha=alpha, extent=extent, interpolation='nearest', origin='lower', **kwargs)
            elif style == 'pcolorimage':
                im = mimage.PcolorImage(self, x, y, C, cmap=cmap, norm=norm, alpha=alpha, extent=extent, **kwargs)
            self.add_image(im)
            ret = im
        if np.ndim(C) == 2:
            ret._scale_norm(norm, vmin, vmax)
        if ret.get_clip_path() is None:
            ret.set_clip_path(self.patch)
        ret.sticky_edges.x[:] = [xl, xr]
        ret.sticky_edges.y[:] = [yb, yt]
        self.update_datalim(np.array([[xl, yb], [xr, yt]]))
        self._request_autoscale_view(tight=True)
        return ret

    @_preprocess_data()
    @_docstring.dedent_interpd
    def contour(self, *args, **kwargs):
        kwargs['filled'] = False
        contours = mcontour.QuadContourSet(self, *args, **kwargs)
        self._request_autoscale_view()
        return contours

    @_preprocess_data()
    @_docstring.dedent_interpd
    def contourf(self, *args, **kwargs):
        kwargs['filled'] = True
        contours = mcontour.QuadContourSet(self, *args, **kwargs)
        self._request_autoscale_view()
        return contours

    def clabel(self, CS, levels=None, **kwargs):
        return CS.clabel(levels, **kwargs)

    @_api.make_keyword_only('3.9', 'range')
    @_preprocess_data(replace_names=['x', 'weights'], label_namer='x')
    def hist(self, x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, **kwargs):
        bin_range = range
        from builtins import range
        if np.isscalar(x):
            x = [x]
        if bins is None:
            bins = mpl.rcParams['hist.bins']
        _api.check_in_list(['bar', 'barstacked', 'step', 'stepfilled'], histtype=histtype)
        _api.check_in_list(['left', 'mid', 'right'], align=align)
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        if histtype == 'barstacked' and (not stacked):
            stacked = True
        x = cbook._reshape_2D(x, 'x')
        nx = len(x)
        if orientation == 'vertical':
            convert_units = self.convert_xunits
            x = [*self._process_unit_info([('x', x[0])], kwargs), *map(convert_units, x[1:])]
        else:
            convert_units = self.convert_yunits
            x = [*self._process_unit_info([('y', x[0])], kwargs), *map(convert_units, x[1:])]
        if bin_range is not None:
            bin_range = convert_units(bin_range)
        if not cbook.is_scalar_or_string(bins):
            bins = convert_units(bins)
        if weights is not None:
            w = cbook._reshape_2D(weights, 'weights')
        else:
            w = [None] * nx
        if len(w) != nx:
            raise ValueError('weights should have the same shape as x')
        input_empty = True
        for (xi, wi) in zip(x, w):
            len_xi = len(xi)
            if wi is not None and len(wi) != len_xi:
                raise ValueError('weights should have the same shape as x')
            if len_xi:
                input_empty = False
        if color is None:
            colors = [self._get_lines.get_next_color() for i in range(nx)]
        else:
            colors = mcolors.to_rgba_array(color)
            if len(colors) != nx:
                raise ValueError(f"The 'color' keyword argument must have one color per dataset, but {nx} datasets and {len(colors)} colors were provided")
        hist_kwargs = dict()
        if bin_range is None:
            xmin = np.inf
            xmax = -np.inf
            for xi in x:
                if len(xi):
                    xmin = min(xmin, np.nanmin(xi))
                    xmax = max(xmax, np.nanmax(xi))
            if xmin <= xmax:
                bin_range = (xmin, xmax)
        if not input_empty and len(x) > 1:
            if weights is not None:
                _w = np.concatenate(w)
            else:
                _w = None
            bins = np.histogram_bin_edges(np.concatenate(x), bins, bin_range, _w)
        else:
            hist_kwargs['range'] = bin_range
        density = bool(density)
        if density and (not stacked):
            hist_kwargs['density'] = density
        tops = []
        for i in range(nx):
            (m, bins) = np.histogram(x[i], bins, weights=w[i], **hist_kwargs)
            tops.append(m)
        tops = np.array(tops, float)
        bins = np.array(bins, float)
        if stacked:
            tops = tops.cumsum(axis=0)
            if density:
                tops = tops / np.diff(bins) / tops[-1].sum()
        if cumulative:
            slc = slice(None)
            if isinstance(cumulative, Number) and cumulative < 0:
                slc = slice(None, None, -1)
            if density:
                tops = (tops * np.diff(bins))[:, slc].cumsum(axis=1)[:, slc]
            else:
                tops = tops[:, slc].cumsum(axis=1)[:, slc]
        patches = []
        if histtype.startswith('bar'):
            totwidth = np.diff(bins)
            if rwidth is not None:
                dr = np.clip(rwidth, 0, 1)
            elif len(tops) > 1 and (not stacked or mpl.rcParams['_internal.classic_mode']):
                dr = 0.8
            else:
                dr = 1.0
            if histtype == 'bar' and (not stacked):
                width = dr * totwidth / nx
                dw = width
                boffset = -0.5 * dr * totwidth * (1 - 1 / nx)
            elif histtype == 'barstacked' or stacked:
                width = dr * totwidth
                (boffset, dw) = (0.0, 0.0)
            if align == 'mid':
                boffset += 0.5 * totwidth
            elif align == 'right':
                boffset += totwidth
            if orientation == 'horizontal':
                _barfunc = self.barh
                bottom_kwarg = 'left'
            else:
                _barfunc = self.bar
                bottom_kwarg = 'bottom'
            for (top, color) in zip(tops, colors):
                if bottom is None:
                    bottom = np.zeros(len(top))
                if stacked:
                    height = top - bottom
                else:
                    height = top
                bars = _barfunc(bins[:-1] + boffset, height, width, align='center', log=log, color=color, **{bottom_kwarg: bottom})
                patches.append(bars)
                if stacked:
                    bottom = top
                boffset += dw
            for bars in patches[1:]:
                for patch in bars:
                    patch.sticky_edges.x[:] = patch.sticky_edges.y[:] = []
        elif histtype.startswith('step'):
            x = np.zeros(4 * len(bins) - 3)
            y = np.zeros(4 * len(bins) - 3)
            (x[0:2 * len(bins) - 1:2], x[1:2 * len(bins) - 1:2]) = (bins, bins[:-1])
            x[2 * len(bins) - 1:] = x[1:2 * len(bins) - 1][::-1]
            if bottom is None:
                bottom = 0
            y[1:2 * len(bins) - 1:2] = y[2:2 * len(bins):2] = bottom
            y[2 * len(bins) - 1:] = y[1:2 * len(bins) - 1][::-1]
            if log:
                if orientation == 'horizontal':
                    self.set_xscale('log', nonpositive='clip')
                else:
                    self.set_yscale('log', nonpositive='clip')
            if align == 'left':
                x -= 0.5 * (bins[1] - bins[0])
            elif align == 'right':
                x += 0.5 * (bins[1] - bins[0])
            fill = histtype == 'stepfilled'
            (xvals, yvals) = ([], [])
            for top in tops:
                if stacked:
                    y[2 * len(bins) - 1:] = y[1:2 * len(bins) - 1][::-1]
                y[1:2 * len(bins) - 1:2] = y[2:2 * len(bins):2] = top + bottom
                y[0] = y[-1]
                if orientation == 'horizontal':
                    xvals.append(y.copy())
                    yvals.append(x.copy())
                else:
                    xvals.append(x.copy())
                    yvals.append(y.copy())
            split = -1 if fill else 2 * len(bins)
            for (x, y, color) in reversed(list(zip(xvals, yvals, colors))):
                patches.append(self.fill(x[:split], y[:split], closed=True if fill else None, facecolor=color, edgecolor=None if fill else color, fill=fill if fill else None, zorder=None if fill else mlines.Line2D.zorder))
            for patch_list in patches:
                for patch in patch_list:
                    if orientation == 'vertical':
                        patch.sticky_edges.y.append(0)
                    elif orientation == 'horizontal':
                        patch.sticky_edges.x.append(0)
            patches.reverse()
        labels = [] if label is None else np.atleast_1d(np.asarray(label, str))
        if histtype == 'step':
            edgecolors = itertools.cycle(np.atleast_1d(kwargs.get('edgecolor', colors)))
        else:
            edgecolors = itertools.cycle(np.atleast_1d(kwargs.get('edgecolor', None)))
        facecolors = itertools.cycle(np.atleast_1d(kwargs.get('facecolor', colors)))
        hatches = itertools.cycle(np.atleast_1d(kwargs.get('hatch', None)))
        linewidths = itertools.cycle(np.atleast_1d(kwargs.get('linewidth', None)))
        linestyles = itertools.cycle(np.atleast_1d(kwargs.get('linestyle', None)))
        for (patch, lbl) in itertools.zip_longest(patches, labels):
            if not patch:
                continue
            p = patch[0]
            kwargs.update({'hatch': next(hatches), 'linewidth': next(linewidths), 'linestyle': next(linestyles), 'edgecolor': next(edgecolors), 'facecolor': next(facecolors)})
            p._internal_update(kwargs)
            if lbl is not None:
                p.set_label(lbl)
            for p in patch[1:]:
                p._internal_update(kwargs)
                p.set_label('_nolegend_')
        if nx == 1:
            return (tops[0], bins, patches[0])
        else:
            patch_type = 'BarContainer' if histtype.startswith('bar') else 'list[Polygon]'
            return (tops, bins, cbook.silent_list(patch_type, patches))

    @_preprocess_data()
    def stairs(self, values, edges=None, *, orientation='vertical', baseline=0, fill=False, **kwargs):
        if 'color' in kwargs:
            _color = kwargs.pop('color')
        else:
            _color = self._get_lines.get_next_color()
        if fill:
            kwargs.setdefault('linewidth', 0)
            kwargs.setdefault('facecolor', _color)
        else:
            kwargs.setdefault('edgecolor', _color)
        if edges is None:
            edges = np.arange(len(values) + 1)
        (edges, values, baseline) = self._process_unit_info([('x', edges), ('y', values), ('y', baseline)], kwargs)
        patch = mpatches.StepPatch(values, edges, baseline=baseline, orientation=orientation, fill=fill, **kwargs)
        self.add_patch(patch)
        if baseline is None and fill:
            _api.warn_external(f'Both baseline={baseline!r} and fill={fill!r} have been passed. baseline=None is only intended for unfilled stair plots. Because baseline is None, the Path used to draw the stairs will not be closed, thus because fill is True the polygon will be closed by drawing an (unstroked) edge from the first to last point.  It is very likely that the resulting fill patterns is not the desired result.')
        if baseline is not None:
            if orientation == 'vertical':
                patch.sticky_edges.y.append(np.min(baseline))
                self.update_datalim([(edges[0], np.min(baseline))])
            else:
                patch.sticky_edges.x.append(np.min(baseline))
                self.update_datalim([(np.min(baseline), edges[0])])
        self._request_autoscale_view()
        return patch

    @_api.make_keyword_only('3.9', 'range')
    @_preprocess_data(replace_names=['x', 'y', 'weights'])
    @_docstring.dedent_interpd
    def hist2d(self, x, y, bins=10, range=None, density=False, weights=None, cmin=None, cmax=None, **kwargs):
        (h, xedges, yedges) = np.histogram2d(x, y, bins=bins, range=range, density=density, weights=weights)
        if cmin is not None:
            h[h < cmin] = None
        if cmax is not None:
            h[h > cmax] = None
        pc = self.pcolormesh(xedges, yedges, h.T, **kwargs)
        self.set_xlim(xedges[0], xedges[-1])
        self.set_ylim(yedges[0], yedges[-1])
        return (h, xedges, yedges, pc)

    @_preprocess_data(replace_names=['x', 'weights'], label_namer='x')
    @_docstring.dedent_interpd
    def ecdf(self, x, weights=None, *, complementary=False, orientation='vertical', compress=False, **kwargs):
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        if 'drawstyle' in kwargs or 'ds' in kwargs:
            raise TypeError("Cannot pass 'drawstyle' or 'ds' to ecdf()")
        if np.ma.getmask(x).any():
            raise ValueError('ecdf() does not support masked entries')
        x = np.asarray(x)
        if np.isnan(x).any():
            raise ValueError('ecdf() does not support NaNs')
        argsort = np.argsort(x)
        x = x[argsort]
        if weights is None:
            cum_weights = (1 + np.arange(len(x))) / len(x)
        else:
            weights = np.take(weights, argsort)
            cum_weights = np.cumsum(weights / np.sum(weights))
        if compress:
            compress_idxs = [0, *(x[:-1] != x[1:]).nonzero()[0] + 1]
            x = x[compress_idxs]
            cum_weights = cum_weights[compress_idxs]
        if orientation == 'vertical':
            if not complementary:
                (line,) = self.plot([x[0], *x], [0, *cum_weights], drawstyle='steps-post', **kwargs)
            else:
                (line,) = self.plot([*x, x[-1]], [1, *1 - cum_weights], drawstyle='steps-pre', **kwargs)
            line.sticky_edges.y[:] = [0, 1]
        else:
            if not complementary:
                (line,) = self.plot([0, *cum_weights], [x[0], *x], drawstyle='steps-pre', **kwargs)
            else:
                (line,) = self.plot([1, *1 - cum_weights], [*x, x[-1]], drawstyle='steps-post', **kwargs)
            line.sticky_edges.x[:] = [0, 1]
        return line

    @_api.make_keyword_only('3.9', 'NFFT')
    @_preprocess_data(replace_names=['x'])
    @_docstring.dedent_interpd
    def psd(self, x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, **kwargs):
        if Fc is None:
            Fc = 0
        (pxx, freqs) = mlab.psd(x=x, NFFT=NFFT, Fs=Fs, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq)
        freqs += Fc
        if scale_by_freq in (None, True):
            psd_units = 'dB/Hz'
        else:
            psd_units = 'dB'
        line = self.plot(freqs, 10 * np.log10(pxx), **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Power Spectral Density (%s)' % psd_units)
        self.grid(True)
        (vmin, vmax) = self.get_ybound()
        step = max(10 * int(np.log10(vmax - vmin)), 1)
        ticks = np.arange(math.floor(vmin), math.ceil(vmax) + 1, step)
        self.set_yticks(ticks)
        if return_line is None or not return_line:
            return (pxx, freqs)
        else:
            return (pxx, freqs, line)

    @_api.make_keyword_only('3.9', 'NFFT')
    @_preprocess_data(replace_names=['x', 'y'], label_namer='y')
    @_docstring.dedent_interpd
    def csd(self, x, y, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, **kwargs):
        if Fc is None:
            Fc = 0
        (pxy, freqs) = mlab.csd(x=x, y=y, NFFT=NFFT, Fs=Fs, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq)
        freqs += Fc
        line = self.plot(freqs, 10 * np.log10(np.abs(pxy)), **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Cross Spectrum Magnitude (dB)')
        self.grid(True)
        (vmin, vmax) = self.get_ybound()
        step = max(10 * int(np.log10(vmax - vmin)), 1)
        ticks = np.arange(math.floor(vmin), math.ceil(vmax) + 1, step)
        self.set_yticks(ticks)
        if return_line is None or not return_line:
            return (pxy, freqs)
        else:
            return (pxy, freqs, line)

    @_api.make_keyword_only('3.9', 'Fs')
    @_preprocess_data(replace_names=['x'])
    @_docstring.dedent_interpd
    def magnitude_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, **kwargs):
        if Fc is None:
            Fc = 0
        (spec, freqs) = mlab.magnitude_spectrum(x=x, Fs=Fs, window=window, pad_to=pad_to, sides=sides)
        freqs += Fc
        yunits = _api.check_getitem({None: 'energy', 'default': 'energy', 'linear': 'energy', 'dB': 'dB'}, scale=scale)
        if yunits == 'energy':
            Z = spec
        else:
            Z = 20.0 * np.log10(spec)
        (line,) = self.plot(freqs, Z, **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Magnitude (%s)' % yunits)
        return (spec, freqs, line)

    @_api.make_keyword_only('3.9', 'Fs')
    @_preprocess_data(replace_names=['x'])
    @_docstring.dedent_interpd
    def angle_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, **kwargs):
        if Fc is None:
            Fc = 0
        (spec, freqs) = mlab.angle_spectrum(x=x, Fs=Fs, window=window, pad_to=pad_to, sides=sides)
        freqs += Fc
        lines = self.plot(freqs, spec, **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Angle (radians)')
        return (spec, freqs, lines[0])

    @_api.make_keyword_only('3.9', 'Fs')
    @_preprocess_data(replace_names=['x'])
    @_docstring.dedent_interpd
    def phase_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, **kwargs):
        if Fc is None:
            Fc = 0
        (spec, freqs) = mlab.phase_spectrum(x=x, Fs=Fs, window=window, pad_to=pad_to, sides=sides)
        freqs += Fc
        lines = self.plot(freqs, spec, **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Phase (radians)')
        return (spec, freqs, lines[0])

    @_api.make_keyword_only('3.9', 'NFFT')
    @_preprocess_data(replace_names=['x', 'y'])
    @_docstring.dedent_interpd
    def cohere(self, x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none, window=mlab.window_hanning, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, **kwargs):
        (cxy, freqs) = mlab.cohere(x=x, y=y, NFFT=NFFT, Fs=Fs, detrend=detrend, window=window, noverlap=noverlap, scale_by_freq=scale_by_freq, sides=sides, pad_to=pad_to)
        freqs += Fc
        self.plot(freqs, cxy, **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Coherence')
        self.grid(True)
        return (cxy, freqs)

    @_api.make_keyword_only('3.9', 'NFFT')
    @_preprocess_data(replace_names=['x'])
    @_docstring.dedent_interpd
    def specgram(self, x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, **kwargs):
        if NFFT is None:
            NFFT = 256
        if Fc is None:
            Fc = 0
        if noverlap is None:
            noverlap = 128
        if Fs is None:
            Fs = 2
        if mode == 'complex':
            raise ValueError('Cannot plot a complex specgram')
        if scale is None or scale == 'default':
            if mode in ['angle', 'phase']:
                scale = 'linear'
            else:
                scale = 'dB'
        elif mode in ['angle', 'phase'] and scale == 'dB':
            raise ValueError('Cannot use dB scale with angle or phase mode')
        (spec, freqs, t) = mlab.specgram(x=x, NFFT=NFFT, Fs=Fs, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode=mode)
        if scale == 'linear':
            Z = spec
        elif scale == 'dB':
            if mode is None or mode == 'default' or mode == 'psd':
                Z = 10.0 * np.log10(spec)
            else:
                Z = 20.0 * np.log10(spec)
        else:
            raise ValueError(f'Unknown scale {scale!r}')
        Z = np.flipud(Z)
        if xextent is None:
            pad_xextent = (NFFT - noverlap) / Fs / 2
            xextent = (np.min(t) - pad_xextent, np.max(t) + pad_xextent)
        (xmin, xmax) = xextent
        freqs += Fc
        extent = (xmin, xmax, freqs[0], freqs[-1])
        if 'origin' in kwargs:
            raise _api.kwarg_error('specgram', 'origin')
        im = self.imshow(Z, cmap, extent=extent, vmin=vmin, vmax=vmax, origin='upper', **kwargs)
        self.axis('auto')
        return (spec, freqs, t, im)

    @_api.make_keyword_only('3.9', 'precision')
    @_docstring.dedent_interpd
    def spy(self, Z, precision=0, marker=None, markersize=None, aspect='equal', origin='upper', **kwargs):
        if marker is None and markersize is None and hasattr(Z, 'tocoo'):
            marker = 's'
        _api.check_in_list(['upper', 'lower'], origin=origin)
        if marker is None and markersize is None:
            Z = np.asarray(Z)
            mask = np.abs(Z) > precision
            if 'cmap' not in kwargs:
                kwargs['cmap'] = mcolors.ListedColormap(['w', 'k'], name='binary')
            if 'interpolation' in kwargs:
                raise _api.kwarg_error('spy', 'interpolation')
            if 'norm' not in kwargs:
                kwargs['norm'] = mcolors.NoNorm()
            ret = self.imshow(mask, interpolation='nearest', aspect=aspect, origin=origin, **kwargs)
        else:
            if hasattr(Z, 'tocoo'):
                c = Z.tocoo()
                if precision == 'present':
                    y = c.row
                    x = c.col
                else:
                    nonzero = np.abs(c.data) > precision
                    y = c.row[nonzero]
                    x = c.col[nonzero]
            else:
                Z = np.asarray(Z)
                nonzero = np.abs(Z) > precision
                (y, x) = np.nonzero(nonzero)
            if marker is None:
                marker = 's'
            if markersize is None:
                markersize = 10
            if 'linestyle' in kwargs:
                raise _api.kwarg_error('spy', 'linestyle')
            ret = mlines.Line2D(x, y, linestyle='None', marker=marker, markersize=markersize, **kwargs)
            self.add_line(ret)
            (nr, nc) = Z.shape
            self.set_xlim(-0.5, nc - 0.5)
            if origin == 'upper':
                self.set_ylim(nr - 0.5, -0.5)
            else:
                self.set_ylim(-0.5, nr - 0.5)
            self.set_aspect(aspect)
        self.title.set_y(1.05)
        if origin == 'upper':
            self.xaxis.tick_top()
        else:
            self.xaxis.tick_bottom()
        self.xaxis.set_ticks_position('both')
        self.xaxis.set_major_locator(mticker.MaxNLocator(nbins=9, steps=[1, 2, 5, 10], integer=True))
        self.yaxis.set_major_locator(mticker.MaxNLocator(nbins=9, steps=[1, 2, 5, 10], integer=True))
        return ret

    def matshow(self, Z, **kwargs):
        Z = np.asanyarray(Z)
        kw = {'origin': 'upper', 'interpolation': 'nearest', 'aspect': 'equal', **kwargs}
        im = self.imshow(Z, **kw)
        self.title.set_y(1.05)
        self.xaxis.tick_top()
        self.xaxis.set_ticks_position('both')
        self.xaxis.set_major_locator(mticker.MaxNLocator(nbins=9, steps=[1, 2, 5, 10], integer=True))
        self.yaxis.set_major_locator(mticker.MaxNLocator(nbins=9, steps=[1, 2, 5, 10], integer=True))
        return im

    @_api.make_keyword_only('3.9', 'vert')
    @_preprocess_data(replace_names=['dataset'])
    def violinplot(self, dataset, positions=None, vert=None, orientation='vertical', widths=0.5, showmeans=False, showextrema=True, showmedians=False, quantiles=None, points=100, bw_method=None, side='both'):

        def _kde_method(X, coords):
            X = cbook._unpack_to_numpy(X)
            if np.all(X[0] == X):
                return (X[0] == coords).astype(float)
            kde = mlab.GaussianKDE(X, bw_method)
            return kde.evaluate(coords)
        vpstats = cbook.violin_stats(dataset, _kde_method, points=points, quantiles=quantiles)
        return self.violin(vpstats, positions=positions, vert=vert, orientation=orientation, widths=widths, showmeans=showmeans, showextrema=showextrema, showmedians=showmedians, side=side)

    @_api.make_keyword_only('3.9', 'vert')
    def violin(self, vpstats, positions=None, vert=None, orientation='vertical', widths=0.5, showmeans=False, showextrema=True, showmedians=False, side='both'):
        means = []
        mins = []
        maxes = []
        medians = []
        quantiles = []
        qlens = []
        artists = {}
        N = len(vpstats)
        datashape_message = 'List of violinplot statistics and `{0}` values must have the same length'
        if vert is not None:
            _api.warn_deprecated('3.10', name='vert: bool', alternative="orientation: {'vertical', 'horizontal'}")
            orientation = 'vertical' if vert else 'horizontal'
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        if positions is None:
            positions = range(1, N + 1)
        elif len(positions) != N:
            raise ValueError(datashape_message.format('positions'))
        if np.isscalar(widths):
            widths = [widths] * N
        elif len(widths) != N:
            raise ValueError(datashape_message.format('widths'))
        _api.check_in_list(['both', 'low', 'high'], side=side)
        line_ends = [[-0.25 if side in ['both', 'low'] else 0], [0.25 if side in ['both', 'high'] else 0]] * np.array(widths) + positions
        if mpl.rcParams['_internal.classic_mode']:
            fillcolor = 'y'
            linecolor = 'r'
        else:
            fillcolor = linecolor = self._get_lines.get_next_color()
        if orientation == 'vertical':
            fill = self.fill_betweenx
            if side in ['low', 'high']:
                perp_lines = functools.partial(self.hlines, colors=linecolor, capstyle='projecting')
                par_lines = functools.partial(self.vlines, colors=linecolor, capstyle='projecting')
            else:
                perp_lines = functools.partial(self.hlines, colors=linecolor)
                par_lines = functools.partial(self.vlines, colors=linecolor)
        else:
            fill = self.fill_between
            if side in ['low', 'high']:
                perp_lines = functools.partial(self.vlines, colors=linecolor, capstyle='projecting')
                par_lines = functools.partial(self.hlines, colors=linecolor, capstyle='projecting')
            else:
                perp_lines = functools.partial(self.vlines, colors=linecolor)
                par_lines = functools.partial(self.hlines, colors=linecolor)
        bodies = []
        for (stats, pos, width) in zip(vpstats, positions, widths):
            vals = np.array(stats['vals'])
            vals = 0.5 * width * vals / vals.max()
            bodies += [fill(stats['coords'], -vals + pos if side in ['both', 'low'] else pos, vals + pos if side in ['both', 'high'] else pos, facecolor=fillcolor, alpha=0.3)]
            means.append(stats['mean'])
            mins.append(stats['min'])
            maxes.append(stats['max'])
            medians.append(stats['median'])
            q = stats.get('quantiles')
            if q is None:
                q = []
            quantiles.extend(q)
            qlens.append(len(q))
        artists['bodies'] = bodies
        if showmeans:
            artists['cmeans'] = perp_lines(means, *line_ends)
        if showextrema:
            artists['cmaxes'] = perp_lines(maxes, *line_ends)
            artists['cmins'] = perp_lines(mins, *line_ends)
            artists['cbars'] = par_lines(positions, mins, maxes)
        if showmedians:
            artists['cmedians'] = perp_lines(medians, *line_ends)
        if quantiles:
            artists['cquantiles'] = perp_lines(quantiles, *np.repeat(line_ends, qlens, axis=1))
        return artists
    table = _make_axes_method(mtable.table)
    stackplot = _preprocess_data()(_make_axes_method(mstack.stackplot))
    streamplot = _preprocess_data(replace_names=['x', 'y', 'u', 'v', 'start_points'])(_make_axes_method(mstream.streamplot))
    tricontour = _make_axes_method(mtri.tricontour)
    tricontourf = _make_axes_method(mtri.tricontourf)
    tripcolor = _make_axes_method(mtri.tripcolor)
    triplot = _make_axes_method(mtri.triplot)

    def _get_aspect_ratio(self):
        figure_size = self.get_figure().get_size_inches()
        (ll, ur) = self.get_position() * figure_size
        (width, height) = ur - ll
        return height / (width * self.get_data_ratio())

# File: matplotlib-main/lib/matplotlib/axes/_base.py
from collections.abc import Iterable, Sequence
from contextlib import ExitStack
import functools
import inspect
import logging
from numbers import Real
from operator import attrgetter
import re
import types
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, _docstring, offsetbox
import matplotlib.artist as martist
import matplotlib.axis as maxis
from matplotlib.cbook import _OrderedSet, _check_1d, index_of
import matplotlib.collections as mcoll
import matplotlib.colors as mcolors
import matplotlib.font_manager as font_manager
from matplotlib.gridspec import SubplotSpec
import matplotlib.image as mimage
import matplotlib.lines as mlines
import matplotlib.patches as mpatches
from matplotlib.rcsetup import cycler, validate_axisbelow
import matplotlib.spines as mspines
import matplotlib.table as mtable
import matplotlib.text as mtext
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
_log = logging.getLogger(__name__)

class _axis_method_wrapper:

    def __init__(self, attr_name, method_name, *, doc_sub=None):
        self.attr_name = attr_name
        self.method_name = method_name
        doc = inspect.getdoc(getattr(maxis.Axis, method_name))
        self._missing_subs = []
        if doc:
            doc_sub = {'this Axis': f'the {self.attr_name}', **(doc_sub or {})}
            for (k, v) in doc_sub.items():
                if k not in doc:
                    self._missing_subs.append(k)
                doc = doc.replace(k, v)
        self.__doc__ = doc

    def __set_name__(self, owner, name):
        get_method = attrgetter(f'{self.attr_name}.{self.method_name}')

        def wrapper(self, *args, **kwargs):
            return get_method(self)(*args, **kwargs)
        wrapper.__module__ = owner.__module__
        wrapper.__name__ = name
        wrapper.__qualname__ = f'{owner.__qualname__}.{name}'
        wrapper.__doc__ = self.__doc__
        wrapper.__signature__ = inspect.signature(getattr(maxis.Axis, self.method_name))
        if self._missing_subs:
            raise ValueError('The definition of {} expected that the docstring of Axis.{} contains {!r} as substrings'.format(wrapper.__qualname__, self.method_name, ', '.join(map(repr, self._missing_subs))))
        setattr(owner, name, wrapper)

class _TransformedBoundsLocator:

    def __init__(self, bounds, transform):
        self._bounds = bounds
        self._transform = transform

    def __call__(self, ax, renderer):
        return mtransforms.TransformedBbox(mtransforms.Bbox.from_bounds(*self._bounds), self._transform - ax.get_figure(root=False).transSubfigure)

def _process_plot_format(fmt, *, ambiguous_fmt_datakey=False):
    linestyle = None
    marker = None
    color = None
    if fmt not in ['0', '1']:
        try:
            color = mcolors.to_rgba(fmt)
            return (linestyle, marker, color)
        except ValueError:
            pass
    errfmt = '{!r} is neither a data key nor a valid format string ({})' if ambiguous_fmt_datakey else '{!r} is not a valid format string ({})'
    i = 0
    while i < len(fmt):
        c = fmt[i]
        if fmt[i:i + 2] in mlines.lineStyles:
            if linestyle is not None:
                raise ValueError(errfmt.format(fmt, 'two linestyle symbols'))
            linestyle = fmt[i:i + 2]
            i += 2
        elif c in mlines.lineStyles:
            if linestyle is not None:
                raise ValueError(errfmt.format(fmt, 'two linestyle symbols'))
            linestyle = c
            i += 1
        elif c in mlines.lineMarkers:
            if marker is not None:
                raise ValueError(errfmt.format(fmt, 'two marker symbols'))
            marker = c
            i += 1
        elif c in mcolors.get_named_colors_mapping():
            if color is not None:
                raise ValueError(errfmt.format(fmt, 'two color symbols'))
            color = c
            i += 1
        elif c == 'C':
            cn_color = re.match('C\\d+', fmt[i:])
            if not cn_color:
                raise ValueError(errfmt.format(fmt, "'C' must be followed by a number"))
            color = mcolors.to_rgba(cn_color[0])
            i += len(cn_color[0])
        else:
            raise ValueError(errfmt.format(fmt, f'unrecognized character {c!r}'))
    if linestyle is None and marker is None:
        linestyle = mpl.rcParams['lines.linestyle']
    if linestyle is None:
        linestyle = 'None'
    if marker is None:
        marker = 'None'
    return (linestyle, marker, color)

class _process_plot_var_args:

    def __init__(self, command='plot'):
        self.command = command
        self.set_prop_cycle(None)

    def set_prop_cycle(self, cycler):
        if cycler is None:
            cycler = mpl.rcParams['axes.prop_cycle']
        self._idx = 0
        self._cycler_items = [*cycler]

    def __call__(self, axes, *args, data=None, **kwargs):
        axes._process_unit_info(kwargs=kwargs)
        for pos_only in 'xy':
            if pos_only in kwargs:
                raise _api.kwarg_error(self.command, pos_only)
        if not args:
            return
        if data is None:
            args = [cbook.sanitize_sequence(a) for a in args]
        else:
            replaced = [mpl._replacer(data, arg) for arg in args]
            if len(args) == 1:
                label_namer_idx = 0
            elif len(args) == 2:
                try:
                    _process_plot_format(args[1])
                except ValueError:
                    label_namer_idx = 1
                else:
                    if replaced[1] is not args[1]:
                        _api.warn_external(f"Second argument {args[1]!r} is ambiguous: could be a format string but is in 'data'; using as data.  If it was intended as data, set the format string to an empty string to suppress this warning.  If it was intended as a format string, explicitly pass the x-values as well.  Alternatively, rename the entry in 'data'.", RuntimeWarning)
                        label_namer_idx = 1
                    else:
                        label_namer_idx = 0
            elif len(args) == 3:
                label_namer_idx = 1
            else:
                raise ValueError('Using arbitrary long args with data is not supported due to ambiguity of arguments; use multiple plotting calls instead')
            if kwargs.get('label') is None:
                kwargs['label'] = mpl._label_from_arg(replaced[label_namer_idx], args[label_namer_idx])
            args = replaced
        ambiguous_fmt_datakey = data is not None and len(args) == 2
        if len(args) >= 4 and (not cbook.is_scalar_or_string(kwargs.get('label'))):
            raise ValueError('plot() with multiple groups of data (i.e., pairs of x and y) does not support multiple labels')
        while args:
            (this, args) = (args[:2], args[2:])
            if args and isinstance(args[0], str):
                this += (args[0],)
                args = args[1:]
            yield from self._plot_args(axes, this, kwargs, ambiguous_fmt_datakey=ambiguous_fmt_datakey)

    def get_next_color(self):
        entry = self._cycler_items[self._idx]
        if 'color' in entry:
            self._idx = (self._idx + 1) % len(self._cycler_items)
            return entry['color']
        else:
            return 'k'

    def _getdefaults(self, kw, ignore=frozenset()):
        defaults = self._cycler_items[self._idx]
        if any((kw.get(k, None) is None for k in {*defaults} - ignore)):
            self._idx = (self._idx + 1) % len(self._cycler_items)
            return {k: v for (k, v) in defaults.items() if k not in ignore}
        else:
            return {}

    def _setdefaults(self, defaults, kw):
        for k in defaults:
            if kw.get(k, None) is None:
                kw[k] = defaults[k]

    def _makeline(self, axes, x, y, kw, kwargs):
        kw = {**kw, **kwargs}
        self._setdefaults(self._getdefaults(kw), kw)
        seg = mlines.Line2D(x, y, **kw)
        return (seg, kw)

    def _makefill(self, axes, x, y, kw, kwargs):
        x = axes.convert_xunits(x)
        y = axes.convert_yunits(y)
        kw = kw.copy()
        kwargs = kwargs.copy()
        ignores = {'marker', 'markersize', 'markeredgecolor', 'markerfacecolor', 'markeredgewidth'} | {k for (k, v) in kwargs.items() if v is not None}
        default_dict = self._getdefaults(kw, ignores)
        self._setdefaults(default_dict, kw)
        facecolor = kw.get('color', None)
        default_dict.pop('color', None)
        self._setdefaults(default_dict, kwargs)
        seg = mpatches.Polygon(np.column_stack((x, y)), facecolor=facecolor, fill=kwargs.get('fill', True), closed=kw['closed'])
        seg.set(**kwargs)
        return (seg, kwargs)

    def _plot_args(self, axes, tup, kwargs, *, return_kwargs=False, ambiguous_fmt_datakey=False):
        if len(tup) > 1 and isinstance(tup[-1], str):
            (*xy, fmt) = tup
            (linestyle, marker, color) = _process_plot_format(fmt, ambiguous_fmt_datakey=ambiguous_fmt_datakey)
        elif len(tup) == 3:
            raise ValueError('third arg must be a format string')
        else:
            xy = tup
            (linestyle, marker, color) = (None, None, None)
        if any((v is None for v in tup)):
            raise ValueError('x, y, and format string must not be None')
        kw = {}
        for (prop_name, val) in zip(('linestyle', 'marker', 'color'), (linestyle, marker, color)):
            if val is not None:
                if fmt.lower() != 'none' and prop_name in kwargs and (val != 'None'):
                    _api.warn_external(f'''{prop_name} is redundantly defined by the '{prop_name}' keyword argument and the fmt string "{fmt}" (-> {prop_name}={val!r}). The keyword argument will take precedence.''')
                kw[prop_name] = val
        if len(xy) == 2:
            x = _check_1d(xy[0])
            y = _check_1d(xy[1])
        else:
            (x, y) = index_of(xy[-1])
        if axes.xaxis is not None:
            axes.xaxis.update_units(x)
        if axes.yaxis is not None:
            axes.yaxis.update_units(y)
        if x.shape[0] != y.shape[0]:
            raise ValueError(f'x and y must have same first dimension, but have shapes {x.shape} and {y.shape}')
        if x.ndim > 2 or y.ndim > 2:
            raise ValueError(f'x and y can be no greater than 2D, but have shapes {x.shape} and {y.shape}')
        if x.ndim == 1:
            x = x[:, np.newaxis]
        if y.ndim == 1:
            y = y[:, np.newaxis]
        if self.command == 'plot':
            make_artist = self._makeline
        else:
            kw['closed'] = kwargs.get('closed', True)
            make_artist = self._makefill
        (ncx, ncy) = (x.shape[1], y.shape[1])
        if ncx > 1 and ncy > 1 and (ncx != ncy):
            raise ValueError(f'x has {ncx} columns but y has {ncy} columns')
        if ncx == 0 or ncy == 0:
            return []
        label = kwargs.get('label')
        n_datasets = max(ncx, ncy)
        if cbook.is_scalar_or_string(label):
            labels = [label] * n_datasets
        elif len(label) == n_datasets:
            labels = label
        elif n_datasets == 1:
            msg = f'Passing label as a length {len(label)} sequence when plotting a single dataset is deprecated in Matplotlib 3.9 and will error in 3.11.  To keep the current behavior, cast the sequence to string before passing.'
            _api.warn_deprecated('3.9', message=msg)
            labels = [label]
        else:
            raise ValueError(f'label must be scalar or have the same length as the input data, but found {len(label)} for {n_datasets} datasets.')
        result = (make_artist(axes, x[:, j % ncx], y[:, j % ncy], kw, {**kwargs, 'label': label}) for (j, label) in enumerate(labels))
        if return_kwargs:
            return list(result)
        else:
            return [l[0] for l in result]

@_api.define_aliases({'facecolor': ['fc']})
class _AxesBase(martist.Artist):
    name = 'rectilinear'
    _axis_names = ('x', 'y')
    _shared_axes = {name: cbook.Grouper() for name in _axis_names}
    _twinned_axes = cbook.Grouper()
    _subclass_uses_cla = False

    @property
    def _axis_map(self):
        return {name: getattr(self, f'{name}axis') for name in self._axis_names}

    def __str__(self):
        return '{0}({1[0]:g},{1[1]:g};{1[2]:g}x{1[3]:g})'.format(type(self).__name__, self._position.bounds)

    def __init__(self, fig, *args, facecolor=None, frameon=True, sharex=None, sharey=None, label='', xscale=None, yscale=None, box_aspect=None, forward_navigation_events='auto', **kwargs):
        super().__init__()
        if 'rect' in kwargs:
            if args:
                raise TypeError("'rect' cannot be used together with positional arguments")
            rect = kwargs.pop('rect')
            _api.check_isinstance((mtransforms.Bbox, Iterable), rect=rect)
            args = (rect,)
        subplotspec = None
        if len(args) == 1 and isinstance(args[0], mtransforms.Bbox):
            self._position = args[0]
        elif len(args) == 1 and np.iterable(args[0]):
            self._position = mtransforms.Bbox.from_bounds(*args[0])
        else:
            self._position = self._originalPosition = mtransforms.Bbox.unit()
            subplotspec = SubplotSpec._from_subplot_args(fig, args)
        if self._position.width < 0 or self._position.height < 0:
            raise ValueError('Width and height specified must be non-negative')
        self._originalPosition = self._position.frozen()
        self.axes = self
        self._aspect = 'auto'
        self._adjustable = 'box'
        self._anchor = 'C'
        self._stale_viewlims = dict.fromkeys(self._axis_names, False)
        self._forward_navigation_events = forward_navigation_events
        self._sharex = sharex
        self._sharey = sharey
        self.set_label(label)
        self.set_figure(fig)
        if subplotspec:
            self.set_subplotspec(subplotspec)
        else:
            self._subplotspec = None
        self.set_box_aspect(box_aspect)
        self._axes_locator = None
        self._children = []
        self._colorbars = []
        self.spines = mspines.Spines.from_dict(self._gen_axes_spines())
        self._init_axis()
        if facecolor is None:
            facecolor = mpl.rcParams['axes.facecolor']
        self._facecolor = facecolor
        self._frameon = frameon
        self.set_axisbelow(mpl.rcParams['axes.axisbelow'])
        self._rasterization_zorder = None
        self.clear()
        self.fmt_xdata = None
        self.fmt_ydata = None
        self.set_navigate(True)
        self.set_navigate_mode(None)
        if xscale:
            self.set_xscale(xscale)
        if yscale:
            self.set_yscale(yscale)
        self._internal_update(kwargs)
        for (name, axis) in self._axis_map.items():
            axis.callbacks._connect_picklable('units', self._unit_change_handler(name))
        rcParams = mpl.rcParams
        self.tick_params(top=rcParams['xtick.top'] and rcParams['xtick.minor.top'], bottom=rcParams['xtick.bottom'] and rcParams['xtick.minor.bottom'], labeltop=rcParams['xtick.labeltop'] and rcParams['xtick.minor.top'], labelbottom=rcParams['xtick.labelbottom'] and rcParams['xtick.minor.bottom'], left=rcParams['ytick.left'] and rcParams['ytick.minor.left'], right=rcParams['ytick.right'] and rcParams['ytick.minor.right'], labelleft=rcParams['ytick.labelleft'] and rcParams['ytick.minor.left'], labelright=rcParams['ytick.labelright'] and rcParams['ytick.minor.right'], which='minor')
        self.tick_params(top=rcParams['xtick.top'] and rcParams['xtick.major.top'], bottom=rcParams['xtick.bottom'] and rcParams['xtick.major.bottom'], labeltop=rcParams['xtick.labeltop'] and rcParams['xtick.major.top'], labelbottom=rcParams['xtick.labelbottom'] and rcParams['xtick.major.bottom'], left=rcParams['ytick.left'] and rcParams['ytick.major.left'], right=rcParams['ytick.right'] and rcParams['ytick.major.right'], labelleft=rcParams['ytick.labelleft'] and rcParams['ytick.major.left'], labelright=rcParams['ytick.labelright'] and rcParams['ytick.major.right'], which='major')

    def __init_subclass__(cls, **kwargs):
        parent_uses_cla = super(cls, cls)._subclass_uses_cla
        if 'cla' in cls.__dict__:
            _api.warn_deprecated('3.6', pending=True, message=f'Overriding `Axes.cla` in {cls.__qualname__} is pending deprecation in %(since)s and will be fully deprecated in favor of `Axes.clear` in the future. Please report this to the {cls.__module__!r} author.')
        cls._subclass_uses_cla = 'cla' in cls.__dict__ or parent_uses_cla
        super().__init_subclass__(**kwargs)

    def __getstate__(self):
        state = super().__getstate__()
        state['_shared_axes'] = {name: self._shared_axes[name].get_siblings(self) for name in self._axis_names if self in self._shared_axes[name]}
        state['_twinned_axes'] = self._twinned_axes.get_siblings(self) if self in self._twinned_axes else None
        return state

    def __setstate__(self, state):
        shared_axes = state.pop('_shared_axes')
        for (name, shared_siblings) in shared_axes.items():
            self._shared_axes[name].join(*shared_siblings)
        twinned_siblings = state.pop('_twinned_axes')
        if twinned_siblings:
            self._twinned_axes.join(*twinned_siblings)
        self.__dict__ = state
        self._stale = True

    def __repr__(self):
        fields = []
        if self.get_label():
            fields += [f'label={self.get_label()!r}']
        if hasattr(self, 'get_title'):
            titles = {}
            for k in ['left', 'center', 'right']:
                title = self.get_title(loc=k)
                if title:
                    titles[k] = title
            if titles:
                fields += [f'title={titles}']
        for (name, axis) in self._axis_map.items():
            if axis.get_label() and axis.get_label().get_text():
                fields += [f'{name}label={axis.get_label().get_text()!r}']
        return f'<{self.__class__.__name__}: ' + ', '.join(fields) + '>'

    def get_subplotspec(self):
        return self._subplotspec

    def set_subplotspec(self, subplotspec):
        self._subplotspec = subplotspec
        self._set_position(subplotspec.get_position(self.get_figure(root=False)))

    def get_gridspec(self):
        return self._subplotspec.get_gridspec() if self._subplotspec else None

    def get_window_extent(self, renderer=None):
        return self.bbox

    def _init_axis(self):
        self.xaxis = maxis.XAxis(self, clear=False)
        self.spines.bottom.register_axis(self.xaxis)
        self.spines.top.register_axis(self.xaxis)
        self.yaxis = maxis.YAxis(self, clear=False)
        self.spines.left.register_axis(self.yaxis)
        self.spines.right.register_axis(self.yaxis)

    def set_figure(self, fig):
        super().set_figure(fig)
        self.bbox = mtransforms.TransformedBbox(self._position, fig.transSubfigure)
        self.dataLim = mtransforms.Bbox.null()
        self._viewLim = mtransforms.Bbox.unit()
        self.transScale = mtransforms.TransformWrapper(mtransforms.IdentityTransform())
        self._set_lim_and_transforms()

    def _unstale_viewLim(self):
        need_scale = {name: any((ax._stale_viewlims[name] for ax in self._shared_axes[name].get_siblings(self))) for name in self._axis_names}
        if any(need_scale.values()):
            for name in need_scale:
                for ax in self._shared_axes[name].get_siblings(self):
                    ax._stale_viewlims[name] = False
            self.autoscale_view(**{f'scale{name}': scale for (name, scale) in need_scale.items()})

    @property
    def viewLim(self):
        self._unstale_viewLim()
        return self._viewLim

    def _request_autoscale_view(self, axis='all', tight=None):
        axis_names = _api.check_getitem({**{k: [k] for k in self._axis_names}, 'all': self._axis_names}, axis=axis)
        for name in axis_names:
            self._stale_viewlims[name] = True
        if tight is not None:
            self._tight = tight

    def _set_lim_and_transforms(self):
        self.transAxes = mtransforms.BboxTransformTo(self.bbox)
        self.transScale = mtransforms.TransformWrapper(mtransforms.IdentityTransform())
        self.transLimits = mtransforms.BboxTransformFrom(mtransforms.TransformedBbox(self._viewLim, self.transScale))
        self.transData = self.transScale + (self.transLimits + self.transAxes)
        self._xaxis_transform = mtransforms.blended_transform_factory(self.transData, self.transAxes)
        self._yaxis_transform = mtransforms.blended_transform_factory(self.transAxes, self.transData)

    def get_xaxis_transform(self, which='grid'):
        if which == 'grid':
            return self._xaxis_transform
        elif which == 'tick1':
            return self.spines.bottom.get_spine_transform()
        elif which == 'tick2':
            return self.spines.top.get_spine_transform()
        else:
            raise ValueError(f'unknown value for which: {which!r}')

    def get_xaxis_text1_transform(self, pad_points):
        labels_align = mpl.rcParams['xtick.alignment']
        return (self.get_xaxis_transform(which='tick1') + mtransforms.ScaledTranslation(0, -1 * pad_points / 72, self.get_figure(root=False).dpi_scale_trans), 'top', labels_align)

    def get_xaxis_text2_transform(self, pad_points):
        labels_align = mpl.rcParams['xtick.alignment']
        return (self.get_xaxis_transform(which='tick2') + mtransforms.ScaledTranslation(0, pad_points / 72, self.get_figure(root=False).dpi_scale_trans), 'bottom', labels_align)

    def get_yaxis_transform(self, which='grid'):
        if which == 'grid':
            return self._yaxis_transform
        elif which == 'tick1':
            return self.spines.left.get_spine_transform()
        elif which == 'tick2':
            return self.spines.right.get_spine_transform()
        else:
            raise ValueError(f'unknown value for which: {which!r}')

    def get_yaxis_text1_transform(self, pad_points):
        labels_align = mpl.rcParams['ytick.alignment']
        return (self.get_yaxis_transform(which='tick1') + mtransforms.ScaledTranslation(-1 * pad_points / 72, 0, self.get_figure(root=False).dpi_scale_trans), labels_align, 'right')

    def get_yaxis_text2_transform(self, pad_points):
        labels_align = mpl.rcParams['ytick.alignment']
        return (self.get_yaxis_transform(which='tick2') + mtransforms.ScaledTranslation(pad_points / 72, 0, self.get_figure(root=False).dpi_scale_trans), labels_align, 'left')

    def _update_transScale(self):
        self.transScale.set(mtransforms.blended_transform_factory(self.xaxis.get_transform(), self.yaxis.get_transform()))

    def get_position(self, original=False):
        if original:
            return self._originalPosition.frozen()
        else:
            locator = self.get_axes_locator()
            if not locator:
                self.apply_aspect()
            return self._position.frozen()

    def set_position(self, pos, which='both'):
        self._set_position(pos, which=which)
        self.set_in_layout(False)

    def _set_position(self, pos, which='both'):
        if not isinstance(pos, mtransforms.BboxBase):
            pos = mtransforms.Bbox.from_bounds(*pos)
        for ax in self._twinned_axes.get_siblings(self):
            if which in ('both', 'active'):
                ax._position.set(pos)
            if which in ('both', 'original'):
                ax._originalPosition.set(pos)
        self.stale = True

    def reset_position(self):
        for ax in self._twinned_axes.get_siblings(self):
            pos = ax.get_position(original=True)
            ax.set_position(pos, which='active')

    def set_axes_locator(self, locator):
        self._axes_locator = locator
        self.stale = True

    def get_axes_locator(self):
        return self._axes_locator

    def _set_artist_props(self, a):
        a.set_figure(self.get_figure(root=False))
        if not a.is_transform_set():
            a.set_transform(self.transData)
        a.axes = self
        if a.get_mouseover():
            self._mouseover_set.add(a)

    def _gen_axes_patch(self):
        return mpatches.Rectangle((0.0, 0.0), 1.0, 1.0)

    def _gen_axes_spines(self, locations=None, offset=0.0, units='inches'):
        return {side: mspines.Spine.linear_spine(self, side) for side in ['left', 'right', 'bottom', 'top']}

    def sharex(self, other):
        _api.check_isinstance(_AxesBase, other=other)
        if self._sharex is not None and other is not self._sharex:
            raise ValueError('x-axis is already shared')
        self._shared_axes['x'].join(self, other)
        self._sharex = other
        self.xaxis.major = other.xaxis.major
        self.xaxis.minor = other.xaxis.minor
        (x0, x1) = other.get_xlim()
        self.set_xlim(x0, x1, emit=False, auto=other.get_autoscalex_on())
        self.xaxis._scale = other.xaxis._scale

    def sharey(self, other):
        _api.check_isinstance(_AxesBase, other=other)
        if self._sharey is not None and other is not self._sharey:
            raise ValueError('y-axis is already shared')
        self._shared_axes['y'].join(self, other)
        self._sharey = other
        self.yaxis.major = other.yaxis.major
        self.yaxis.minor = other.yaxis.minor
        (y0, y1) = other.get_ylim()
        self.set_ylim(y0, y1, emit=False, auto=other.get_autoscaley_on())
        self.yaxis._scale = other.yaxis._scale

    def __clear(self):
        if hasattr(self, 'patch'):
            patch_visible = self.patch.get_visible()
        else:
            patch_visible = True
        xaxis_visible = self.xaxis.get_visible()
        yaxis_visible = self.yaxis.get_visible()
        for axis in self._axis_map.values():
            axis.clear()
        for spine in self.spines.values():
            spine._clear()
        self.ignore_existing_data_limits = True
        self.callbacks = cbook.CallbackRegistry(signals=['xlim_changed', 'ylim_changed', 'zlim_changed'])
        if mpl.rcParams['xtick.minor.visible']:
            self.xaxis.set_minor_locator(mticker.AutoMinorLocator())
        if mpl.rcParams['ytick.minor.visible']:
            self.yaxis.set_minor_locator(mticker.AutoMinorLocator())
        self._xmargin = mpl.rcParams['axes.xmargin']
        self._ymargin = mpl.rcParams['axes.ymargin']
        self._tight = None
        self._use_sticky_edges = True
        self._get_lines = _process_plot_var_args()
        self._get_patches_for_fill = _process_plot_var_args('fill')
        self._gridOn = mpl.rcParams['axes.grid']
        (old_children, self._children) = (self._children, [])
        for chld in old_children:
            chld.axes = chld._parent_figure = None
        self._mouseover_set = _OrderedSet()
        self.child_axes = []
        self._current_image = None
        self._projection_init = None
        self.legend_ = None
        self.containers = []
        self.grid(False)
        self.grid(self._gridOn, which=mpl.rcParams['axes.grid.which'], axis=mpl.rcParams['axes.grid.axis'])
        props = font_manager.FontProperties(size=mpl.rcParams['axes.titlesize'], weight=mpl.rcParams['axes.titleweight'])
        y = mpl.rcParams['axes.titley']
        if y is None:
            y = 1.0
            self._autotitlepos = True
        else:
            self._autotitlepos = False
        self.title = mtext.Text(x=0.5, y=y, text='', fontproperties=props, verticalalignment='baseline', horizontalalignment='center')
        self._left_title = mtext.Text(x=0.0, y=y, text='', fontproperties=props.copy(), verticalalignment='baseline', horizontalalignment='left')
        self._right_title = mtext.Text(x=1.0, y=y, text='', fontproperties=props.copy(), verticalalignment='baseline', horizontalalignment='right')
        title_offset_points = mpl.rcParams['axes.titlepad']
        self._set_title_offset_trans(title_offset_points)
        for _title in (self.title, self._left_title, self._right_title):
            self._set_artist_props(_title)
        self.patch = self._gen_axes_patch()
        self.patch.set_figure(self.get_figure(root=False))
        self.patch.set_facecolor(self._facecolor)
        self.patch.set_edgecolor('none')
        self.patch.set_linewidth(0)
        self.patch.set_transform(self.transAxes)
        self.set_axis_on()
        self.xaxis.set_clip_path(self.patch)
        self.yaxis.set_clip_path(self.patch)
        if self._sharex is not None:
            self.xaxis.set_visible(xaxis_visible)
            self.patch.set_visible(patch_visible)
        if self._sharey is not None:
            self.yaxis.set_visible(yaxis_visible)
            self.patch.set_visible(patch_visible)
        for (name, axis) in self._axis_map.items():
            share = getattr(self, f'_share{name}')
            if share is not None:
                getattr(self, f'share{name}')(share)
            else:
                if self.name == 'polar':
                    axis._set_scale('linear')
                axis._set_lim(0, 1, auto=True)
        self._update_transScale()
        self.stale = True

    def clear(self):
        if self._subclass_uses_cla:
            self.cla()
        else:
            self.__clear()

    def cla(self):
        if self._subclass_uses_cla:
            self.__clear()
        else:
            self.clear()

    class ArtistList(Sequence):

        def __init__(self, axes, prop_name, valid_types=None, invalid_types=None):
            self._axes = axes
            self._prop_name = prop_name
            self._type_check = lambda artist: (not valid_types or isinstance(artist, valid_types)) and (not invalid_types or not isinstance(artist, invalid_types))

        def __repr__(self):
            return f'<Axes.ArtistList of {len(self)} {self._prop_name}>'

        def __len__(self):
            return sum((self._type_check(artist) for artist in self._axes._children))

        def __iter__(self):
            for artist in list(self._axes._children):
                if self._type_check(artist):
                    yield artist

        def __getitem__(self, key):
            return [artist for artist in self._axes._children if self._type_check(artist)][key]

        def __add__(self, other):
            if isinstance(other, (list, _AxesBase.ArtistList)):
                return [*self, *other]
            if isinstance(other, (tuple, _AxesBase.ArtistList)):
                return (*self, *other)
            return NotImplemented

        def __radd__(self, other):
            if isinstance(other, list):
                return other + list(self)
            if isinstance(other, tuple):
                return other + tuple(self)
            return NotImplemented

    @property
    def artists(self):
        return self.ArtistList(self, 'artists', invalid_types=(mcoll.Collection, mimage.AxesImage, mlines.Line2D, mpatches.Patch, mtable.Table, mtext.Text))

    @property
    def collections(self):
        return self.ArtistList(self, 'collections', valid_types=mcoll.Collection)

    @property
    def images(self):
        return self.ArtistList(self, 'images', valid_types=mimage.AxesImage)

    @property
    def lines(self):
        return self.ArtistList(self, 'lines', valid_types=mlines.Line2D)

    @property
    def patches(self):
        return self.ArtistList(self, 'patches', valid_types=mpatches.Patch)

    @property
    def tables(self):
        return self.ArtistList(self, 'tables', valid_types=mtable.Table)

    @property
    def texts(self):
        return self.ArtistList(self, 'texts', valid_types=mtext.Text)

    def get_facecolor(self):
        return self.patch.get_facecolor()

    def set_facecolor(self, color):
        self._facecolor = color
        self.stale = True
        return self.patch.set_facecolor(color)

    def _set_title_offset_trans(self, title_offset_points):
        self.titleOffsetTrans = mtransforms.ScaledTranslation(0.0, title_offset_points / 72, self.get_figure(root=False).dpi_scale_trans)
        for _title in (self.title, self._left_title, self._right_title):
            _title.set_transform(self.transAxes + self.titleOffsetTrans)
            _title.set_clip_box(None)

    def set_prop_cycle(self, *args, **kwargs):
        if args and kwargs:
            raise TypeError('Cannot supply both positional and keyword arguments to this method.')
        if len(args) == 1 and args[0] is None:
            prop_cycle = None
        else:
            prop_cycle = cycler(*args, **kwargs)
        self._get_lines.set_prop_cycle(prop_cycle)
        self._get_patches_for_fill.set_prop_cycle(prop_cycle)

    def get_aspect(self):
        return self._aspect

    def set_aspect(self, aspect, adjustable=None, anchor=None, share=False):
        if cbook._str_equal(aspect, 'equal'):
            aspect = 1
        if not cbook._str_equal(aspect, 'auto'):
            aspect = float(aspect)
            if aspect <= 0 or not np.isfinite(aspect):
                raise ValueError('aspect must be finite and positive ')
        if share:
            axes = {sibling for name in self._axis_names for sibling in self._shared_axes[name].get_siblings(self)}
        else:
            axes = [self]
        for ax in axes:
            ax._aspect = aspect
        if adjustable is None:
            adjustable = self._adjustable
        self.set_adjustable(adjustable, share=share)
        if anchor is not None:
            self.set_anchor(anchor, share=share)
        self.stale = True

    def get_adjustable(self):
        return self._adjustable

    def set_adjustable(self, adjustable, share=False):
        _api.check_in_list(['box', 'datalim'], adjustable=adjustable)
        if share:
            axs = {sibling for name in self._axis_names for sibling in self._shared_axes[name].get_siblings(self)}
        else:
            axs = [self]
        if adjustable == 'datalim' and any((getattr(ax.get_data_ratio, '__func__', None) != _AxesBase.get_data_ratio for ax in axs)):
            raise ValueError("Cannot set Axes adjustable to 'datalim' for Axes which override 'get_data_ratio'")
        for ax in axs:
            ax._adjustable = adjustable
        self.stale = True

    def get_box_aspect(self):
        return self._box_aspect

    def set_box_aspect(self, aspect=None):
        axs = {*self._twinned_axes.get_siblings(self), *self._twinned_axes.get_siblings(self)}
        if aspect is not None:
            aspect = float(aspect)
            for ax in axs:
                ax.set_adjustable('datalim')
        for ax in axs:
            ax._box_aspect = aspect
            ax.stale = True

    def get_anchor(self):
        return self._anchor

    def set_anchor(self, anchor, share=False):
        if not (anchor in mtransforms.Bbox.coefs or len(anchor) == 2):
            raise ValueError('argument must be among %s' % ', '.join(mtransforms.Bbox.coefs))
        if share:
            axes = {sibling for name in self._axis_names for sibling in self._shared_axes[name].get_siblings(self)}
        else:
            axes = [self]
        for ax in axes:
            ax._anchor = anchor
        self.stale = True

    def get_data_ratio(self):
        (txmin, txmax) = self.xaxis.get_transform().transform(self.get_xbound())
        (tymin, tymax) = self.yaxis.get_transform().transform(self.get_ybound())
        xsize = max(abs(txmax - txmin), 1e-30)
        ysize = max(abs(tymax - tymin), 1e-30)
        return ysize / xsize

    def apply_aspect(self, position=None):
        if position is None:
            position = self.get_position(original=True)
        aspect = self.get_aspect()
        if aspect == 'auto' and self._box_aspect is None:
            self._set_position(position, which='active')
            return
        trans = self.get_figure(root=False).transSubfigure
        bb = mtransforms.Bbox.unit().transformed(trans)
        fig_aspect = bb.height / bb.width
        if self._adjustable == 'box':
            if self in self._twinned_axes:
                raise RuntimeError("Adjustable 'box' is not allowed in a twinned Axes; use 'datalim' instead")
            box_aspect = aspect * self.get_data_ratio()
            pb = position.frozen()
            pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)
            self._set_position(pb1.anchored(self.get_anchor(), pb), 'active')
            return
        if self._box_aspect is not None:
            pb = position.frozen()
            pb1 = pb.shrunk_to_aspect(self._box_aspect, pb, fig_aspect)
            self._set_position(pb1.anchored(self.get_anchor(), pb), 'active')
            if aspect == 'auto':
                return
        if self._box_aspect is None:
            self._set_position(position, which='active')
        else:
            position = pb1.anchored(self.get_anchor(), pb)
        x_trf = self.xaxis.get_transform()
        y_trf = self.yaxis.get_transform()
        (xmin, xmax) = x_trf.transform(self.get_xbound())
        (ymin, ymax) = y_trf.transform(self.get_ybound())
        xsize = max(abs(xmax - xmin), 1e-30)
        ysize = max(abs(ymax - ymin), 1e-30)
        box_aspect = fig_aspect * (position.height / position.width)
        data_ratio = box_aspect / aspect
        y_expander = data_ratio * xsize / ysize - 1
        if abs(y_expander) < 0.005:
            return
        dL = self.dataLim
        (x0, x1) = x_trf.transform(dL.intervalx)
        (y0, y1) = y_trf.transform(dL.intervaly)
        xr = 1.05 * (x1 - x0)
        yr = 1.05 * (y1 - y0)
        xmarg = xsize - xr
        ymarg = ysize - yr
        Ysize = data_ratio * xsize
        Xsize = ysize / data_ratio
        Xmarg = Xsize - xr
        Ymarg = Ysize - yr
        xm = 0
        ym = 0
        shared_x = self in self._shared_axes['x']
        shared_y = self in self._shared_axes['y']
        if shared_x and shared_y:
            raise RuntimeError("set_aspect(..., adjustable='datalim') or axis('equal') are not allowed when both axes are shared.  Try set_aspect(..., adjustable='box').")
        if shared_y:
            adjust_y = False
        else:
            if xmarg > xm and ymarg > ym:
                adjy = Ymarg > 0 and y_expander < 0 or (Xmarg < 0 and y_expander > 0)
            else:
                adjy = y_expander > 0
            adjust_y = shared_x or adjy
        if adjust_y:
            yc = 0.5 * (ymin + ymax)
            y0 = yc - Ysize / 2.0
            y1 = yc + Ysize / 2.0
            self.set_ybound(y_trf.inverted().transform([y0, y1]))
        else:
            xc = 0.5 * (xmin + xmax)
            x0 = xc - Xsize / 2.0
            x1 = xc + Xsize / 2.0
            self.set_xbound(x_trf.inverted().transform([x0, x1]))

    def axis(self, arg=None, /, *, emit=True, **kwargs):
        if isinstance(arg, (str, bool)):
            if arg is True:
                arg = 'on'
            if arg is False:
                arg = 'off'
            arg = arg.lower()
            if arg == 'on':
                self.set_axis_on()
            elif arg == 'off':
                self.set_axis_off()
            elif arg in ['equal', 'tight', 'scaled', 'auto', 'image', 'square']:
                self.set_autoscale_on(True)
                self.set_aspect('auto')
                self.autoscale_view(tight=False)
                if arg == 'equal':
                    self.set_aspect('equal', adjustable='datalim')
                elif arg == 'scaled':
                    self.set_aspect('equal', adjustable='box', anchor='C')
                    self.set_autoscale_on(False)
                elif arg == 'tight':
                    self.autoscale_view(tight=True)
                    self.set_autoscale_on(False)
                elif arg == 'image':
                    self.autoscale_view(tight=True)
                    self.set_autoscale_on(False)
                    self.set_aspect('equal', adjustable='box', anchor='C')
                elif arg == 'square':
                    self.set_aspect('equal', adjustable='box', anchor='C')
                    self.set_autoscale_on(False)
                    xlim = self.get_xlim()
                    ylim = self.get_ylim()
                    edge_size = max(np.diff(xlim), np.diff(ylim))[0]
                    self.set_xlim([xlim[0], xlim[0] + edge_size], emit=emit, auto=False)
                    self.set_ylim([ylim[0], ylim[0] + edge_size], emit=emit, auto=False)
            else:
                raise ValueError(f"Unrecognized string {arg!r} to axis; try 'on' or 'off'")
        else:
            if arg is not None:
                if len(arg) != 2 * len(self._axis_names):
                    raise TypeError('The first argument to axis() must be an iterable of the form [{}]'.format(', '.join((f'{name}min, {name}max' for name in self._axis_names))))
                limits = {name: arg[2 * i:2 * (i + 1)] for (i, name) in enumerate(self._axis_names)}
            else:
                limits = {}
                for name in self._axis_names:
                    ax_min = kwargs.pop(f'{name}min', None)
                    ax_max = kwargs.pop(f'{name}max', None)
                    limits[name] = (ax_min, ax_max)
            for (name, (ax_min, ax_max)) in limits.items():
                ax_auto = None if ax_min is None and ax_max is None else False
                set_ax_lim = getattr(self, f'set_{name}lim')
                set_ax_lim(ax_min, ax_max, emit=emit, auto=ax_auto)
        if kwargs:
            raise _api.kwarg_error('axis', kwargs)
        lims = ()
        for name in self._axis_names:
            get_ax_lim = getattr(self, f'get_{name}lim')
            lims += get_ax_lim()
        return lims

    def get_legend(self):
        return self.legend_

    def get_images(self):
        return cbook.silent_list('AxesImage', self.images)

    def get_lines(self):
        return cbook.silent_list('Line2D', self.lines)

    def get_xaxis(self):
        return self.xaxis

    def get_yaxis(self):
        return self.yaxis
    get_xgridlines = _axis_method_wrapper('xaxis', 'get_gridlines')
    get_xticklines = _axis_method_wrapper('xaxis', 'get_ticklines')
    get_ygridlines = _axis_method_wrapper('yaxis', 'get_gridlines')
    get_yticklines = _axis_method_wrapper('yaxis', 'get_ticklines')

    def _sci(self, im):
        _api.check_isinstance((mcoll.Collection, mimage.AxesImage), im=im)
        if im not in self._children:
            raise ValueError('Argument must be an image or collection in this Axes')
        self._current_image = im

    def _gci(self):
        return self._current_image

    def has_data(self):
        return any((isinstance(a, (mcoll.Collection, mimage.AxesImage, mlines.Line2D, mpatches.Patch)) for a in self._children))

    def add_artist(self, a):
        a.axes = self
        self._children.append(a)
        a._remove_method = self._children.remove
        self._set_artist_props(a)
        if a.get_clip_path() is None:
            a.set_clip_path(self.patch)
        self.stale = True
        return a

    def add_child_axes(self, ax):
        ax._axes = self
        ax.stale_callback = martist._stale_axes_callback
        self.child_axes.append(ax)
        ax._remove_method = functools.partial(self.get_figure(root=False)._remove_axes, owners=[self.child_axes])
        self.stale = True
        return ax

    def add_collection(self, collection, autolim=True):
        _api.check_isinstance(mcoll.Collection, collection=collection)
        if not collection.get_label():
            collection.set_label(f'_child{len(self._children)}')
        self._children.append(collection)
        collection._remove_method = self._children.remove
        self._set_artist_props(collection)
        if collection.get_clip_path() is None:
            collection.set_clip_path(self.patch)
        if autolim:
            self._unstale_viewLim()
            datalim = collection.get_datalim(self.transData)
            points = datalim.get_points()
            if not np.isinf(datalim.minpos).all():
                points = np.concatenate([points, [datalim.minpos]])
            self.update_datalim(points)
        self.stale = True
        return collection

    def add_image(self, image):
        _api.check_isinstance(mimage.AxesImage, image=image)
        self._set_artist_props(image)
        if not image.get_label():
            image.set_label(f'_child{len(self._children)}')
        self._children.append(image)
        image._remove_method = self._children.remove
        self.stale = True
        return image

    def _update_image_limits(self, image):
        (xmin, xmax, ymin, ymax) = image.get_extent()
        self.axes.update_datalim(((xmin, ymin), (xmax, ymax)))

    def add_line(self, line):
        _api.check_isinstance(mlines.Line2D, line=line)
        self._set_artist_props(line)
        if line.get_clip_path() is None:
            line.set_clip_path(self.patch)
        self._update_line_limits(line)
        if not line.get_label():
            line.set_label(f'_child{len(self._children)}')
        self._children.append(line)
        line._remove_method = self._children.remove
        self.stale = True
        return line

    def _add_text(self, txt):
        _api.check_isinstance(mtext.Text, txt=txt)
        self._set_artist_props(txt)
        self._children.append(txt)
        txt._remove_method = self._children.remove
        self.stale = True
        return txt

    def _update_line_limits(self, line):
        path = line.get_path()
        if path.vertices.size == 0:
            return
        line_trf = line.get_transform()
        if line_trf == self.transData:
            data_path = path
        elif any(line_trf.contains_branch_seperately(self.transData)):
            trf_to_data = line_trf - self.transData
            if self.transData.is_affine:
                line_trans_path = line._get_transformed_path()
                (na_path, _) = line_trans_path.get_transformed_path_and_affine()
                data_path = trf_to_data.transform_path_affine(na_path)
            else:
                data_path = trf_to_data.transform_path(path)
        else:
            data_path = path
        if not data_path.vertices.size:
            return
        (updatex, updatey) = line_trf.contains_branch_seperately(self.transData)
        if self.name != 'rectilinear':
            if updatex and line_trf == self.get_yaxis_transform():
                updatex = False
            if updatey and line_trf == self.get_xaxis_transform():
                updatey = False
        self.dataLim.update_from_path(data_path, self.ignore_existing_data_limits, updatex=updatex, updatey=updatey)
        self.ignore_existing_data_limits = False

    def add_patch(self, p):
        _api.check_isinstance(mpatches.Patch, p=p)
        self._set_artist_props(p)
        if p.get_clip_path() is None:
            p.set_clip_path(self.patch)
        self._update_patch_limits(p)
        self._children.append(p)
        p._remove_method = self._children.remove
        return p

    def _update_patch_limits(self, patch):
        if isinstance(patch, mpatches.Rectangle) and (not patch.get_width() and (not patch.get_height())):
            return
        p = patch.get_path()
        vertices = []
        for (curve, code) in p.iter_bezier(simplify=False):
            (_, dzeros) = curve.axis_aligned_extrema()
            vertices.append(curve([0, *dzeros, 1]))
        if len(vertices):
            vertices = np.vstack(vertices)
        patch_trf = patch.get_transform()
        (updatex, updatey) = patch_trf.contains_branch_seperately(self.transData)
        if not (updatex or updatey):
            return
        if self.name != 'rectilinear':
            if updatex and patch_trf == self.get_yaxis_transform():
                updatex = False
            if updatey and patch_trf == self.get_xaxis_transform():
                updatey = False
        trf_to_data = patch_trf - self.transData
        xys = trf_to_data.transform(vertices)
        self.update_datalim(xys, updatex=updatex, updatey=updatey)

    def add_table(self, tab):
        _api.check_isinstance(mtable.Table, tab=tab)
        self._set_artist_props(tab)
        self._children.append(tab)
        if tab.get_clip_path() is None:
            tab.set_clip_path(self.patch)
        tab._remove_method = self._children.remove
        return tab

    def add_container(self, container):
        label = container.get_label()
        if not label:
            container.set_label('_container%d' % len(self.containers))
        self.containers.append(container)
        container._remove_method = self.containers.remove
        return container

    def _unit_change_handler(self, axis_name, event=None):
        if event is None:
            return functools.partial(self._unit_change_handler, axis_name, event=object())
        _api.check_in_list(self._axis_map, axis_name=axis_name)
        for line in self.lines:
            line.recache_always()
        self.relim()
        self._request_autoscale_view(axis_name)

    def relim(self, visible_only=False):
        self.dataLim.ignore(True)
        self.dataLim.set_points(mtransforms.Bbox.null().get_points())
        self.ignore_existing_data_limits = True
        for artist in self._children:
            if not visible_only or artist.get_visible():
                if isinstance(artist, mlines.Line2D):
                    self._update_line_limits(artist)
                elif isinstance(artist, mpatches.Patch):
                    self._update_patch_limits(artist)
                elif isinstance(artist, mimage.AxesImage):
                    self._update_image_limits(artist)

    def update_datalim(self, xys, updatex=True, updatey=True):
        xys = np.asarray(xys)
        if not np.any(np.isfinite(xys)):
            return
        self.dataLim.update_from_data_xy(xys, self.ignore_existing_data_limits, updatex=updatex, updatey=updatey)
        self.ignore_existing_data_limits = False

    def _process_unit_info(self, datasets=None, kwargs=None, *, convert=True):
        datasets = datasets or []
        kwargs = kwargs or {}
        axis_map = self._axis_map
        for (axis_name, data) in datasets:
            try:
                axis = axis_map[axis_name]
            except KeyError:
                raise ValueError(f'Invalid axis name: {axis_name!r}') from None
            if axis is not None and data is not None and (not axis.have_units()):
                axis.update_units(data)
        for (axis_name, axis) in axis_map.items():
            if axis is None:
                continue
            units = kwargs.pop(f'{axis_name}units', axis.units)
            if self.name == 'polar':
                polar_units = {'x': 'thetaunits', 'y': 'runits'}
                units = kwargs.pop(polar_units[axis_name], units)
            if units != axis.units and units is not None:
                axis.set_units(units)
                for (dataset_axis_name, data) in datasets:
                    if dataset_axis_name == axis_name and data is not None:
                        axis.update_units(data)
        return [axis_map[axis_name].convert_units(data) if convert and data is not None else data for (axis_name, data) in datasets]

    def in_axes(self, mouseevent):
        return self.patch.contains(mouseevent)[0]
    get_autoscalex_on = _axis_method_wrapper('xaxis', '_get_autoscale_on')
    get_autoscaley_on = _axis_method_wrapper('yaxis', '_get_autoscale_on')
    set_autoscalex_on = _axis_method_wrapper('xaxis', '_set_autoscale_on')
    set_autoscaley_on = _axis_method_wrapper('yaxis', '_set_autoscale_on')

    def get_autoscale_on(self):
        return all((axis._get_autoscale_on() for axis in self._axis_map.values()))

    def set_autoscale_on(self, b):
        for axis in self._axis_map.values():
            axis._set_autoscale_on(b)

    @property
    def use_sticky_edges(self):
        return self._use_sticky_edges

    @use_sticky_edges.setter
    def use_sticky_edges(self, b):
        self._use_sticky_edges = bool(b)

    def get_xmargin(self):
        return self._xmargin

    def get_ymargin(self):
        return self._ymargin

    def set_xmargin(self, m):
        if m <= -0.5:
            raise ValueError('margin must be greater than -0.5')
        self._xmargin = m
        self._request_autoscale_view('x')
        self.stale = True

    def set_ymargin(self, m):
        if m <= -0.5:
            raise ValueError('margin must be greater than -0.5')
        self._ymargin = m
        self._request_autoscale_view('y')
        self.stale = True

    def margins(self, *margins, x=None, y=None, tight=True):
        if margins and (x is not None or y is not None):
            raise TypeError('Cannot pass both positional and keyword arguments for x and/or y.')
        elif len(margins) == 1:
            x = y = margins[0]
        elif len(margins) == 2:
            (x, y) = margins
        elif margins:
            raise TypeError('Must pass a single positional argument for all margins, or one for each margin (x, y).')
        if x is None and y is None:
            if tight is not True:
                _api.warn_external(f'ignoring tight={tight!r} in get mode')
            return (self._xmargin, self._ymargin)
        if tight is not None:
            self._tight = tight
        if x is not None:
            self.set_xmargin(x)
        if y is not None:
            self.set_ymargin(y)

    def set_rasterization_zorder(self, z):
        self._rasterization_zorder = z
        self.stale = True

    def get_rasterization_zorder(self):
        return self._rasterization_zorder

    def autoscale(self, enable=True, axis='both', tight=None):
        if enable is None:
            scalex = True
            scaley = True
        else:
            if axis in ['x', 'both']:
                self.set_autoscalex_on(bool(enable))
                scalex = self.get_autoscalex_on()
            else:
                scalex = False
            if axis in ['y', 'both']:
                self.set_autoscaley_on(bool(enable))
                scaley = self.get_autoscaley_on()
            else:
                scaley = False
        if tight and scalex:
            self._xmargin = 0
        if tight and scaley:
            self._ymargin = 0
        if scalex:
            self._request_autoscale_view('x', tight=tight)
        if scaley:
            self._request_autoscale_view('y', tight=tight)

    def autoscale_view(self, tight=None, scalex=True, scaley=True):
        if tight is not None:
            self._tight = bool(tight)
        x_stickies = y_stickies = np.array([])
        if self.use_sticky_edges:
            if self._xmargin and scalex and self.get_autoscalex_on():
                x_stickies = np.sort(np.concatenate([artist.sticky_edges.x for ax in self._shared_axes['x'].get_siblings(self) for artist in ax.get_children()]))
            if self._ymargin and scaley and self.get_autoscaley_on():
                y_stickies = np.sort(np.concatenate([artist.sticky_edges.y for ax in self._shared_axes['y'].get_siblings(self) for artist in ax.get_children()]))
        if self.get_xscale() == 'log':
            x_stickies = x_stickies[x_stickies > 0]
        if self.get_yscale() == 'log':
            y_stickies = y_stickies[y_stickies > 0]

        def handle_single_axis(scale, shared_axes, name, axis, margin, stickies, set_bound):
            if not (scale and axis._get_autoscale_on()):
                return
            shared = shared_axes.get_siblings(self)
            values = [val for ax in shared for val in getattr(ax.dataLim, f'interval{name}') if np.isfinite(val)]
            if values:
                (x0, x1) = (min(values), max(values))
            elif getattr(self._viewLim, f'mutated{name}')():
                return
            else:
                (x0, x1) = (-np.inf, np.inf)
            locator = axis.get_major_locator()
            (x0, x1) = locator.nonsingular(x0, x1)
            minimum_minpos = min((getattr(ax.dataLim, f'minpos{name}') for ax in shared))
            tol = 1e-05 * abs(x1 - x0)
            i0 = stickies.searchsorted(x0 + tol) - 1
            x0bound = stickies[i0] if i0 != -1 else None
            i1 = stickies.searchsorted(x1 - tol)
            x1bound = stickies[i1] if i1 != len(stickies) else None
            transform = axis.get_transform()
            inverse_trans = transform.inverted()
            (x0, x1) = axis._scale.limit_range_for_scale(x0, x1, minimum_minpos)
            (x0t, x1t) = transform.transform([x0, x1])
            delta = (x1t - x0t) * margin
            if not np.isfinite(delta):
                delta = 0
            (x0, x1) = inverse_trans.transform([x0t - delta, x1t + delta])
            if x0bound is not None:
                x0 = max(x0, x0bound)
            if x1bound is not None:
                x1 = min(x1, x1bound)
            if not self._tight:
                (x0, x1) = locator.view_limits(x0, x1)
            set_bound(x0, x1)
        handle_single_axis(scalex, self._shared_axes['x'], 'x', self.xaxis, self._xmargin, x_stickies, self.set_xbound)
        handle_single_axis(scaley, self._shared_axes['y'], 'y', self.yaxis, self._ymargin, y_stickies, self.set_ybound)

    def _update_title_position(self, renderer):
        if self._autotitlepos is not None and (not self._autotitlepos):
            _log.debug('title position was updated manually, not adjusting')
            return
        titles = (self.title, self._left_title, self._right_title)
        if not any((title.get_text() for title in titles)):
            return
        axs = set()
        axs.update(self.child_axes)
        axs.update(self._twinned_axes.get_siblings(self))
        axs.update(self.get_figure(root=False)._align_label_groups['title'].get_siblings(self))
        for ax in self.child_axes:
            locator = ax.get_axes_locator()
            ax.apply_aspect(locator(self, renderer) if locator else None)
        top = -np.inf
        for ax in axs:
            bb = None
            xticklabel_top = any((tick.label2.get_visible() for tick in [ax.xaxis.majorTicks[0], ax.xaxis.minorTicks[0]]))
            if xticklabel_top or ax.xaxis.get_label_position() == 'top':
                bb = ax.xaxis.get_tightbbox(renderer)
            if bb is None:
                bb = ax.spines.get('outline', ax).get_window_extent()
            top = max(top, bb.ymax)
        for title in titles:
            (x, _) = title.get_position()
            title.set_position((x, 1.0))
            if title.get_text():
                for ax in axs:
                    ax.yaxis.get_tightbbox(renderer)
                    if ax.yaxis.offsetText.get_text():
                        bb = ax.yaxis.offsetText.get_tightbbox(renderer)
                        if bb.intersection(title.get_tightbbox(renderer), bb):
                            top = bb.ymax
            if top < 0:
                _log.debug('top of Axes not in the figure, so title not moved')
                return
            if title.get_window_extent(renderer).ymin < top:
                (_, y) = self.transAxes.inverted().transform((0, top))
                title.set_position((x, y))
                if title.get_window_extent(renderer).ymin < top:
                    (_, y) = self.transAxes.inverted().transform((0.0, 2 * top - title.get_window_extent(renderer).ymin))
                    title.set_position((x, y))
        ymax = max((title.get_position()[1] for title in titles))
        for title in titles:
            (x, _) = title.get_position()
            title.set_position((x, ymax))

    @martist.allow_rasterization
    def draw(self, renderer):
        if renderer is None:
            raise RuntimeError('No renderer defined')
        if not self.get_visible():
            return
        self._unstale_viewLim()
        renderer.open_group('axes', gid=self.get_gid())
        self._stale = True
        locator = self.get_axes_locator()
        self.apply_aspect(locator(self, renderer) if locator else None)
        artists = self.get_children()
        artists.remove(self.patch)
        if not (self.axison and self._frameon):
            for spine in self.spines.values():
                artists.remove(spine)
        self._update_title_position(renderer)
        if not self.axison:
            for _axis in self._axis_map.values():
                artists.remove(_axis)
        if not self.get_figure(root=True).canvas.is_saving():
            artists = [a for a in artists if not a.get_animated() or isinstance(a, mimage.AxesImage)]
        artists = sorted(artists, key=attrgetter('zorder'))
        rasterization_zorder = self._rasterization_zorder
        if rasterization_zorder is not None and artists and (artists[0].zorder < rasterization_zorder):
            split_index = np.searchsorted([art.zorder for art in artists], rasterization_zorder, side='right')
            artists_rasterized = artists[:split_index]
            artists = artists[split_index:]
        else:
            artists_rasterized = []
        if self.axison and self._frameon:
            if artists_rasterized:
                artists_rasterized = [self.patch] + artists_rasterized
            else:
                artists = [self.patch] + artists
        if artists_rasterized:
            _draw_rasterized(self.get_figure(root=True), artists_rasterized, renderer)
        mimage._draw_list_compositing_images(renderer, self, artists, self.get_figure(root=True).suppressComposite)
        renderer.close_group('axes')
        self.stale = False

    def draw_artist(self, a):
        a.draw(self.get_figure(root=True).canvas.get_renderer())

    def redraw_in_frame(self):
        with ExitStack() as stack:
            for artist in [*self._axis_map.values(), self.title, self._left_title, self._right_title]:
                stack.enter_context(artist._cm_set(visible=False))
            self.draw(self.get_figure(root=True).canvas.get_renderer())

    def get_frame_on(self):
        return self._frameon

    def set_frame_on(self, b):
        self._frameon = b
        self.stale = True

    def get_axisbelow(self):
        return self._axisbelow

    def set_axisbelow(self, b):
        self._axisbelow = axisbelow = validate_axisbelow(b)
        zorder = {True: 0.5, 'line': 1.5, False: 2.5}[axisbelow]
        for axis in self._axis_map.values():
            axis.set_zorder(zorder)
        self.stale = True

    @_docstring.dedent_interpd
    def grid(self, visible=None, which='major', axis='both', **kwargs):
        _api.check_in_list(['x', 'y', 'both'], axis=axis)
        if axis in ['x', 'both']:
            self.xaxis.grid(visible, which=which, **kwargs)
        if axis in ['y', 'both']:
            self.yaxis.grid(visible, which=which, **kwargs)

    def ticklabel_format(self, *, axis='both', style=None, scilimits=None, useOffset=None, useLocale=None, useMathText=None):
        if isinstance(style, str):
            style = style.lower()
        axis = axis.lower()
        if scilimits is not None:
            try:
                (m, n) = scilimits
                m + n + 1
            except (ValueError, TypeError) as err:
                raise ValueError('scilimits must be a sequence of 2 integers') from err
        STYLES = {'sci': True, 'scientific': True, 'plain': False, '': None, None: None}
        is_sci_style = _api.check_getitem(STYLES, style=style)
        axis_map = {**{k: [v] for (k, v) in self._axis_map.items()}, 'both': list(self._axis_map.values())}
        axises = _api.check_getitem(axis_map, axis=axis)
        try:
            for axis in axises:
                if is_sci_style is not None:
                    axis.major.formatter.set_scientific(is_sci_style)
                if scilimits is not None:
                    axis.major.formatter.set_powerlimits(scilimits)
                if useOffset is not None:
                    axis.major.formatter.set_useOffset(useOffset)
                if useLocale is not None:
                    axis.major.formatter.set_useLocale(useLocale)
                if useMathText is not None:
                    axis.major.formatter.set_useMathText(useMathText)
        except AttributeError as err:
            raise AttributeError('This method only works with the ScalarFormatter') from err

    def locator_params(self, axis='both', tight=None, **kwargs):
        _api.check_in_list([*self._axis_names, 'both'], axis=axis)
        for name in self._axis_names:
            if axis in [name, 'both']:
                loc = self._axis_map[name].get_major_locator()
                loc.set_params(**kwargs)
                self._request_autoscale_view(name, tight=tight)
        self.stale = True

    def tick_params(self, axis='both', **kwargs):
        _api.check_in_list(['x', 'y', 'both'], axis=axis)
        if axis in ['x', 'both']:
            xkw = dict(kwargs)
            xkw.pop('left', None)
            xkw.pop('right', None)
            xkw.pop('labelleft', None)
            xkw.pop('labelright', None)
            self.xaxis.set_tick_params(**xkw)
        if axis in ['y', 'both']:
            ykw = dict(kwargs)
            ykw.pop('top', None)
            ykw.pop('bottom', None)
            ykw.pop('labeltop', None)
            ykw.pop('labelbottom', None)
            self.yaxis.set_tick_params(**ykw)

    def set_axis_off(self):
        self.axison = False
        self.stale = True

    def set_axis_on(self):
        self.axison = True
        self.stale = True

    def get_xlabel(self):
        label = self.xaxis.get_label()
        return label.get_text()

    def set_xlabel(self, xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs):
        if labelpad is not None:
            self.xaxis.labelpad = labelpad
        protected_kw = ['x', 'horizontalalignment', 'ha']
        if {*kwargs} & {*protected_kw}:
            if loc is not None:
                raise TypeError(f"Specifying 'loc' is disallowed when any of its corresponding low level keyword arguments ({protected_kw}) are also supplied")
        else:
            loc = loc if loc is not None else mpl.rcParams['xaxis.labellocation']
            _api.check_in_list(('left', 'center', 'right'), loc=loc)
            x = {'left': 0, 'center': 0.5, 'right': 1}[loc]
            kwargs.update(x=x, horizontalalignment=loc)
        return self.xaxis.set_label_text(xlabel, fontdict, **kwargs)

    def invert_xaxis(self):
        self.xaxis.set_inverted(not self.xaxis.get_inverted())
    xaxis_inverted = _axis_method_wrapper('xaxis', 'get_inverted')

    def get_xbound(self):
        (left, right) = self.get_xlim()
        if left < right:
            return (left, right)
        else:
            return (right, left)

    def set_xbound(self, lower=None, upper=None):
        if upper is None and np.iterable(lower):
            (lower, upper) = lower
        (old_lower, old_upper) = self.get_xbound()
        if lower is None:
            lower = old_lower
        if upper is None:
            upper = old_upper
        self.set_xlim(sorted((lower, upper), reverse=bool(self.xaxis_inverted())), auto=None)

    def get_xlim(self):
        return tuple(self.viewLim.intervalx)

    def _validate_converted_limits(self, limit, convert):
        if limit is not None:
            converted_limit = convert(limit)
            if isinstance(converted_limit, np.ndarray):
                converted_limit = converted_limit.squeeze()
            if isinstance(converted_limit, Real) and (not np.isfinite(converted_limit)):
                raise ValueError('Axis limits cannot be NaN or Inf')
            return converted_limit

    def set_xlim(self, left=None, right=None, *, emit=True, auto=False, xmin=None, xmax=None):
        if right is None and np.iterable(left):
            (left, right) = left
        if xmin is not None:
            if left is not None:
                raise TypeError("Cannot pass both 'left' and 'xmin'")
            left = xmin
        if xmax is not None:
            if right is not None:
                raise TypeError("Cannot pass both 'right' and 'xmax'")
            right = xmax
        return self.xaxis._set_lim(left, right, emit=emit, auto=auto)
    get_xscale = _axis_method_wrapper('xaxis', 'get_scale')
    set_xscale = _axis_method_wrapper('xaxis', '_set_axes_scale')
    get_xticks = _axis_method_wrapper('xaxis', 'get_ticklocs')
    set_xticks = _axis_method_wrapper('xaxis', 'set_ticks', doc_sub={'set_ticks': 'set_xticks'})
    get_xmajorticklabels = _axis_method_wrapper('xaxis', 'get_majorticklabels')
    get_xminorticklabels = _axis_method_wrapper('xaxis', 'get_minorticklabels')
    get_xticklabels = _axis_method_wrapper('xaxis', 'get_ticklabels')
    set_xticklabels = _axis_method_wrapper('xaxis', 'set_ticklabels', doc_sub={'Axis.set_ticks': 'Axes.set_xticks'})

    def get_ylabel(self):
        label = self.yaxis.get_label()
        return label.get_text()

    def set_ylabel(self, ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs):
        if labelpad is not None:
            self.yaxis.labelpad = labelpad
        protected_kw = ['y', 'horizontalalignment', 'ha']
        if {*kwargs} & {*protected_kw}:
            if loc is not None:
                raise TypeError(f"Specifying 'loc' is disallowed when any of its corresponding low level keyword arguments ({protected_kw}) are also supplied")
        else:
            loc = loc if loc is not None else mpl.rcParams['yaxis.labellocation']
            _api.check_in_list(('bottom', 'center', 'top'), loc=loc)
            (y, ha) = {'bottom': (0, 'left'), 'center': (0.5, 'center'), 'top': (1, 'right')}[loc]
            kwargs.update(y=y, horizontalalignment=ha)
        return self.yaxis.set_label_text(ylabel, fontdict, **kwargs)

    def invert_yaxis(self):
        self.yaxis.set_inverted(not self.yaxis.get_inverted())
    yaxis_inverted = _axis_method_wrapper('yaxis', 'get_inverted')

    def get_ybound(self):
        (bottom, top) = self.get_ylim()
        if bottom < top:
            return (bottom, top)
        else:
            return (top, bottom)

    def set_ybound(self, lower=None, upper=None):
        if upper is None and np.iterable(lower):
            (lower, upper) = lower
        (old_lower, old_upper) = self.get_ybound()
        if lower is None:
            lower = old_lower
        if upper is None:
            upper = old_upper
        self.set_ylim(sorted((lower, upper), reverse=bool(self.yaxis_inverted())), auto=None)

    def get_ylim(self):
        return tuple(self.viewLim.intervaly)

    def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False, ymin=None, ymax=None):
        if top is None and np.iterable(bottom):
            (bottom, top) = bottom
        if ymin is not None:
            if bottom is not None:
                raise TypeError("Cannot pass both 'bottom' and 'ymin'")
            bottom = ymin
        if ymax is not None:
            if top is not None:
                raise TypeError("Cannot pass both 'top' and 'ymax'")
            top = ymax
        return self.yaxis._set_lim(bottom, top, emit=emit, auto=auto)
    get_yscale = _axis_method_wrapper('yaxis', 'get_scale')
    set_yscale = _axis_method_wrapper('yaxis', '_set_axes_scale')
    get_yticks = _axis_method_wrapper('yaxis', 'get_ticklocs')
    set_yticks = _axis_method_wrapper('yaxis', 'set_ticks', doc_sub={'set_ticks': 'set_yticks'})
    get_ymajorticklabels = _axis_method_wrapper('yaxis', 'get_majorticklabels')
    get_yminorticklabels = _axis_method_wrapper('yaxis', 'get_minorticklabels')
    get_yticklabels = _axis_method_wrapper('yaxis', 'get_ticklabels')
    set_yticklabels = _axis_method_wrapper('yaxis', 'set_ticklabels', doc_sub={'Axis.set_ticks': 'Axes.set_yticks'})
    xaxis_date = _axis_method_wrapper('xaxis', 'axis_date')
    yaxis_date = _axis_method_wrapper('yaxis', 'axis_date')

    def format_xdata(self, x):
        return (self.fmt_xdata if self.fmt_xdata is not None else self.xaxis.get_major_formatter().format_data_short)(x)

    def format_ydata(self, y):
        return (self.fmt_ydata if self.fmt_ydata is not None else self.yaxis.get_major_formatter().format_data_short)(y)

    def format_coord(self, x, y):
        twins = self._twinned_axes.get_siblings(self)
        if len(twins) == 1:
            return '(x, y) = ({}, {})'.format('???' if x is None else self.format_xdata(x), '???' if y is None else self.format_ydata(y))
        screen_xy = self.transData.transform((x, y))
        xy_strs = []
        for ax in sorted(twins, key=attrgetter('zorder')):
            (data_x, data_y) = ax.transData.inverted().transform(screen_xy)
            xy_strs.append('({}, {})'.format(ax.format_xdata(data_x), ax.format_ydata(data_y)))
        return '(x, y) = {}'.format(' | '.join(xy_strs))

    def minorticks_on(self):
        self.xaxis.minorticks_on()
        self.yaxis.minorticks_on()

    def minorticks_off(self):
        self.xaxis.minorticks_off()
        self.yaxis.minorticks_off()

    def can_zoom(self):
        return True

    def can_pan(self):
        return True

    def get_navigate(self):
        return self._navigate

    def set_navigate(self, b):
        self._navigate = b

    def get_navigate_mode(self):
        return self._navigate_mode

    def set_navigate_mode(self, b):
        self._navigate_mode = b

    def _get_view(self):
        return {'xlim': self.get_xlim(), 'autoscalex_on': self.get_autoscalex_on(), 'ylim': self.get_ylim(), 'autoscaley_on': self.get_autoscaley_on()}

    def _set_view(self, view):
        self.set(**view)

    def _prepare_view_from_bbox(self, bbox, direction='in', mode=None, twinx=False, twiny=False):
        if len(bbox) == 3:
            (xp, yp, scl) = bbox
            if scl == 0:
                scl = 1.0
            if scl > 1:
                direction = 'in'
            else:
                direction = 'out'
                scl = 1 / scl
            ((xmin, ymin), (xmax, ymax)) = self.transData.transform(np.transpose([self.get_xlim(), self.get_ylim()]))
            xwidth = xmax - xmin
            ywidth = ymax - ymin
            xcen = (xmax + xmin) * 0.5
            ycen = (ymax + ymin) * 0.5
            xzc = (xp * (scl - 1) + xcen) / scl
            yzc = (yp * (scl - 1) + ycen) / scl
            bbox = [xzc - xwidth / 2.0 / scl, yzc - ywidth / 2.0 / scl, xzc + xwidth / 2.0 / scl, yzc + ywidth / 2.0 / scl]
        elif len(bbox) != 4:
            _api.warn_external('Warning in _set_view_from_bbox: bounding box is not a tuple of length 3 or 4. Ignoring the view change.')
            return
        (xmin0, xmax0) = self.get_xbound()
        (ymin0, ymax0) = self.get_ybound()
        (startx, starty, stopx, stopy) = bbox
        ((startx, starty), (stopx, stopy)) = self.transData.inverted().transform([(startx, starty), (stopx, stopy)])
        (xmin, xmax) = np.clip(sorted([startx, stopx]), xmin0, xmax0)
        (ymin, ymax) = np.clip(sorted([starty, stopy]), ymin0, ymax0)
        if twinx or mode == 'y':
            (xmin, xmax) = (xmin0, xmax0)
        if twiny or mode == 'x':
            (ymin, ymax) = (ymin0, ymax0)
        if direction == 'in':
            new_xbound = (xmin, xmax)
            new_ybound = (ymin, ymax)
        elif direction == 'out':
            x_trf = self.xaxis.get_transform()
            (sxmin0, sxmax0, sxmin, sxmax) = x_trf.transform([xmin0, xmax0, xmin, xmax])
            factor = (sxmax0 - sxmin0) / (sxmax - sxmin)
            sxmin1 = sxmin0 - factor * (sxmin - sxmin0)
            sxmax1 = sxmax0 + factor * (sxmax0 - sxmax)
            new_xbound = x_trf.inverted().transform([sxmin1, sxmax1])
            y_trf = self.yaxis.get_transform()
            (symin0, symax0, symin, symax) = y_trf.transform([ymin0, ymax0, ymin, ymax])
            factor = (symax0 - symin0) / (symax - symin)
            symin1 = symin0 - factor * (symin - symin0)
            symax1 = symax0 + factor * (symax0 - symax)
            new_ybound = y_trf.inverted().transform([symin1, symax1])
        return (new_xbound, new_ybound)

    def _set_view_from_bbox(self, bbox, direction='in', mode=None, twinx=False, twiny=False):
        (new_xbound, new_ybound) = self._prepare_view_from_bbox(bbox, direction=direction, mode=mode, twinx=twinx, twiny=twiny)
        if not twinx and mode != 'y':
            self.set_xbound(new_xbound)
            self.set_autoscalex_on(False)
        if not twiny and mode != 'x':
            self.set_ybound(new_ybound)
            self.set_autoscaley_on(False)

    def start_pan(self, x, y, button):
        self._pan_start = types.SimpleNamespace(lim=self.viewLim.frozen(), trans=self.transData.frozen(), trans_inverse=self.transData.inverted().frozen(), bbox=self.bbox.frozen(), x=x, y=y)

    def end_pan(self):
        del self._pan_start

    def _get_pan_points(self, button, key, x, y):

        def format_deltas(key, dx, dy):
            if key == 'control':
                if abs(dx) > abs(dy):
                    dy = dx
                else:
                    dx = dy
            elif key == 'x':
                dy = 0
            elif key == 'y':
                dx = 0
            elif key == 'shift':
                if 2 * abs(dx) < abs(dy):
                    dx = 0
                elif 2 * abs(dy) < abs(dx):
                    dy = 0
                elif abs(dx) > abs(dy):
                    dy = dy / abs(dy) * abs(dx)
                else:
                    dx = dx / abs(dx) * abs(dy)
            return (dx, dy)
        p = self._pan_start
        dx = x - p.x
        dy = y - p.y
        if dx == dy == 0:
            return
        if button == 1:
            (dx, dy) = format_deltas(key, dx, dy)
            result = p.bbox.translated(-dx, -dy).transformed(p.trans_inverse)
        elif button == 3:
            try:
                dx = -dx / self.bbox.width
                dy = -dy / self.bbox.height
                (dx, dy) = format_deltas(key, dx, dy)
                if self.get_aspect() != 'auto':
                    dx = dy = 0.5 * (dx + dy)
                alpha = np.power(10.0, (dx, dy))
                start = np.array([p.x, p.y])
                oldpoints = p.lim.transformed(p.trans)
                newpoints = start + alpha * (oldpoints - start)
                result = mtransforms.Bbox(newpoints).transformed(p.trans_inverse)
            except OverflowError:
                _api.warn_external('Overflow while panning')
                return
        else:
            return
        valid = np.isfinite(result.transformed(p.trans))
        points = result.get_points().astype(object)
        points[~valid] = None
        return points

    def drag_pan(self, button, key, x, y):
        points = self._get_pan_points(button, key, x, y)
        if points is not None:
            self.set_xlim(points[:, 0])
            self.set_ylim(points[:, 1])

    def get_children(self):
        return [*self._children, *self.spines.values(), *self._axis_map.values(), self.title, self._left_title, self._right_title, *self.child_axes, *([self.legend_] if self.legend_ is not None else []), self.patch]

    def contains(self, mouseevent):
        return self.patch.contains(mouseevent)

    def contains_point(self, point):
        return self.patch.contains_point(point, radius=1.0)

    def get_default_bbox_extra_artists(self):
        artists = self.get_children()
        for axis in self._axis_map.values():
            artists.remove(axis)
        if not (self.axison and self._frameon):
            for spine in self.spines.values():
                artists.remove(spine)
        artists.remove(self.title)
        artists.remove(self._left_title)
        artists.remove(self._right_title)
        noclip = (_AxesBase, maxis.Axis, offsetbox.AnnotationBbox, offsetbox.OffsetBox)
        return [a for a in artists if a.get_visible() and a.get_in_layout() and (isinstance(a, noclip) or not a._fully_clipped_to_axes())]

    def get_tightbbox(self, renderer=None, *, call_axes_locator=True, bbox_extra_artists=None, for_layout_only=False):
        bb = []
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        if not self.get_visible():
            return None
        locator = self.get_axes_locator()
        self.apply_aspect(locator(self, renderer) if locator and call_axes_locator else None)
        for axis in self._axis_map.values():
            if self.axison and axis.get_visible():
                ba = martist._get_tightbbox_for_layout_only(axis, renderer)
                if ba:
                    bb.append(ba)
        self._update_title_position(renderer)
        axbbox = self.get_window_extent(renderer)
        bb.append(axbbox)
        for title in [self.title, self._left_title, self._right_title]:
            if title.get_visible():
                bt = title.get_window_extent(renderer)
                if for_layout_only and bt.width > 0:
                    bt.x0 = (bt.x0 + bt.x1) / 2 - 0.5
                    bt.x1 = bt.x0 + 1.0
                bb.append(bt)
        bbox_artists = bbox_extra_artists
        if bbox_artists is None:
            bbox_artists = self.get_default_bbox_extra_artists()
        for a in bbox_artists:
            bbox = a.get_tightbbox(renderer)
            if bbox is not None and 0 < bbox.width < np.inf and (0 < bbox.height < np.inf):
                bb.append(bbox)
        return mtransforms.Bbox.union([b for b in bb if b.width != 0 or b.height != 0])

    def _make_twin_axes(self, *args, **kwargs):
        if 'sharex' in kwargs and 'sharey' in kwargs:
            if kwargs['sharex'] is not self and kwargs['sharey'] is not self:
                raise ValueError('Twinned Axes may share only one axis')
        ss = self.get_subplotspec()
        if ss:
            twin = self.get_figure(root=False).add_subplot(ss, *args, **kwargs)
        else:
            twin = self.get_figure(root=False).add_axes(self.get_position(True), *args, **kwargs, axes_locator=_TransformedBoundsLocator([0, 0, 1, 1], self.transAxes))
        self.set_adjustable('datalim')
        twin.set_adjustable('datalim')
        twin.set_zorder(self.zorder)
        self._twinned_axes.join(self, twin)
        return twin

    def twinx(self):
        ax2 = self._make_twin_axes(sharex=self)
        ax2.yaxis.tick_right()
        ax2.yaxis.set_label_position('right')
        ax2.yaxis.set_offset_position('right')
        ax2.set_autoscalex_on(self.get_autoscalex_on())
        self.yaxis.tick_left()
        ax2.xaxis.set_visible(False)
        ax2.patch.set_visible(False)
        ax2.xaxis.units = self.xaxis.units
        return ax2

    def twiny(self):
        ax2 = self._make_twin_axes(sharey=self)
        ax2.xaxis.tick_top()
        ax2.xaxis.set_label_position('top')
        ax2.set_autoscaley_on(self.get_autoscaley_on())
        self.xaxis.tick_bottom()
        ax2.yaxis.set_visible(False)
        ax2.patch.set_visible(False)
        ax2.yaxis.units = self.yaxis.units
        return ax2

    def get_shared_x_axes(self):
        return cbook.GrouperView(self._shared_axes['x'])

    def get_shared_y_axes(self):
        return cbook.GrouperView(self._shared_axes['y'])

    def label_outer(self, remove_inner_ticks=False):
        self._label_outer_xaxis(skip_non_rectangular_axes=False, remove_inner_ticks=remove_inner_ticks)
        self._label_outer_yaxis(skip_non_rectangular_axes=False, remove_inner_ticks=remove_inner_ticks)

    def _label_outer_xaxis(self, *, skip_non_rectangular_axes, remove_inner_ticks=False):
        if skip_non_rectangular_axes and (not isinstance(self.patch, mpl.patches.Rectangle)):
            return
        ss = self.get_subplotspec()
        if not ss:
            return
        label_position = self.xaxis.get_label_position()
        if not ss.is_first_row():
            if label_position == 'top':
                self.set_xlabel('')
            top_kw = {'top': False} if remove_inner_ticks else {}
            self.xaxis.set_tick_params(which='both', labeltop=False, **top_kw)
            if self.xaxis.offsetText.get_position()[1] == 1:
                self.xaxis.offsetText.set_visible(False)
        if not ss.is_last_row():
            if label_position == 'bottom':
                self.set_xlabel('')
            bottom_kw = {'bottom': False} if remove_inner_ticks else {}
            self.xaxis.set_tick_params(which='both', labelbottom=False, **bottom_kw)
            if self.xaxis.offsetText.get_position()[1] == 0:
                self.xaxis.offsetText.set_visible(False)

    def _label_outer_yaxis(self, *, skip_non_rectangular_axes, remove_inner_ticks=False):
        if skip_non_rectangular_axes and (not isinstance(self.patch, mpl.patches.Rectangle)):
            return
        ss = self.get_subplotspec()
        if not ss:
            return
        label_position = self.yaxis.get_label_position()
        if not ss.is_first_col():
            if label_position == 'left':
                self.set_ylabel('')
            left_kw = {'left': False} if remove_inner_ticks else {}
            self.yaxis.set_tick_params(which='both', labelleft=False, **left_kw)
            if self.yaxis.offsetText.get_position()[0] == 0:
                self.yaxis.offsetText.set_visible(False)
        if not ss.is_last_col():
            if label_position == 'right':
                self.set_ylabel('')
            right_kw = {'right': False} if remove_inner_ticks else {}
            self.yaxis.set_tick_params(which='both', labelright=False, **right_kw)
            if self.yaxis.offsetText.get_position()[0] == 1:
                self.yaxis.offsetText.set_visible(False)

    def set_forward_navigation_events(self, forward):
        self._forward_navigation_events = forward

    def get_forward_navigation_events(self):
        return self._forward_navigation_events

def _draw_rasterized(figure, artists, renderer):

    class _MinimalArtist:

        def get_rasterized(self):
            return True

        def get_agg_filter(self):
            return None

        def __init__(self, figure, artists):
            self.figure = figure
            self.artists = artists

        def get_figure(self, root=False):
            if root:
                return self.figure.get_figure(root=True)
            else:
                return self.figure

        @martist.allow_rasterization
        def draw(self, renderer):
            for a in self.artists:
                a.draw(renderer)
    return _MinimalArtist(figure, artists).draw(renderer)

# File: matplotlib-main/lib/matplotlib/axes/_secondary_axes.py
import numbers
import numpy as np
from matplotlib import _api, _docstring, transforms
import matplotlib.ticker as mticker
from matplotlib.axes._base import _AxesBase, _TransformedBoundsLocator
from matplotlib.axis import Axis
from matplotlib.transforms import Transform

class SecondaryAxis(_AxesBase):

    def __init__(self, parent, orientation, location, functions, transform=None, **kwargs):
        _api.check_in_list(['x', 'y'], orientation=orientation)
        self._functions = functions
        self._parent = parent
        self._orientation = orientation
        self._ticks_set = False
        fig = self._parent.get_figure(root=False)
        if self._orientation == 'x':
            super().__init__(fig, [0, 1.0, 1, 0.0001], **kwargs)
            self._axis = self.xaxis
            self._locstrings = ['top', 'bottom']
            self._otherstrings = ['left', 'right']
        else:
            super().__init__(fig, [0, 1.0, 0.0001, 1], **kwargs)
            self._axis = self.yaxis
            self._locstrings = ['right', 'left']
            self._otherstrings = ['top', 'bottom']
        self._parentscale = None
        self.set_location(location, transform)
        self.set_functions(functions)
        otheraxis = self.yaxis if self._orientation == 'x' else self.xaxis
        otheraxis.set_major_locator(mticker.NullLocator())
        otheraxis.set_ticks_position('none')
        self.spines[self._otherstrings].set_visible(False)
        self.spines[self._locstrings].set_visible(True)
        if self._pos < 0.5:
            self._locstrings = self._locstrings[::-1]
        self.set_alignment(self._locstrings[0])

    def set_alignment(self, align):
        _api.check_in_list(self._locstrings, align=align)
        if align == self._locstrings[1]:
            self._locstrings = self._locstrings[::-1]
        self.spines[self._locstrings[0]].set_visible(True)
        self.spines[self._locstrings[1]].set_visible(False)
        self._axis.set_ticks_position(align)
        self._axis.set_label_position(align)

    def set_location(self, location, transform=None):
        _api.check_isinstance((transforms.Transform, None), transform=transform)
        if isinstance(location, str):
            _api.check_in_list(self._locstrings, location=location)
            self._pos = 1.0 if location in ('top', 'right') else 0.0
        elif isinstance(location, numbers.Real):
            self._pos = location
        else:
            raise ValueError(f'location must be {self._locstrings[0]!r}, {self._locstrings[1]!r}, or a float, not {location!r}')
        self._loc = location
        if self._orientation == 'x':
            bounds = [0, self._pos, 1.0, 1e-10]
            if transform is not None:
                transform = transforms.blended_transform_factory(self._parent.transAxes, transform)
        else:
            bounds = [self._pos, 0, 1e-10, 1]
            if transform is not None:
                transform = transforms.blended_transform_factory(transform, self._parent.transAxes)
        if transform is None:
            transform = self._parent.transAxes
        self.set_axes_locator(_TransformedBoundsLocator(bounds, transform))

    def apply_aspect(self, position=None):
        self._set_lims()
        super().apply_aspect(position)

    @_docstring.copy(Axis.set_ticks)
    def set_ticks(self, ticks, labels=None, *, minor=False, **kwargs):
        ret = self._axis.set_ticks(ticks, labels, minor=minor, **kwargs)
        self.stale = True
        self._ticks_set = True
        return ret

    def set_functions(self, functions):
        if isinstance(functions, tuple) and len(functions) == 2 and callable(functions[0]) and callable(functions[1]):
            self._functions = functions
        elif isinstance(functions, Transform):
            self._functions = (functions.transform, lambda x: functions.inverted().transform(x))
        elif functions is None:
            self._functions = (lambda x: x, lambda x: x)
        else:
            raise ValueError('functions argument of secondary Axes must be a two-tuple of callable functions with the first function being the transform and the second being the inverse')
        self._set_scale()

    def draw(self, renderer):
        self._set_lims()
        self._set_scale()
        super().draw(renderer)

    def _set_scale(self):
        if self._orientation == 'x':
            pscale = self._parent.xaxis.get_scale()
            set_scale = self.set_xscale
        else:
            pscale = self._parent.yaxis.get_scale()
            set_scale = self.set_yscale
        if pscale == self._parentscale:
            return
        if self._ticks_set:
            ticks = self._axis.get_ticklocs()
        set_scale('functionlog' if pscale == 'log' else 'function', functions=self._functions[::-1])
        if self._ticks_set:
            self._axis.set_major_locator(mticker.FixedLocator(ticks))
        self._parentscale = pscale

    def _set_lims(self):
        if self._orientation == 'x':
            lims = self._parent.get_xlim()
            set_lim = self.set_xlim
        else:
            lims = self._parent.get_ylim()
            set_lim = self.set_ylim
        order = lims[0] < lims[1]
        lims = self._functions[0](np.array(lims))
        neworder = lims[0] < lims[1]
        if neworder != order:
            lims = lims[::-1]
        set_lim(lims)

    def set_aspect(self, *args, **kwargs):
        _api.warn_external("Secondary Axes can't set the aspect ratio")

    def set_color(self, color):
        axis = self._axis_map[self._orientation]
        axis.set_tick_params(colors=color)
        for spine in self.spines.values():
            if spine.axis is axis:
                spine.set_color(color)
        axis.label.set_color(color)
_secax_docstring = "\nWarnings\n--------\nThis method is experimental as of 3.1, and the API may change.\n\nParameters\n----------\nlocation : {'top', 'bottom', 'left', 'right'} or float\n    The position to put the secondary axis.  Strings can be 'top' or\n    'bottom' for orientation='x' and 'right' or 'left' for\n    orientation='y'. A float indicates the relative position on the\n    parent Axes to put the new Axes, 0.0 being the bottom (or left)\n    and 1.0 being the top (or right).\n\nfunctions : 2-tuple of func, or Transform with an inverse\n\n    If a 2-tuple of functions, the user specifies the transform\n    function and its inverse.  i.e.\n    ``functions=(lambda x: 2 / x, lambda x: 2 / x)`` would be an\n    reciprocal transform with a factor of 2. Both functions must accept\n    numpy arrays as input.\n\n    The user can also directly supply a subclass of\n    `.transforms.Transform` so long as it has an inverse.\n\n    See :doc:`/gallery/subplots_axes_and_figures/secondary_axis`\n    for examples of making these conversions.\n\ntransform : `.Transform`, optional\n    If specified, *location* will be\n    placed relative to this transform (in the direction of the axis)\n    rather than the parent's axis. i.e. a secondary x-axis will\n    use the provided y transform and the x transform of the parent.\n\n    .. versionadded:: 3.9\n\nReturns\n-------\nax : axes._secondary_axes.SecondaryAxis\n\nOther Parameters\n----------------\n**kwargs : `~matplotlib.axes.Axes` properties.\n    Other miscellaneous Axes parameters.\n"
_docstring.interpd.update(_secax_docstring=_secax_docstring)

# File: matplotlib-main/lib/matplotlib/axis.py
""""""
import datetime
import functools
import logging
from numbers import Real
import warnings
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
import matplotlib.artist as martist
import matplotlib.colors as mcolors
import matplotlib.lines as mlines
import matplotlib.scale as mscale
import matplotlib.text as mtext
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
import matplotlib.units as munits
_log = logging.getLogger(__name__)
GRIDLINE_INTERPOLATION_STEPS = 180
_line_inspector = martist.ArtistInspector(mlines.Line2D)
_line_param_names = _line_inspector.get_setters()
_line_param_aliases = [next(iter(d)) for d in _line_inspector.aliasd.values()]
_gridline_param_names = ['grid_' + name for name in _line_param_names + _line_param_aliases]

class Tick(martist.Artist):

    def __init__(self, axes, loc, *, size=None, width=None, color=None, tickdir=None, pad=None, labelsize=None, labelcolor=None, labelfontfamily=None, zorder=None, gridOn=None, tick1On=True, tick2On=True, label1On=True, label2On=False, major=True, labelrotation=0, grid_color=None, grid_linestyle=None, grid_linewidth=None, grid_alpha=None, **kwargs):
        super().__init__()
        if gridOn is None:
            which = mpl.rcParams['axes.grid.which']
            if major and which in ('both', 'major'):
                gridOn = mpl.rcParams['axes.grid']
            elif not major and which in ('both', 'minor'):
                gridOn = mpl.rcParams['axes.grid']
            else:
                gridOn = False
        self.set_figure(axes.get_figure(root=False))
        self.axes = axes
        self._loc = loc
        self._major = major
        name = self.__name__
        major_minor = 'major' if major else 'minor'
        if size is None:
            size = mpl.rcParams[f'{name}.{major_minor}.size']
        self._size = size
        if width is None:
            width = mpl.rcParams[f'{name}.{major_minor}.width']
        self._width = width
        if color is None:
            color = mpl.rcParams[f'{name}.color']
        if pad is None:
            pad = mpl.rcParams[f'{name}.{major_minor}.pad']
        self._base_pad = pad
        if labelcolor is None:
            labelcolor = mpl.rcParams[f'{name}.labelcolor']
        if cbook._str_equal(labelcolor, 'inherit'):
            labelcolor = mpl.rcParams[f'{name}.color']
        if labelsize is None:
            labelsize = mpl.rcParams[f'{name}.labelsize']
        self._set_labelrotation(labelrotation)
        if zorder is None:
            if major:
                zorder = mlines.Line2D.zorder + 0.01
            else:
                zorder = mlines.Line2D.zorder
        self._zorder = zorder
        grid_color = mpl._val_or_rc(grid_color, 'grid.color')
        grid_linestyle = mpl._val_or_rc(grid_linestyle, 'grid.linestyle')
        grid_linewidth = mpl._val_or_rc(grid_linewidth, 'grid.linewidth')
        if grid_alpha is None and (not mcolors._has_alpha_channel(grid_color)):
            grid_alpha = mpl.rcParams['grid.alpha']
        grid_kw = {k[5:]: v for (k, v) in kwargs.items()}
        self.tick1line = mlines.Line2D([], [], color=color, linestyle='none', zorder=zorder, visible=tick1On, markeredgecolor=color, markersize=size, markeredgewidth=width)
        self.tick2line = mlines.Line2D([], [], color=color, linestyle='none', zorder=zorder, visible=tick2On, markeredgecolor=color, markersize=size, markeredgewidth=width)
        self.gridline = mlines.Line2D([], [], color=grid_color, alpha=grid_alpha, visible=gridOn, linestyle=grid_linestyle, linewidth=grid_linewidth, marker='', **grid_kw)
        self.gridline.get_path()._interpolation_steps = GRIDLINE_INTERPOLATION_STEPS
        self.label1 = mtext.Text(np.nan, np.nan, fontsize=labelsize, color=labelcolor, visible=label1On, fontfamily=labelfontfamily, rotation=self._labelrotation[1])
        self.label2 = mtext.Text(np.nan, np.nan, fontsize=labelsize, color=labelcolor, visible=label2On, fontfamily=labelfontfamily, rotation=self._labelrotation[1])
        self._apply_tickdir(tickdir)
        for artist in [self.tick1line, self.tick2line, self.gridline, self.label1, self.label2]:
            self._set_artist_props(artist)
        self.update_position(loc)

    def _set_labelrotation(self, labelrotation):
        if isinstance(labelrotation, str):
            mode = labelrotation
            angle = 0
        elif isinstance(labelrotation, (tuple, list)):
            (mode, angle) = labelrotation
        else:
            mode = 'default'
            angle = labelrotation
        _api.check_in_list(['auto', 'default'], labelrotation=mode)
        self._labelrotation = (mode, angle)

    @property
    def _pad(self):
        return self._base_pad + self.get_tick_padding()

    def _apply_tickdir(self, tickdir):
        if tickdir is None:
            tickdir = mpl.rcParams[f'{self.__name__}.direction']
        else:
            _api.check_in_list(['in', 'out', 'inout'], tickdir=tickdir)
        self._tickdir = tickdir

    def get_tickdir(self):
        return self._tickdir

    def get_tick_padding(self):
        padding = {'in': 0.0, 'inout': 0.5, 'out': 1.0}
        return self._size * padding[self._tickdir]

    def get_children(self):
        children = [self.tick1line, self.tick2line, self.gridline, self.label1, self.label2]
        return children

    def set_clip_path(self, path, transform=None):
        super().set_clip_path(path, transform)
        self.gridline.set_clip_path(path, transform)
        self.stale = True

    def contains(self, mouseevent):
        return (False, {})

    def set_pad(self, val):
        self._apply_params(pad=val)
        self.stale = True

    def get_pad(self):
        return self._base_pad

    def get_loc(self):
        return self._loc

    @martist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            self.stale = False
            return
        renderer.open_group(self.__name__, gid=self.get_gid())
        for artist in [self.gridline, self.tick1line, self.tick2line, self.label1, self.label2]:
            artist.draw(renderer)
        renderer.close_group(self.__name__)
        self.stale = False

    def set_url(self, url):
        super().set_url(url)
        self.label1.set_url(url)
        self.label2.set_url(url)
        self.stale = True

    def _set_artist_props(self, a):
        a.set_figure(self.get_figure(root=False))

    def get_view_interval(self):
        raise NotImplementedError('Derived must override')

    def _apply_params(self, **kwargs):
        for (name, target) in [('gridOn', self.gridline), ('tick1On', self.tick1line), ('tick2On', self.tick2line), ('label1On', self.label1), ('label2On', self.label2)]:
            if name in kwargs:
                target.set_visible(kwargs.pop(name))
        if any((k in kwargs for k in ['size', 'width', 'pad', 'tickdir'])):
            self._size = kwargs.pop('size', self._size)
            self._width = kwargs.pop('width', self._width)
            self._base_pad = kwargs.pop('pad', self._base_pad)
            self._apply_tickdir(kwargs.pop('tickdir', self._tickdir))
            for line in (self.tick1line, self.tick2line):
                line.set_markersize(self._size)
                line.set_markeredgewidth(self._width)
            trans = self._get_text1_transform()[0]
            self.label1.set_transform(trans)
            trans = self._get_text2_transform()[0]
            self.label2.set_transform(trans)
        tick_kw = {k: v for (k, v) in kwargs.items() if k in ['color', 'zorder']}
        if 'color' in kwargs:
            tick_kw['markeredgecolor'] = kwargs['color']
        self.tick1line.set(**tick_kw)
        self.tick2line.set(**tick_kw)
        for (k, v) in tick_kw.items():
            setattr(self, '_' + k, v)
        if 'labelrotation' in kwargs:
            self._set_labelrotation(kwargs.pop('labelrotation'))
            self.label1.set(rotation=self._labelrotation[1])
            self.label2.set(rotation=self._labelrotation[1])
        label_kw = {k[5:]: v for (k, v) in kwargs.items() if k in ['labelsize', 'labelcolor', 'labelfontfamily']}
        self.label1.set(**label_kw)
        self.label2.set(**label_kw)
        grid_kw = {k[5:]: v for (k, v) in kwargs.items() if k in _gridline_param_names}
        self.gridline.set(**grid_kw)

    def update_position(self, loc):
        raise NotImplementedError('Derived must override')

    def _get_text1_transform(self):
        raise NotImplementedError('Derived must override')

    def _get_text2_transform(self):
        raise NotImplementedError('Derived must override')

class XTick(Tick):
    __name__ = 'xtick'

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        ax = self.axes
        self.tick1line.set(data=([0], [0]), transform=ax.get_xaxis_transform('tick1'))
        self.tick2line.set(data=([0], [1]), transform=ax.get_xaxis_transform('tick2'))
        self.gridline.set(data=([0, 0], [0, 1]), transform=ax.get_xaxis_transform('grid'))
        (trans, va, ha) = self._get_text1_transform()
        self.label1.set(x=0, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans)
        (trans, va, ha) = self._get_text2_transform()
        self.label2.set(x=0, y=1, verticalalignment=va, horizontalalignment=ha, transform=trans)

    def _get_text1_transform(self):
        return self.axes.get_xaxis_text1_transform(self._pad)

    def _get_text2_transform(self):
        return self.axes.get_xaxis_text2_transform(self._pad)

    def _apply_tickdir(self, tickdir):
        super()._apply_tickdir(tickdir)
        (mark1, mark2) = {'out': (mlines.TICKDOWN, mlines.TICKUP), 'in': (mlines.TICKUP, mlines.TICKDOWN), 'inout': ('|', '|')}[self._tickdir]
        self.tick1line.set_marker(mark1)
        self.tick2line.set_marker(mark2)

    def update_position(self, loc):
        self.tick1line.set_xdata((loc,))
        self.tick2line.set_xdata((loc,))
        self.gridline.set_xdata((loc,))
        self.label1.set_x(loc)
        self.label2.set_x(loc)
        self._loc = loc
        self.stale = True

    def get_view_interval(self):
        return self.axes.viewLim.intervalx

class YTick(Tick):
    __name__ = 'ytick'

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        ax = self.axes
        self.tick1line.set(data=([0], [0]), transform=ax.get_yaxis_transform('tick1'))
        self.tick2line.set(data=([1], [0]), transform=ax.get_yaxis_transform('tick2'))
        self.gridline.set(data=([0, 1], [0, 0]), transform=ax.get_yaxis_transform('grid'))
        (trans, va, ha) = self._get_text1_transform()
        self.label1.set(x=0, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans)
        (trans, va, ha) = self._get_text2_transform()
        self.label2.set(x=1, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans)

    def _get_text1_transform(self):
        return self.axes.get_yaxis_text1_transform(self._pad)

    def _get_text2_transform(self):
        return self.axes.get_yaxis_text2_transform(self._pad)

    def _apply_tickdir(self, tickdir):
        super()._apply_tickdir(tickdir)
        (mark1, mark2) = {'out': (mlines.TICKLEFT, mlines.TICKRIGHT), 'in': (mlines.TICKRIGHT, mlines.TICKLEFT), 'inout': ('_', '_')}[self._tickdir]
        self.tick1line.set_marker(mark1)
        self.tick2line.set_marker(mark2)

    def update_position(self, loc):
        self.tick1line.set_ydata((loc,))
        self.tick2line.set_ydata((loc,))
        self.gridline.set_ydata((loc,))
        self.label1.set_y(loc)
        self.label2.set_y(loc)
        self._loc = loc
        self.stale = True

    def get_view_interval(self):
        return self.axes.viewLim.intervaly

class Ticker:

    def __init__(self):
        self._locator = None
        self._formatter = None
        self._locator_is_default = True
        self._formatter_is_default = True

    @property
    def locator(self):
        return self._locator

    @locator.setter
    def locator(self, locator):
        if not isinstance(locator, mticker.Locator):
            raise TypeError('locator must be a subclass of matplotlib.ticker.Locator')
        self._locator = locator

    @property
    def formatter(self):
        return self._formatter

    @formatter.setter
    def formatter(self, formatter):
        if not isinstance(formatter, mticker.Formatter):
            raise TypeError('formatter must be a subclass of matplotlib.ticker.Formatter')
        self._formatter = formatter

class _LazyTickList:

    def __init__(self, major):
        self._major = major

    def __get__(self, instance, owner):
        if instance is None:
            return self
        elif self._major:
            instance.majorTicks = []
            tick = instance._get_tick(major=True)
            instance.majorTicks.append(tick)
            return instance.majorTicks
        else:
            instance.minorTicks = []
            tick = instance._get_tick(major=False)
            instance.minorTicks.append(tick)
            return instance.minorTicks

class Axis(martist.Artist):
    OFFSETTEXTPAD = 3
    _tick_class = None

    def __str__(self):
        return '{}({},{})'.format(type(self).__name__, *self.axes.transAxes.transform((0, 0)))

    def __init__(self, axes, *, pickradius=15, clear=True):
        super().__init__()
        self._remove_overlapping_locs = True
        self.set_figure(axes.get_figure(root=False))
        self.isDefault_label = True
        self.axes = axes
        self.major = Ticker()
        self.minor = Ticker()
        self.callbacks = cbook.CallbackRegistry(signals=['units'])
        self._autolabelpos = True
        self.label = mtext.Text(np.nan, np.nan, fontsize=mpl.rcParams['axes.labelsize'], fontweight=mpl.rcParams['axes.labelweight'], color=mpl.rcParams['axes.labelcolor'])
        self._set_artist_props(self.label)
        self.offsetText = mtext.Text(np.nan, np.nan)
        self._set_artist_props(self.offsetText)
        self.labelpad = mpl.rcParams['axes.labelpad']
        self.pickradius = pickradius
        self._major_tick_kw = dict()
        self._minor_tick_kw = dict()
        if clear:
            self.clear()
        else:
            self.converter = None
            self.units = None
        self._autoscale_on = True

    @property
    def isDefault_majloc(self):
        return self.major._locator_is_default

    @isDefault_majloc.setter
    def isDefault_majloc(self, value):
        self.major._locator_is_default = value

    @property
    def isDefault_majfmt(self):
        return self.major._formatter_is_default

    @isDefault_majfmt.setter
    def isDefault_majfmt(self, value):
        self.major._formatter_is_default = value

    @property
    def isDefault_minloc(self):
        return self.minor._locator_is_default

    @isDefault_minloc.setter
    def isDefault_minloc(self, value):
        self.minor._locator_is_default = value

    @property
    def isDefault_minfmt(self):
        return self.minor._formatter_is_default

    @isDefault_minfmt.setter
    def isDefault_minfmt(self, value):
        self.minor._formatter_is_default = value

    def _get_shared_axes(self):
        return self.axes._shared_axes[self._get_axis_name()].get_siblings(self.axes)

    def _get_shared_axis(self):
        name = self._get_axis_name()
        return [ax._axis_map[name] for ax in self._get_shared_axes()]

    def _get_axis_name(self):
        return next((name for (name, axis) in self.axes._axis_map.items() if axis is self))
    majorTicks = _LazyTickList(major=True)
    minorTicks = _LazyTickList(major=False)

    def get_remove_overlapping_locs(self):
        return self._remove_overlapping_locs

    def set_remove_overlapping_locs(self, val):
        self._remove_overlapping_locs = bool(val)
    remove_overlapping_locs = property(get_remove_overlapping_locs, set_remove_overlapping_locs, doc='If minor ticker locations that overlap with major ticker locations should be trimmed.')

    def set_label_coords(self, x, y, transform=None):
        self._autolabelpos = False
        if transform is None:
            transform = self.axes.transAxes
        self.label.set_transform(transform)
        self.label.set_position((x, y))
        self.stale = True

    def get_transform(self):
        return self._scale.get_transform()

    def get_scale(self):
        return self._scale.name

    def _set_scale(self, value, **kwargs):
        if not isinstance(value, mscale.ScaleBase):
            self._scale = mscale.scale_factory(value, self, **kwargs)
        else:
            self._scale = value
        self._scale.set_default_locators_and_formatters(self)
        self.isDefault_majloc = True
        self.isDefault_minloc = True
        self.isDefault_majfmt = True
        self.isDefault_minfmt = True

    def _set_axes_scale(self, value, **kwargs):
        name = self._get_axis_name()
        old_default_lims = self.get_major_locator().nonsingular(-np.inf, np.inf)
        for ax in self._get_shared_axes():
            ax._axis_map[name]._set_scale(value, **kwargs)
            ax._update_transScale()
            ax.stale = True
        new_default_lims = self.get_major_locator().nonsingular(-np.inf, np.inf)
        if old_default_lims != new_default_lims:
            self.axes.autoscale_view(**{f'scale{k}': k == name for k in self.axes._axis_names})

    def limit_range_for_scale(self, vmin, vmax):
        return self._scale.limit_range_for_scale(vmin, vmax, self.get_minpos())

    def _get_autoscale_on(self):
        return self._autoscale_on

    def _set_autoscale_on(self, b):
        if b is not None:
            self._autoscale_on = b

    def get_children(self):
        return [self.label, self.offsetText, *self.get_major_ticks(), *self.get_minor_ticks()]

    def _reset_major_tick_kw(self):
        self._major_tick_kw.clear()
        self._major_tick_kw['gridOn'] = mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'major')

    def _reset_minor_tick_kw(self):
        self._minor_tick_kw.clear()
        self._minor_tick_kw['gridOn'] = mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'minor')

    def clear(self):
        self.label._reset_visual_defaults()
        self.label.set_color(mpl.rcParams['axes.labelcolor'])
        self.label.set_fontsize(mpl.rcParams['axes.labelsize'])
        self.label.set_fontweight(mpl.rcParams['axes.labelweight'])
        self.offsetText._reset_visual_defaults()
        self.labelpad = mpl.rcParams['axes.labelpad']
        self._init()
        self._set_scale('linear')
        self.callbacks = cbook.CallbackRegistry(signals=['units'])
        self._major_tick_kw['gridOn'] = mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'major')
        self._minor_tick_kw['gridOn'] = mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'minor')
        self.reset_ticks()
        self.converter = None
        self.units = None
        self.stale = True

    def reset_ticks(self):
        try:
            del self.majorTicks
        except AttributeError:
            pass
        try:
            del self.minorTicks
        except AttributeError:
            pass
        try:
            self.set_clip_path(self.axes.patch)
        except AttributeError:
            pass

    def minorticks_on(self):
        scale = self.get_scale()
        if scale == 'log':
            s = self._scale
            self.set_minor_locator(mticker.LogLocator(s.base, s.subs))
        elif scale == 'symlog':
            s = self._scale
            self.set_minor_locator(mticker.SymmetricalLogLocator(s._transform, s.subs))
        elif scale == 'asinh':
            s = self._scale
            self.set_minor_locator(mticker.AsinhLocator(s.linear_width, base=s._base, subs=s._subs))
        elif scale == 'logit':
            self.set_minor_locator(mticker.LogitLocator(minor=True))
        else:
            self.set_minor_locator(mticker.AutoMinorLocator())

    def minorticks_off(self):
        self.set_minor_locator(mticker.NullLocator())

    def set_tick_params(self, which='major', reset=False, **kwargs):
        _api.check_in_list(['major', 'minor', 'both'], which=which)
        kwtrans = self._translate_tick_params(kwargs)
        if reset:
            if which in ['major', 'both']:
                self._reset_major_tick_kw()
                self._major_tick_kw.update(kwtrans)
            if which in ['minor', 'both']:
                self._reset_minor_tick_kw()
                self._minor_tick_kw.update(kwtrans)
            self.reset_ticks()
        else:
            if which in ['major', 'both']:
                self._major_tick_kw.update(kwtrans)
                for tick in self.majorTicks:
                    tick._apply_params(**kwtrans)
            if which in ['minor', 'both']:
                self._minor_tick_kw.update(kwtrans)
                for tick in self.minorTicks:
                    tick._apply_params(**kwtrans)
            if 'label1On' in kwtrans or 'label2On' in kwtrans:
                self.offsetText.set_visible(self._major_tick_kw.get('label1On', False) or self._major_tick_kw.get('label2On', False))
            if 'labelcolor' in kwtrans:
                self.offsetText.set_color(kwtrans['labelcolor'])
        self.stale = True

    def get_tick_params(self, which='major'):
        _api.check_in_list(['major', 'minor'], which=which)
        if which == 'major':
            return self._translate_tick_params(self._major_tick_kw, reverse=True)
        return self._translate_tick_params(self._minor_tick_kw, reverse=True)

    @staticmethod
    def _translate_tick_params(kw, reverse=False):
        kw_ = {**kw}
        allowed_keys = ['size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', *_gridline_param_names]
        keymap = {'length': 'size', 'direction': 'tickdir', 'rotation': 'labelrotation', 'left': 'tick1On', 'bottom': 'tick1On', 'right': 'tick2On', 'top': 'tick2On', 'labelleft': 'label1On', 'labelbottom': 'label1On', 'labelright': 'label2On', 'labeltop': 'label2On'}
        if reverse:
            kwtrans = {oldkey: kw_.pop(newkey) for (oldkey, newkey) in keymap.items() if newkey in kw_}
        else:
            kwtrans = {newkey: kw_.pop(oldkey) for (oldkey, newkey) in keymap.items() if oldkey in kw_}
        if 'colors' in kw_:
            c = kw_.pop('colors')
            kwtrans['color'] = c
            kwtrans['labelcolor'] = c
        for key in kw_:
            if key not in allowed_keys:
                raise ValueError('keyword %s is not recognized; valid keywords are %s' % (key, allowed_keys))
        kwtrans.update(kw_)
        return kwtrans

    def set_clip_path(self, path, transform=None):
        super().set_clip_path(path, transform)
        for child in self.majorTicks + self.minorTicks:
            child.set_clip_path(path, transform)
        self.stale = True

    def get_view_interval(self):
        raise NotImplementedError('Derived must override')

    def set_view_interval(self, vmin, vmax, ignore=False):
        raise NotImplementedError('Derived must override')

    def get_data_interval(self):
        raise NotImplementedError('Derived must override')

    def set_data_interval(self, vmin, vmax, ignore=False):
        raise NotImplementedError('Derived must override')

    def get_inverted(self):
        (low, high) = self.get_view_interval()
        return high < low

    def set_inverted(self, inverted):
        (a, b) = self.get_view_interval()
        self._set_lim(*sorted((a, b), reverse=bool(inverted)), auto=None)

    def set_default_intervals(self):

    def _set_lim(self, v0, v1, *, emit=True, auto):
        name = self._get_axis_name()
        self.axes._process_unit_info([(name, (v0, v1))], convert=False)
        v0 = self.axes._validate_converted_limits(v0, self.convert_units)
        v1 = self.axes._validate_converted_limits(v1, self.convert_units)
        if v0 is None or v1 is None:
            (old0, old1) = self.get_view_interval()
            if v0 is None:
                v0 = old0
            if v1 is None:
                v1 = old1
        if self.get_scale() == 'log' and (v0 <= 0 or v1 <= 0):
            (old0, old1) = self.get_view_interval()
            if v0 <= 0:
                _api.warn_external(f'Attempt to set non-positive {name}lim on a log-scaled axis will be ignored.')
                v0 = old0
            if v1 <= 0:
                _api.warn_external(f'Attempt to set non-positive {name}lim on a log-scaled axis will be ignored.')
                v1 = old1
        if v0 == v1:
            _api.warn_external(f'Attempting to set identical low and high {name}lims makes transformation singular; automatically expanding.')
        reverse = bool(v0 > v1)
        (v0, v1) = self.get_major_locator().nonsingular(v0, v1)
        (v0, v1) = self.limit_range_for_scale(v0, v1)
        (v0, v1) = sorted([v0, v1], reverse=bool(reverse))
        self.set_view_interval(v0, v1, ignore=True)
        for ax in self._get_shared_axes():
            ax._stale_viewlims[name] = False
        self._set_autoscale_on(auto)
        if emit:
            self.axes.callbacks.process(f'{name}lim_changed', self.axes)
            for other in self._get_shared_axes():
                if other is self.axes:
                    continue
                other._axis_map[name]._set_lim(v0, v1, emit=False, auto=auto)
                if emit:
                    other.callbacks.process(f'{name}lim_changed', other)
                if (other_fig := other.get_figure(root=False)) != self.get_figure(root=False):
                    other_fig.canvas.draw_idle()
        self.stale = True
        return (v0, v1)

    def _set_artist_props(self, a):
        if a is None:
            return
        a.set_figure(self.get_figure(root=False))

    def _update_ticks(self):
        major_locs = self.get_majorticklocs()
        major_labels = self.major.formatter.format_ticks(major_locs)
        major_ticks = self.get_major_ticks(len(major_locs))
        for (tick, loc, label) in zip(major_ticks, major_locs, major_labels):
            tick.update_position(loc)
            tick.label1.set_text(label)
            tick.label2.set_text(label)
        minor_locs = self.get_minorticklocs()
        minor_labels = self.minor.formatter.format_ticks(minor_locs)
        minor_ticks = self.get_minor_ticks(len(minor_locs))
        for (tick, loc, label) in zip(minor_ticks, minor_locs, minor_labels):
            tick.update_position(loc)
            tick.label1.set_text(label)
            tick.label2.set_text(label)
        ticks = [*major_ticks, *minor_ticks]
        (view_low, view_high) = self.get_view_interval()
        if view_low > view_high:
            (view_low, view_high) = (view_high, view_low)
        if hasattr(self, 'axes') and self.axes.name == '3d' and mpl.rcParams['axes3d.automargin']:
            margin = 0.019965277777777776
            delta = view_high - view_low
            view_high = view_high - delta * margin
            view_low = view_low + delta * margin
        interval_t = self.get_transform().transform([view_low, view_high])
        ticks_to_draw = []
        for tick in ticks:
            try:
                loc_t = self.get_transform().transform(tick.get_loc())
            except AssertionError:
                pass
            else:
                if mtransforms._interval_contains_close(interval_t, loc_t):
                    ticks_to_draw.append(tick)
        return ticks_to_draw

    def _get_ticklabel_bboxes(self, ticks, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        return ([tick.label1.get_window_extent(renderer) for tick in ticks if tick.label1.get_visible()], [tick.label2.get_window_extent(renderer) for tick in ticks if tick.label2.get_visible()])

    def get_tightbbox(self, renderer=None, *, for_layout_only=False):
        if not self.get_visible() or (for_layout_only and (not self.get_in_layout())):
            return
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        ticks_to_draw = self._update_ticks()
        self._update_label_position(renderer)
        (tlb1, tlb2) = self._get_ticklabel_bboxes(ticks_to_draw, renderer)
        self._update_offset_text_position(tlb1, tlb2)
        self.offsetText.set_text(self.major.formatter.get_offset())
        bboxes = [*(a.get_window_extent(renderer) for a in [self.offsetText] if a.get_visible()), *tlb1, *tlb2]
        if self.label.get_visible():
            bb = self.label.get_window_extent(renderer)
            if for_layout_only:
                if self.axis_name == 'x' and bb.width > 0:
                    bb.x0 = (bb.x0 + bb.x1) / 2 - 0.5
                    bb.x1 = bb.x0 + 1.0
                if self.axis_name == 'y' and bb.height > 0:
                    bb.y0 = (bb.y0 + bb.y1) / 2 - 0.5
                    bb.y1 = bb.y0 + 1.0
            bboxes.append(bb)
        bboxes = [b for b in bboxes if 0 < b.width < np.inf and 0 < b.height < np.inf]
        if bboxes:
            return mtransforms.Bbox.union(bboxes)
        else:
            return None

    def get_tick_padding(self):
        values = []
        if len(self.majorTicks):
            values.append(self.majorTicks[0].get_tick_padding())
        if len(self.minorTicks):
            values.append(self.minorTicks[0].get_tick_padding())
        return max(values, default=0)

    @martist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group(__name__, gid=self.get_gid())
        ticks_to_draw = self._update_ticks()
        (tlb1, tlb2) = self._get_ticklabel_bboxes(ticks_to_draw, renderer)
        for tick in ticks_to_draw:
            tick.draw(renderer)
        self._update_label_position(renderer)
        self.label.draw(renderer)
        self._update_offset_text_position(tlb1, tlb2)
        self.offsetText.set_text(self.major.formatter.get_offset())
        self.offsetText.draw(renderer)
        renderer.close_group(__name__)
        self.stale = False

    def get_gridlines(self):
        ticks = self.get_major_ticks()
        return cbook.silent_list('Line2D gridline', [tick.gridline for tick in ticks])

    def get_label(self):
        return self.label

    def get_offset_text(self):
        return self.offsetText

    def get_pickradius(self):
        return self._pickradius

    def get_majorticklabels(self):
        self._update_ticks()
        ticks = self.get_major_ticks()
        labels1 = [tick.label1 for tick in ticks if tick.label1.get_visible()]
        labels2 = [tick.label2 for tick in ticks if tick.label2.get_visible()]
        return labels1 + labels2

    def get_minorticklabels(self):
        self._update_ticks()
        ticks = self.get_minor_ticks()
        labels1 = [tick.label1 for tick in ticks if tick.label1.get_visible()]
        labels2 = [tick.label2 for tick in ticks if tick.label2.get_visible()]
        return labels1 + labels2

    def get_ticklabels(self, minor=False, which=None):
        if which is not None:
            if which == 'minor':
                return self.get_minorticklabels()
            elif which == 'major':
                return self.get_majorticklabels()
            elif which == 'both':
                return self.get_majorticklabels() + self.get_minorticklabels()
            else:
                _api.check_in_list(['major', 'minor', 'both'], which=which)
        if minor:
            return self.get_minorticklabels()
        return self.get_majorticklabels()

    def get_majorticklines(self):
        lines = []
        ticks = self.get_major_ticks()
        for tick in ticks:
            lines.append(tick.tick1line)
            lines.append(tick.tick2line)
        return cbook.silent_list('Line2D ticklines', lines)

    def get_minorticklines(self):
        lines = []
        ticks = self.get_minor_ticks()
        for tick in ticks:
            lines.append(tick.tick1line)
            lines.append(tick.tick2line)
        return cbook.silent_list('Line2D ticklines', lines)

    def get_ticklines(self, minor=False):
        if minor:
            return self.get_minorticklines()
        return self.get_majorticklines()

    def get_majorticklocs(self):
        return self.major.locator()

    def get_minorticklocs(self):
        minor_locs = np.asarray(self.minor.locator())
        if self.remove_overlapping_locs:
            major_locs = self.major.locator()
            transform = self._scale.get_transform()
            tr_minor_locs = transform.transform(minor_locs)
            tr_major_locs = transform.transform(major_locs)
            (lo, hi) = sorted(transform.transform(self.get_view_interval()))
            tol = (hi - lo) * 1e-05
            mask = np.isclose(tr_minor_locs[:, None], tr_major_locs[None, :], atol=tol, rtol=0).any(axis=1)
            minor_locs = minor_locs[~mask]
        return minor_locs

    def get_ticklocs(self, *, minor=False):
        return self.get_minorticklocs() if minor else self.get_majorticklocs()

    def get_ticks_direction(self, minor=False):
        if minor:
            return np.array([tick._tickdir for tick in self.get_minor_ticks()])
        else:
            return np.array([tick._tickdir for tick in self.get_major_ticks()])

    def _get_tick(self, major):
        if self._tick_class is None:
            raise NotImplementedError(f'The Axis subclass {self.__class__.__name__} must define _tick_class or reimplement _get_tick()')
        tick_kw = self._major_tick_kw if major else self._minor_tick_kw
        return self._tick_class(self.axes, 0, major=major, **tick_kw)

    def _get_tick_label_size(self, axis_name):
        tick_kw = self._major_tick_kw
        size = tick_kw.get('labelsize', mpl.rcParams[f'{axis_name}tick.labelsize'])
        return mtext.FontProperties(size=size).get_size_in_points()

    def _copy_tick_props(self, src, dest):
        if src is None or dest is None:
            return
        dest.label1.update_from(src.label1)
        dest.label2.update_from(src.label2)
        dest.tick1line.update_from(src.tick1line)
        dest.tick2line.update_from(src.tick2line)
        dest.gridline.update_from(src.gridline)
        dest.update_from(src)
        dest._loc = src._loc
        dest._size = src._size
        dest._width = src._width
        dest._base_pad = src._base_pad
        dest._labelrotation = src._labelrotation
        dest._zorder = src._zorder
        dest._tickdir = src._tickdir

    def get_label_text(self):
        return self.label.get_text()

    def get_major_locator(self):
        return self.major.locator

    def get_minor_locator(self):
        return self.minor.locator

    def get_major_formatter(self):
        return self.major.formatter

    def get_minor_formatter(self):
        return self.minor.formatter

    def get_major_ticks(self, numticks=None):
        if numticks is None:
            numticks = len(self.get_majorticklocs())
        while len(self.majorTicks) < numticks:
            tick = self._get_tick(major=True)
            self.majorTicks.append(tick)
            self._copy_tick_props(self.majorTicks[0], tick)
        return self.majorTicks[:numticks]

    def get_minor_ticks(self, numticks=None):
        if numticks is None:
            numticks = len(self.get_minorticklocs())
        while len(self.minorTicks) < numticks:
            tick = self._get_tick(major=False)
            self.minorTicks.append(tick)
            self._copy_tick_props(self.minorTicks[0], tick)
        return self.minorTicks[:numticks]

    def grid(self, visible=None, which='major', **kwargs):
        if kwargs:
            if visible is None:
                visible = True
            elif not visible:
                _api.warn_external('First parameter to grid() is false, but line properties are supplied. The grid will be enabled.')
                visible = True
        which = which.lower()
        _api.check_in_list(['major', 'minor', 'both'], which=which)
        gridkw = {f'grid_{name}': value for (name, value) in kwargs.items()}
        if which in ['minor', 'both']:
            gridkw['gridOn'] = not self._minor_tick_kw['gridOn'] if visible is None else visible
            self.set_tick_params(which='minor', **gridkw)
        if which in ['major', 'both']:
            gridkw['gridOn'] = not self._major_tick_kw['gridOn'] if visible is None else visible
            self.set_tick_params(which='major', **gridkw)
        self.stale = True

    def update_units(self, data):
        converter = munits.registry.get_converter(data)
        if converter is None:
            return False
        neednew = self.converter != converter
        self.converter = converter
        default = self.converter.default_units(data, self)
        if default is not None and self.units is None:
            self.set_units(default)
        elif neednew:
            self._update_axisinfo()
        self.stale = True
        return True

    def _update_axisinfo(self):
        if self.converter is None:
            return
        info = self.converter.axisinfo(self.units, self)
        if info is None:
            return
        if info.majloc is not None and self.major.locator != info.majloc and self.isDefault_majloc:
            self.set_major_locator(info.majloc)
            self.isDefault_majloc = True
        if info.minloc is not None and self.minor.locator != info.minloc and self.isDefault_minloc:
            self.set_minor_locator(info.minloc)
            self.isDefault_minloc = True
        if info.majfmt is not None and self.major.formatter != info.majfmt and self.isDefault_majfmt:
            self.set_major_formatter(info.majfmt)
            self.isDefault_majfmt = True
        if info.minfmt is not None and self.minor.formatter != info.minfmt and self.isDefault_minfmt:
            self.set_minor_formatter(info.minfmt)
            self.isDefault_minfmt = True
        if info.label is not None and self.isDefault_label:
            self.set_label_text(info.label)
            self.isDefault_label = True
        self.set_default_intervals()

    def have_units(self):
        return self.converter is not None or self.units is not None

    def convert_units(self, x):
        if munits._is_natively_supported(x):
            return x
        if self.converter is None:
            self.converter = munits.registry.get_converter(x)
        if self.converter is None:
            return x
        try:
            ret = self.converter.convert(x, self.units, self)
        except Exception as e:
            raise munits.ConversionError(f'Failed to convert value(s) to axis units: {x!r}') from e
        return ret

    def set_units(self, u):
        if u == self.units:
            return
        for axis in self._get_shared_axis():
            axis.units = u
            axis._update_axisinfo()
            axis.callbacks.process('units')
            axis.stale = True

    def get_units(self):
        return self.units

    def set_label_text(self, label, fontdict=None, **kwargs):
        self.isDefault_label = False
        self.label.set_text(label)
        if fontdict is not None:
            self.label.update(fontdict)
        self.label.update(kwargs)
        self.stale = True
        return self.label

    def set_major_formatter(self, formatter):
        self._set_formatter(formatter, self.major)

    def set_minor_formatter(self, formatter):
        self._set_formatter(formatter, self.minor)

    def _set_formatter(self, formatter, level):
        if isinstance(formatter, str):
            formatter = mticker.StrMethodFormatter(formatter)
        elif callable(formatter) and (not isinstance(formatter, mticker.TickHelper)):
            formatter = mticker.FuncFormatter(formatter)
        else:
            _api.check_isinstance(mticker.Formatter, formatter=formatter)
        if isinstance(formatter, mticker.FixedFormatter) and len(formatter.seq) > 0 and (not isinstance(level.locator, mticker.FixedLocator)):
            _api.warn_external('FixedFormatter should only be used together with FixedLocator')
        if level == self.major:
            self.isDefault_majfmt = False
        else:
            self.isDefault_minfmt = False
        level.formatter = formatter
        formatter.set_axis(self)
        self.stale = True

    def set_major_locator(self, locator):
        _api.check_isinstance(mticker.Locator, locator=locator)
        self.isDefault_majloc = False
        self.major.locator = locator
        if self.major.formatter:
            self.major.formatter._set_locator(locator)
        locator.set_axis(self)
        self.stale = True

    def set_minor_locator(self, locator):
        _api.check_isinstance(mticker.Locator, locator=locator)
        self.isDefault_minloc = False
        self.minor.locator = locator
        if self.minor.formatter:
            self.minor.formatter._set_locator(locator)
        locator.set_axis(self)
        self.stale = True

    def set_pickradius(self, pickradius):
        if not isinstance(pickradius, Real) or pickradius < 0:
            raise ValueError('pick radius should be a distance')
        self._pickradius = pickradius
    pickradius = property(get_pickradius, set_pickradius, doc='The acceptance radius for containment tests. See also `.Axis.contains`.')

    @staticmethod
    def _format_with_dict(tickd, x, pos):
        return tickd.get(x, '')

    def set_ticklabels(self, labels, *, minor=False, fontdict=None, **kwargs):
        try:
            labels = [t.get_text() if hasattr(t, 'get_text') else t for t in labels]
        except TypeError:
            raise TypeError(f'{labels:=} must be a sequence') from None
        locator = self.get_minor_locator() if minor else self.get_major_locator()
        if not labels:
            formatter = mticker.NullFormatter()
        elif isinstance(locator, mticker.FixedLocator):
            if len(locator.locs) != len(labels) and len(labels) != 0:
                raise ValueError(f'The number of FixedLocator locations ({len(locator.locs)}), usually from a call to set_ticks, does not match the number of labels ({len(labels)}).')
            tickd = {loc: lab for (loc, lab) in zip(locator.locs, labels)}
            func = functools.partial(self._format_with_dict, tickd)
            formatter = mticker.FuncFormatter(func)
        else:
            _api.warn_external('set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.')
            formatter = mticker.FixedFormatter(labels)
        with warnings.catch_warnings():
            warnings.filterwarnings('ignore', message='FixedFormatter should only be used together with FixedLocator')
            if minor:
                self.set_minor_formatter(formatter)
                locs = self.get_minorticklocs()
                ticks = self.get_minor_ticks(len(locs))
            else:
                self.set_major_formatter(formatter)
                locs = self.get_majorticklocs()
                ticks = self.get_major_ticks(len(locs))
        ret = []
        if fontdict is not None:
            kwargs.update(fontdict)
        for (pos, (loc, tick)) in enumerate(zip(locs, ticks)):
            tick.update_position(loc)
            tick_label = formatter(loc, pos)
            tick.label1.set_text(tick_label)
            tick.label1._internal_update(kwargs)
            tick.label2.set_text(tick_label)
            tick.label2._internal_update(kwargs)
            if tick.label1.get_visible():
                ret.append(tick.label1)
            if tick.label2.get_visible():
                ret.append(tick.label2)
        self.stale = True
        return ret

    def _set_tick_locations(self, ticks, *, minor=False):
        ticks = self.convert_units(ticks)
        locator = mticker.FixedLocator(ticks)
        if len(ticks):
            for axis in self._get_shared_axis():
                axis.set_view_interval(min(ticks), max(ticks))
        self.axes.stale = True
        if minor:
            self.set_minor_locator(locator)
            return self.get_minor_ticks(len(ticks))
        else:
            self.set_major_locator(locator)
            return self.get_major_ticks(len(ticks))

    def set_ticks(self, ticks, labels=None, *, minor=False, **kwargs):
        if labels is None and kwargs:
            first_key = next(iter(kwargs))
            raise ValueError(f"Incorrect use of keyword argument {first_key!r}. Keyword arguments other than 'minor' modify the text labels and can only be used if 'labels' are passed as well.")
        result = self._set_tick_locations(ticks, minor=minor)
        if labels is not None:
            self.set_ticklabels(labels, minor=minor, **kwargs)
        return result

    def _get_tick_boxes_siblings(self, renderer):
        name = self._get_axis_name()
        if name not in self.get_figure(root=False)._align_label_groups:
            return ([], [])
        grouper = self.get_figure(root=False)._align_label_groups[name]
        bboxes = []
        bboxes2 = []
        for ax in grouper.get_siblings(self.axes):
            axis = ax._axis_map[name]
            ticks_to_draw = axis._update_ticks()
            (tlb, tlb2) = axis._get_ticklabel_bboxes(ticks_to_draw, renderer)
            bboxes.extend(tlb)
            bboxes2.extend(tlb2)
        return (bboxes, bboxes2)

    def _update_label_position(self, renderer):
        raise NotImplementedError('Derived must override')

    def _update_offset_text_position(self, bboxes, bboxes2):
        raise NotImplementedError('Derived must override')

    def axis_date(self, tz=None):
        if isinstance(tz, str):
            import dateutil.tz
            tz = dateutil.tz.gettz(tz)
        self.update_units(datetime.datetime(2009, 1, 1, 0, 0, 0, 0, tz))

    def get_tick_space(self):
        raise NotImplementedError()

    def _get_ticks_position(self):
        major = self.majorTicks[0]
        minor = self.minorTicks[0]
        if all((tick.tick1line.get_visible() and (not tick.tick2line.get_visible()) and tick.label1.get_visible() and (not tick.label2.get_visible()) for tick in [major, minor])):
            return 1
        elif all((tick.tick2line.get_visible() and (not tick.tick1line.get_visible()) and tick.label2.get_visible() and (not tick.label1.get_visible()) for tick in [major, minor])):
            return 2
        elif all((tick.tick1line.get_visible() and tick.tick2line.get_visible() and tick.label1.get_visible() and (not tick.label2.get_visible()) for tick in [major, minor])):
            return 'default'
        else:
            return 'unknown'

    def get_label_position(self):
        return self.label_position

    def set_label_position(self, position):
        raise NotImplementedError()

    def get_minpos(self):
        raise NotImplementedError()

def _make_getset_interval(method_name, lim_name, attr_name):

    def getter(self):
        return getattr(getattr(self.axes, lim_name), attr_name)

    def setter(self, vmin, vmax, ignore=False):
        if ignore:
            setattr(getattr(self.axes, lim_name), attr_name, (vmin, vmax))
        else:
            (oldmin, oldmax) = getter(self)
            if oldmin < oldmax:
                setter(self, min(vmin, vmax, oldmin), max(vmin, vmax, oldmax), ignore=True)
            else:
                setter(self, max(vmin, vmax, oldmin), min(vmin, vmax, oldmax), ignore=True)
        self.stale = True
    getter.__name__ = f'get_{method_name}_interval'
    setter.__name__ = f'set_{method_name}_interval'
    return (getter, setter)

class XAxis(Axis):
    __name__ = 'xaxis'
    axis_name = 'x'
    _tick_class = XTick

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._init()

    def _init(self):
        self.label.set(x=0.5, y=0, verticalalignment='top', horizontalalignment='center', transform=mtransforms.blended_transform_factory(self.axes.transAxes, mtransforms.IdentityTransform()))
        self.label_position = 'bottom'
        if mpl.rcParams['xtick.labelcolor'] == 'inherit':
            tick_color = mpl.rcParams['xtick.color']
        else:
            tick_color = mpl.rcParams['xtick.labelcolor']
        self.offsetText.set(x=1, y=0, verticalalignment='top', horizontalalignment='right', transform=mtransforms.blended_transform_factory(self.axes.transAxes, mtransforms.IdentityTransform()), fontsize=mpl.rcParams['xtick.labelsize'], color=tick_color)
        self.offset_text_position = 'bottom'

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        (x, y) = (mouseevent.x, mouseevent.y)
        try:
            trans = self.axes.transAxes.inverted()
            (xaxes, yaxes) = trans.transform((x, y))
        except ValueError:
            return (False, {})
        ((l, b), (r, t)) = self.axes.transAxes.transform([(0, 0), (1, 1)])
        inaxis = 0 <= xaxes <= 1 and (b - self._pickradius < y < b or t < y < t + self._pickradius)
        return (inaxis, {})

    def set_label_position(self, position):
        self.label.set_verticalalignment(_api.check_getitem({'top': 'baseline', 'bottom': 'top'}, position=position))
        self.label_position = position
        self.stale = True

    def _update_label_position(self, renderer):
        if not self._autolabelpos:
            return
        (bboxes, bboxes2) = self._get_tick_boxes_siblings(renderer=renderer)
        (x, y) = self.label.get_position()
        if self.label_position == 'bottom':
            bbox = mtransforms.Bbox.union([*bboxes, self.axes.spines.get('bottom', self.axes).get_window_extent()])
            self.label.set_position((x, bbox.y0 - self.labelpad * self.get_figure(root=True).dpi / 72))
        else:
            bbox = mtransforms.Bbox.union([*bboxes2, self.axes.spines.get('top', self.axes).get_window_extent()])
            self.label.set_position((x, bbox.y1 + self.labelpad * self.get_figure(root=True).dpi / 72))

    def _update_offset_text_position(self, bboxes, bboxes2):
        (x, y) = self.offsetText.get_position()
        if not hasattr(self, '_tick_position'):
            self._tick_position = 'bottom'
        if self._tick_position == 'bottom':
            if not len(bboxes):
                bottom = self.axes.bbox.ymin
            else:
                bbox = mtransforms.Bbox.union(bboxes)
                bottom = bbox.y0
            y = bottom - self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72
        else:
            if not len(bboxes2):
                top = self.axes.bbox.ymax
            else:
                bbox = mtransforms.Bbox.union(bboxes2)
                top = bbox.y1
            y = top + self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72
        self.offsetText.set_position((x, y))

    def set_ticks_position(self, position):
        if position == 'top':
            self.set_tick_params(which='both', top=True, labeltop=True, bottom=False, labelbottom=False)
            self._tick_position = 'top'
            self.offsetText.set_verticalalignment('bottom')
        elif position == 'bottom':
            self.set_tick_params(which='both', top=False, labeltop=False, bottom=True, labelbottom=True)
            self._tick_position = 'bottom'
            self.offsetText.set_verticalalignment('top')
        elif position == 'both':
            self.set_tick_params(which='both', top=True, bottom=True)
        elif position == 'none':
            self.set_tick_params(which='both', top=False, bottom=False)
        elif position == 'default':
            self.set_tick_params(which='both', top=True, labeltop=False, bottom=True, labelbottom=True)
            self._tick_position = 'bottom'
            self.offsetText.set_verticalalignment('top')
        else:
            _api.check_in_list(['top', 'bottom', 'both', 'default', 'none'], position=position)
        self.stale = True

    def tick_top(self):
        label = True
        if 'label1On' in self._major_tick_kw:
            label = self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']
        self.set_ticks_position('top')
        self.set_tick_params(which='both', labeltop=label)

    def tick_bottom(self):
        label = True
        if 'label1On' in self._major_tick_kw:
            label = self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']
        self.set_ticks_position('bottom')
        self.set_tick_params(which='both', labelbottom=label)

    def get_ticks_position(self):
        return {1: 'bottom', 2: 'top', 'default': 'default', 'unknown': 'unknown'}[self._get_ticks_position()]
    (get_view_interval, set_view_interval) = _make_getset_interval('view', 'viewLim', 'intervalx')
    (get_data_interval, set_data_interval) = _make_getset_interval('data', 'dataLim', 'intervalx')

    def get_minpos(self):
        return self.axes.dataLim.minposx

    def set_default_intervals(self):
        if not self.axes.dataLim.mutatedx() and (not self.axes.viewLim.mutatedx()):
            if self.converter is not None:
                info = self.converter.axisinfo(self.units, self)
                if info.default_limits is not None:
                    (xmin, xmax) = self.convert_units(info.default_limits)
                    self.axes.viewLim.intervalx = (xmin, xmax)
        self.stale = True

    def get_tick_space(self):
        ends = mtransforms.Bbox.unit().transformed(self.axes.transAxes - self.get_figure(root=False).dpi_scale_trans)
        length = ends.width * 72
        size = self._get_tick_label_size('x') * 3
        if size > 0:
            return int(np.floor(length / size))
        else:
            return 2 ** 31 - 1

class YAxis(Axis):
    __name__ = 'yaxis'
    axis_name = 'y'
    _tick_class = YTick

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._init()

    def _init(self):
        self.label.set(x=0, y=0.5, verticalalignment='bottom', horizontalalignment='center', rotation='vertical', rotation_mode='anchor', transform=mtransforms.blended_transform_factory(mtransforms.IdentityTransform(), self.axes.transAxes))
        self.label_position = 'left'
        if mpl.rcParams['ytick.labelcolor'] == 'inherit':
            tick_color = mpl.rcParams['ytick.color']
        else:
            tick_color = mpl.rcParams['ytick.labelcolor']
        self.offsetText.set(x=0, y=0.5, verticalalignment='baseline', horizontalalignment='left', transform=mtransforms.blended_transform_factory(self.axes.transAxes, mtransforms.IdentityTransform()), fontsize=mpl.rcParams['ytick.labelsize'], color=tick_color)
        self.offset_text_position = 'left'

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        (x, y) = (mouseevent.x, mouseevent.y)
        try:
            trans = self.axes.transAxes.inverted()
            (xaxes, yaxes) = trans.transform((x, y))
        except ValueError:
            return (False, {})
        ((l, b), (r, t)) = self.axes.transAxes.transform([(0, 0), (1, 1)])
        inaxis = 0 <= yaxes <= 1 and (l - self._pickradius < x < l or r < x < r + self._pickradius)
        return (inaxis, {})

    def set_label_position(self, position):
        self.label.set_rotation_mode('anchor')
        self.label.set_verticalalignment(_api.check_getitem({'left': 'bottom', 'right': 'top'}, position=position))
        self.label_position = position
        self.stale = True

    def _update_label_position(self, renderer):
        if not self._autolabelpos:
            return
        (bboxes, bboxes2) = self._get_tick_boxes_siblings(renderer=renderer)
        (x, y) = self.label.get_position()
        if self.label_position == 'left':
            bbox = mtransforms.Bbox.union([*bboxes, self.axes.spines.get('left', self.axes).get_window_extent()])
            self.label.set_position((bbox.x0 - self.labelpad * self.get_figure(root=True).dpi / 72, y))
        else:
            bbox = mtransforms.Bbox.union([*bboxes2, self.axes.spines.get('right', self.axes).get_window_extent()])
            self.label.set_position((bbox.x1 + self.labelpad * self.get_figure(root=True).dpi / 72, y))

    def _update_offset_text_position(self, bboxes, bboxes2):
        (x, _) = self.offsetText.get_position()
        if 'outline' in self.axes.spines:
            bbox = self.axes.spines['outline'].get_window_extent()
        else:
            bbox = self.axes.bbox
        top = bbox.ymax
        self.offsetText.set_position((x, top + self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72))

    def set_offset_position(self, position):
        (x, y) = self.offsetText.get_position()
        x = _api.check_getitem({'left': 0, 'right': 1}, position=position)
        self.offsetText.set_ha(position)
        self.offsetText.set_position((x, y))
        self.stale = True

    def set_ticks_position(self, position):
        if position == 'right':
            self.set_tick_params(which='both', right=True, labelright=True, left=False, labelleft=False)
            self.set_offset_position(position)
        elif position == 'left':
            self.set_tick_params(which='both', right=False, labelright=False, left=True, labelleft=True)
            self.set_offset_position(position)
        elif position == 'both':
            self.set_tick_params(which='both', right=True, left=True)
        elif position == 'none':
            self.set_tick_params(which='both', right=False, left=False)
        elif position == 'default':
            self.set_tick_params(which='both', right=True, labelright=False, left=True, labelleft=True)
        else:
            _api.check_in_list(['left', 'right', 'both', 'default', 'none'], position=position)
        self.stale = True

    def tick_right(self):
        label = True
        if 'label1On' in self._major_tick_kw:
            label = self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']
        self.set_ticks_position('right')
        self.set_tick_params(which='both', labelright=label)

    def tick_left(self):
        label = True
        if 'label1On' in self._major_tick_kw:
            label = self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']
        self.set_ticks_position('left')
        self.set_tick_params(which='both', labelleft=label)

    def get_ticks_position(self):
        return {1: 'left', 2: 'right', 'default': 'default', 'unknown': 'unknown'}[self._get_ticks_position()]
    (get_view_interval, set_view_interval) = _make_getset_interval('view', 'viewLim', 'intervaly')
    (get_data_interval, set_data_interval) = _make_getset_interval('data', 'dataLim', 'intervaly')

    def get_minpos(self):
        return self.axes.dataLim.minposy

    def set_default_intervals(self):
        if not self.axes.dataLim.mutatedy() and (not self.axes.viewLim.mutatedy()):
            if self.converter is not None:
                info = self.converter.axisinfo(self.units, self)
                if info.default_limits is not None:
                    (ymin, ymax) = self.convert_units(info.default_limits)
                    self.axes.viewLim.intervaly = (ymin, ymax)
        self.stale = True

    def get_tick_space(self):
        ends = mtransforms.Bbox.unit().transformed(self.axes.transAxes - self.get_figure(root=False).dpi_scale_trans)
        length = ends.height * 72
        size = self._get_tick_label_size('y') * 2
        if size > 0:
            return int(np.floor(length / size))
        else:
            return 2 ** 31 - 1

# File: matplotlib-main/lib/matplotlib/backend_bases.py
""""""
from collections import namedtuple
from contextlib import ExitStack, contextmanager, nullcontext
from enum import Enum, IntEnum
import functools
import importlib
import inspect
import io
import itertools
import logging
import os
import pathlib
import signal
import socket
import sys
import time
import weakref
from weakref import WeakKeyDictionary
import numpy as np
import matplotlib as mpl
from matplotlib import _api, backend_tools as tools, cbook, colors, _docstring, text, _tight_bbox, transforms, widgets, is_interactive, rcParams
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_managers import ToolManager
from matplotlib.cbook import _setattr_cm
from matplotlib.layout_engine import ConstrainedLayoutEngine
from matplotlib.path import Path
from matplotlib.texmanager import TexManager
from matplotlib.transforms import Affine2D
from matplotlib._enums import JoinStyle, CapStyle
_log = logging.getLogger(__name__)
_default_filetypes = {'eps': 'Encapsulated Postscript', 'jpg': 'Joint Photographic Experts Group', 'jpeg': 'Joint Photographic Experts Group', 'pdf': 'Portable Document Format', 'pgf': 'PGF code for LaTeX', 'png': 'Portable Network Graphics', 'ps': 'Postscript', 'raw': 'Raw RGBA bitmap', 'rgba': 'Raw RGBA bitmap', 'svg': 'Scalable Vector Graphics', 'svgz': 'Scalable Vector Graphics', 'tif': 'Tagged Image File Format', 'tiff': 'Tagged Image File Format', 'webp': 'WebP Image Format'}
_default_backends = {'eps': 'matplotlib.backends.backend_ps', 'jpg': 'matplotlib.backends.backend_agg', 'jpeg': 'matplotlib.backends.backend_agg', 'pdf': 'matplotlib.backends.backend_pdf', 'pgf': 'matplotlib.backends.backend_pgf', 'png': 'matplotlib.backends.backend_agg', 'ps': 'matplotlib.backends.backend_ps', 'raw': 'matplotlib.backends.backend_agg', 'rgba': 'matplotlib.backends.backend_agg', 'svg': 'matplotlib.backends.backend_svg', 'svgz': 'matplotlib.backends.backend_svg', 'tif': 'matplotlib.backends.backend_agg', 'tiff': 'matplotlib.backends.backend_agg', 'webp': 'matplotlib.backends.backend_agg'}

def register_backend(format, backend, description=None):
    if description is None:
        description = ''
    _default_backends[format] = backend
    _default_filetypes[format] = description

def get_registered_canvas_class(format):
    if format not in _default_backends:
        return None
    backend_class = _default_backends[format]
    if isinstance(backend_class, str):
        backend_class = importlib.import_module(backend_class).FigureCanvas
        _default_backends[format] = backend_class
    return backend_class

class RendererBase:

    def __init__(self):
        super().__init__()
        self._texmanager = None
        self._text2path = text.TextToPath()
        self._raster_depth = 0
        self._rasterizing = False

    def open_group(self, s, gid=None):

    def close_group(self, s):

    def draw_path(self, gc, path, transform, rgbFace=None):
        raise NotImplementedError

    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
        for (vertices, codes) in path.iter_segments(trans, simplify=False):
            if len(vertices):
                (x, y) = vertices[-2:]
                self.draw_path(gc, marker_path, marker_trans + transforms.Affine2D().translate(x, y), rgbFace)

    def draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
        path_ids = self._iter_collection_raw_paths(master_transform, paths, all_transforms)
        for (xo, yo, path_id, gc0, rgbFace) in self._iter_collection(gc, list(path_ids), offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
            (path, transform) = path_id
            if xo != 0 or yo != 0:
                transform = transform.frozen()
                transform.translate(xo, yo)
            self.draw_path(gc0, path, transform, rgbFace)

    def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight, coordinates, offsets, offsetTrans, facecolors, antialiased, edgecolors):
        from matplotlib.collections import QuadMesh
        paths = QuadMesh._convert_mesh_to_paths(coordinates)
        if edgecolors is None:
            edgecolors = facecolors
        linewidths = np.array([gc.get_linewidth()], float)
        return self.draw_path_collection(gc, master_transform, paths, [], offsets, offsetTrans, facecolors, edgecolors, linewidths, [], [antialiased], [None], 'screen')

    def draw_gouraud_triangles(self, gc, triangles_array, colors_array, transform):
        raise NotImplementedError

    def _iter_collection_raw_paths(self, master_transform, paths, all_transforms):
        Npaths = len(paths)
        Ntransforms = len(all_transforms)
        N = max(Npaths, Ntransforms)
        if Npaths == 0:
            return
        transform = transforms.IdentityTransform()
        for i in range(N):
            path = paths[i % Npaths]
            if Ntransforms:
                transform = Affine2D(all_transforms[i % Ntransforms])
            yield (path, transform + master_transform)

    def _iter_collection_uses_per_path(self, paths, all_transforms, offsets, facecolors, edgecolors):
        Npaths = len(paths)
        if Npaths == 0 or len(facecolors) == len(edgecolors) == 0:
            return 0
        Npath_ids = max(Npaths, len(all_transforms))
        N = max(Npath_ids, len(offsets))
        return (N + Npath_ids - 1) // Npath_ids

    def _iter_collection(self, gc, path_ids, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
        Npaths = len(path_ids)
        Noffsets = len(offsets)
        N = max(Npaths, Noffsets)
        Nfacecolors = len(facecolors)
        Nedgecolors = len(edgecolors)
        Nlinewidths = len(linewidths)
        Nlinestyles = len(linestyles)
        Nurls = len(urls)
        if Nfacecolors == 0 and Nedgecolors == 0 or Npaths == 0:
            return
        gc0 = self.new_gc()
        gc0.copy_properties(gc)

        def cycle_or_default(seq, default=None):
            return itertools.cycle(seq) if len(seq) else itertools.repeat(default)
        pathids = cycle_or_default(path_ids)
        toffsets = cycle_or_default(offset_trans.transform(offsets), (0, 0))
        fcs = cycle_or_default(facecolors)
        ecs = cycle_or_default(edgecolors)
        lws = cycle_or_default(linewidths)
        lss = cycle_or_default(linestyles)
        aas = cycle_or_default(antialiaseds)
        urls = cycle_or_default(urls)
        if Nedgecolors == 0:
            gc0.set_linewidth(0.0)
        for (pathid, (xo, yo), fc, ec, lw, ls, aa, url) in itertools.islice(zip(pathids, toffsets, fcs, ecs, lws, lss, aas, urls), N):
            if not (np.isfinite(xo) and np.isfinite(yo)):
                continue
            if Nedgecolors:
                if Nlinewidths:
                    gc0.set_linewidth(lw)
                if Nlinestyles:
                    gc0.set_dashes(*ls)
                if len(ec) == 4 and ec[3] == 0.0:
                    gc0.set_linewidth(0)
                else:
                    gc0.set_foreground(ec)
            if fc is not None and len(fc) == 4 and (fc[3] == 0):
                fc = None
            gc0.set_antialiased(aa)
            if Nurls:
                gc0.set_url(url)
            yield (xo, yo, pathid, gc0, fc)
        gc0.restore()

    def get_image_magnification(self):
        return 1.0

    def draw_image(self, gc, x, y, im, transform=None):
        raise NotImplementedError

    def option_image_nocomposite(self):
        return False

    def option_scale_image(self):
        return False

    def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
        self._draw_text_as_path(gc, x, y, s, prop, angle, ismath='TeX')

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        self._draw_text_as_path(gc, x, y, s, prop, angle, ismath)

    def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath):
        text2path = self._text2path
        fontsize = self.points_to_pixels(prop.get_size_in_points())
        (verts, codes) = text2path.get_text_path(prop, s, ismath=ismath)
        path = Path(verts, codes)
        if self.flipy():
            (width, height) = self.get_canvas_width_height()
            transform = Affine2D().scale(fontsize / text2path.FONT_SCALE).rotate_deg(angle).translate(x, height - y)
        else:
            transform = Affine2D().scale(fontsize / text2path.FONT_SCALE).rotate_deg(angle).translate(x, y)
        color = gc.get_rgb()
        gc.set_linewidth(0.0)
        self.draw_path(gc, path, transform, rgbFace=color)

    def get_text_width_height_descent(self, s, prop, ismath):
        fontsize = prop.get_size_in_points()
        if ismath == 'TeX':
            return self.get_texmanager().get_text_width_height_descent(s, fontsize, renderer=self)
        dpi = self.points_to_pixels(72)
        if ismath:
            dims = self._text2path.mathtext_parser.parse(s, dpi, prop)
            return dims[0:3]
        flags = self._text2path._get_hinting_flag()
        font = self._text2path._get_font(prop)
        font.set_size(fontsize, dpi)
        font.set_text(s, 0.0, flags=flags)
        (w, h) = font.get_width_height()
        d = font.get_descent()
        w /= 64.0
        h /= 64.0
        d /= 64.0
        return (w, h, d)

    def flipy(self):
        return True

    def get_canvas_width_height(self):
        return (1, 1)

    def get_texmanager(self):
        if self._texmanager is None:
            self._texmanager = TexManager()
        return self._texmanager

    def new_gc(self):
        return GraphicsContextBase()

    def points_to_pixels(self, points):
        return points

    def start_rasterizing(self):

    def stop_rasterizing(self):

    def start_filter(self):

    def stop_filter(self, filter_func):

    def _draw_disabled(self):
        no_ops = {meth_name: lambda *args, **kwargs: None for meth_name in dir(RendererBase) if meth_name.startswith('draw_') or meth_name in ['open_group', 'close_group']}
        return _setattr_cm(self, **no_ops)

class GraphicsContextBase:

    def __init__(self):
        self._alpha = 1.0
        self._forced_alpha = False
        self._antialiased = 1
        self._capstyle = CapStyle('butt')
        self._cliprect = None
        self._clippath = None
        self._dashes = (0, None)
        self._joinstyle = JoinStyle('round')
        self._linestyle = 'solid'
        self._linewidth = 1
        self._rgb = (0.0, 0.0, 0.0, 1.0)
        self._hatch = None
        self._hatch_color = colors.to_rgba(rcParams['hatch.color'])
        self._hatch_linewidth = rcParams['hatch.linewidth']
        self._url = None
        self._gid = None
        self._snap = None
        self._sketch = None

    def copy_properties(self, gc):
        self._alpha = gc._alpha
        self._forced_alpha = gc._forced_alpha
        self._antialiased = gc._antialiased
        self._capstyle = gc._capstyle
        self._cliprect = gc._cliprect
        self._clippath = gc._clippath
        self._dashes = gc._dashes
        self._joinstyle = gc._joinstyle
        self._linestyle = gc._linestyle
        self._linewidth = gc._linewidth
        self._rgb = gc._rgb
        self._hatch = gc._hatch
        self._hatch_color = gc._hatch_color
        self._hatch_linewidth = gc._hatch_linewidth
        self._url = gc._url
        self._gid = gc._gid
        self._snap = gc._snap
        self._sketch = gc._sketch

    def restore(self):

    def get_alpha(self):
        return self._alpha

    def get_antialiased(self):
        return self._antialiased

    def get_capstyle(self):
        return self._capstyle.name

    def get_clip_rectangle(self):
        return self._cliprect

    def get_clip_path(self):
        if self._clippath is not None:
            (tpath, tr) = self._clippath.get_transformed_path_and_affine()
            if np.all(np.isfinite(tpath.vertices)):
                return (tpath, tr)
            else:
                _log.warning('Ill-defined clip_path detected. Returning None.')
                return (None, None)
        return (None, None)

    def get_dashes(self):
        return self._dashes

    def get_forced_alpha(self):
        return self._forced_alpha

    def get_joinstyle(self):
        return self._joinstyle.name

    def get_linewidth(self):
        return self._linewidth

    def get_rgb(self):
        return self._rgb

    def get_url(self):
        return self._url

    def get_gid(self):
        return self._gid

    def get_snap(self):
        return self._snap

    def set_alpha(self, alpha):
        if alpha is not None:
            self._alpha = alpha
            self._forced_alpha = True
        else:
            self._alpha = 1.0
            self._forced_alpha = False
        self.set_foreground(self._rgb, isRGBA=True)

    def set_antialiased(self, b):
        self._antialiased = int(bool(b))

    @_docstring.interpd
    def set_capstyle(self, cs):
        self._capstyle = CapStyle(cs)

    def set_clip_rectangle(self, rectangle):
        self._cliprect = rectangle

    def set_clip_path(self, path):
        _api.check_isinstance((transforms.TransformedPath, None), path=path)
        self._clippath = path

    def set_dashes(self, dash_offset, dash_list):
        if dash_list is not None:
            dl = np.asarray(dash_list)
            if np.any(dl < 0.0):
                raise ValueError('All values in the dash list must be non-negative')
            if dl.size and (not np.any(dl > 0.0)):
                raise ValueError('At least one value in the dash list must be positive')
        self._dashes = (dash_offset, dash_list)

    def set_foreground(self, fg, isRGBA=False):
        if self._forced_alpha and isRGBA:
            self._rgb = fg[:3] + (self._alpha,)
        elif self._forced_alpha:
            self._rgb = colors.to_rgba(fg, self._alpha)
        elif isRGBA:
            self._rgb = fg
        else:
            self._rgb = colors.to_rgba(fg)

    @_docstring.interpd
    def set_joinstyle(self, js):
        self._joinstyle = JoinStyle(js)

    def set_linewidth(self, w):
        self._linewidth = float(w)

    def set_url(self, url):
        self._url = url

    def set_gid(self, id):
        self._gid = id

    def set_snap(self, snap):
        self._snap = snap

    def set_hatch(self, hatch):
        self._hatch = hatch

    def get_hatch(self):
        return self._hatch

    def get_hatch_path(self, density=6.0):
        hatch = self.get_hatch()
        if hatch is None:
            return None
        return Path.hatch(hatch, density)

    def get_hatch_color(self):
        return self._hatch_color

    def set_hatch_color(self, hatch_color):
        self._hatch_color = hatch_color

    def get_hatch_linewidth(self):
        return self._hatch_linewidth

    def get_sketch_params(self):
        return self._sketch

    def set_sketch_params(self, scale=None, length=None, randomness=None):
        self._sketch = None if scale is None else (scale, length or 128.0, randomness or 16.0)

class TimerBase:

    def __init__(self, interval=None, callbacks=None):
        self.callbacks = [] if callbacks is None else callbacks.copy()
        self.interval = 1000 if interval is None else interval
        self.single_shot = False

    def __del__(self):
        self._timer_stop()

    @_api.delete_parameter('3.9', 'interval', alternative='timer.interval')
    def start(self, interval=None):
        if interval is not None:
            self.interval = interval
        self._timer_start()

    def stop(self):
        self._timer_stop()

    def _timer_start(self):
        pass

    def _timer_stop(self):
        pass

    @property
    def interval(self):
        return self._interval

    @interval.setter
    def interval(self, interval):
        interval = max(int(interval), 1)
        self._interval = interval
        self._timer_set_interval()

    @property
    def single_shot(self):
        return self._single

    @single_shot.setter
    def single_shot(self, ss):
        self._single = ss
        self._timer_set_single_shot()

    def add_callback(self, func, *args, **kwargs):
        self.callbacks.append((func, args, kwargs))
        return func

    def remove_callback(self, func, *args, **kwargs):
        if args or kwargs:
            _api.warn_deprecated('3.1', message='In a future version, Timer.remove_callback will not take *args, **kwargs anymore, but remove all callbacks where the callable matches; to keep a specific callback removable by itself, pass it to add_callback as a functools.partial object.')
            self.callbacks.remove((func, args, kwargs))
        else:
            funcs = [c[0] for c in self.callbacks]
            if func in funcs:
                self.callbacks.pop(funcs.index(func))

    def _timer_set_interval(self):

    def _timer_set_single_shot(self):

    def _on_timer(self):
        for (func, args, kwargs) in self.callbacks:
            ret = func(*args, **kwargs)
            if ret == 0:
                self.callbacks.remove((func, args, kwargs))
        if len(self.callbacks) == 0:
            self.stop()

class Event:

    def __init__(self, name, canvas, guiEvent=None):
        self.name = name
        self.canvas = canvas
        self._guiEvent = guiEvent
        self._guiEvent_deleted = False

    def _process(self):
        self.canvas.callbacks.process(self.name, self)
        self._guiEvent_deleted = True

    @property
    def guiEvent(self):
        if self._guiEvent_deleted:
            _api.warn_deprecated('3.8', message='Accessing guiEvent outside of the original GUI event handler is unsafe and deprecated since %(since)s; in the future, the attribute will be set to None after quitting the event handler.  You may separately record the value of the guiEvent attribute at your own risk.')
        return self._guiEvent

class DrawEvent(Event):

    def __init__(self, name, canvas, renderer):
        super().__init__(name, canvas)
        self.renderer = renderer

class ResizeEvent(Event):

    def __init__(self, name, canvas):
        super().__init__(name, canvas)
        (self.width, self.height) = canvas.get_width_height()

class CloseEvent(Event):

class LocationEvent(Event):
    _lastevent = None
    lastevent = _api.deprecated('3.8')(_api.classproperty(lambda cls: cls._lastevent))
    _last_axes_ref = None

    def __init__(self, name, canvas, x, y, guiEvent=None, *, modifiers=None):
        super().__init__(name, canvas, guiEvent=guiEvent)
        self.x = int(x) if x is not None else x
        self.y = int(y) if y is not None else y
        self.inaxes = None
        self.xdata = None
        self.ydata = None
        self.modifiers = frozenset(modifiers if modifiers is not None else [])
        if x is None or y is None:
            return
        self._set_inaxes(self.canvas.inaxes((x, y)) if self.canvas.mouse_grabber is None else self.canvas.mouse_grabber, (x, y))

    def _set_inaxes(self, inaxes, xy=None):
        self.inaxes = inaxes
        if inaxes is not None:
            try:
                (self.xdata, self.ydata) = inaxes.transData.inverted().transform(xy if xy is not None else (self.x, self.y))
            except ValueError:
                pass

class MouseButton(IntEnum):
    LEFT = 1
    MIDDLE = 2
    RIGHT = 3
    BACK = 8
    FORWARD = 9

class MouseEvent(LocationEvent):

    def __init__(self, name, canvas, x, y, button=None, key=None, step=0, dblclick=False, guiEvent=None, *, modifiers=None):
        super().__init__(name, canvas, x, y, guiEvent=guiEvent, modifiers=modifiers)
        if button in MouseButton.__members__.values():
            button = MouseButton(button)
        if name == 'scroll_event' and button is None:
            if step > 0:
                button = 'up'
            elif step < 0:
                button = 'down'
        self.button = button
        self.key = key
        self.step = step
        self.dblclick = dblclick

    def __str__(self):
        return f'{self.name}: xy=({self.x}, {self.y}) xydata=({self.xdata}, {self.ydata}) button={self.button} dblclick={self.dblclick} inaxes={self.inaxes}'

class PickEvent(Event):

    def __init__(self, name, canvas, mouseevent, artist, guiEvent=None, **kwargs):
        if guiEvent is None:
            guiEvent = mouseevent.guiEvent
        super().__init__(name, canvas, guiEvent)
        self.mouseevent = mouseevent
        self.artist = artist
        self.__dict__.update(kwargs)

class KeyEvent(LocationEvent):

    def __init__(self, name, canvas, key, x=0, y=0, guiEvent=None):
        super().__init__(name, canvas, x, y, guiEvent=guiEvent)
        self.key = key

def _key_handler(event):
    if event.name == 'key_press_event':
        event.canvas._key = event.key
    elif event.name == 'key_release_event':
        event.canvas._key = None

def _mouse_handler(event):
    if event.name == 'button_press_event':
        event.canvas._button = event.button
    elif event.name == 'button_release_event':
        event.canvas._button = None
    elif event.name == 'motion_notify_event' and event.button is None:
        event.button = event.canvas._button
    if event.key is None:
        event.key = event.canvas._key
    if event.name == 'motion_notify_event':
        last_ref = LocationEvent._last_axes_ref
        last_axes = last_ref() if last_ref else None
        if last_axes != event.inaxes:
            if last_axes is not None:
                try:
                    canvas = last_axes.get_figure(root=True).canvas
                    leave_event = LocationEvent('axes_leave_event', canvas, event.x, event.y, event.guiEvent, modifiers=event.modifiers)
                    leave_event._set_inaxes(last_axes)
                    canvas.callbacks.process('axes_leave_event', leave_event)
                except Exception:
                    pass
            if event.inaxes is not None:
                event.canvas.callbacks.process('axes_enter_event', event)
        LocationEvent._last_axes_ref = weakref.ref(event.inaxes) if event.inaxes else None
        LocationEvent._lastevent = None if event.name == 'figure_leave_event' else event

def _get_renderer(figure, print_method=None):

    class Done(Exception):
        pass

    def _draw(renderer):
        raise Done(renderer)
    with cbook._setattr_cm(figure, draw=_draw), ExitStack() as stack:
        if print_method is None:
            fmt = figure.canvas.get_default_filetype()
            print_method = stack.enter_context(figure.canvas._switch_canvas_and_return_print_method(fmt))
        try:
            print_method(io.BytesIO())
        except Done as exc:
            (renderer,) = exc.args
            return renderer
        else:
            raise RuntimeError(f'{print_method} did not call Figure.draw, so no renderer is available')

def _no_output_draw(figure):
    figure.draw_without_rendering()

def _is_non_interactive_terminal_ipython(ip):
    return hasattr(ip, 'parent') and ip.parent is not None and (getattr(ip.parent, 'interact', None) is False)

@contextmanager
def _allow_interrupt(prepare_notifier, handle_sigint):
    old_sigint_handler = signal.getsignal(signal.SIGINT)
    if old_sigint_handler in (None, signal.SIG_IGN, signal.SIG_DFL):
        yield
        return
    handler_args = None
    (wsock, rsock) = socket.socketpair()
    wsock.setblocking(False)
    rsock.setblocking(False)
    old_wakeup_fd = signal.set_wakeup_fd(wsock.fileno())
    notifier = prepare_notifier(rsock)

    def save_args_and_handle_sigint(*args):
        nonlocal handler_args
        handler_args = args
        handle_sigint()
    signal.signal(signal.SIGINT, save_args_and_handle_sigint)
    try:
        yield
    finally:
        wsock.close()
        rsock.close()
        signal.set_wakeup_fd(old_wakeup_fd)
        signal.signal(signal.SIGINT, old_sigint_handler)
        if handler_args is not None:
            old_sigint_handler(*handler_args)

class FigureCanvasBase:
    required_interactive_framework = None
    manager_class = _api.classproperty(lambda cls: FigureManagerBase)
    events = ['resize_event', 'draw_event', 'key_press_event', 'key_release_event', 'button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event', 'pick_event', 'figure_enter_event', 'figure_leave_event', 'axes_enter_event', 'axes_leave_event', 'close_event']
    fixed_dpi = None
    filetypes = _default_filetypes

    @_api.classproperty
    def supports_blit(cls):
        return hasattr(cls, 'copy_from_bbox') and hasattr(cls, 'restore_region')

    def __init__(self, figure=None):
        from matplotlib.figure import Figure
        self._fix_ipython_backend2gui()
        self._is_idle_drawing = True
        self._is_saving = False
        if figure is None:
            figure = Figure()
        figure.set_canvas(self)
        self.figure = figure
        self.manager = None
        self.widgetlock = widgets.LockDraw()
        self._button = None
        self._key = None
        self.mouse_grabber = None
        self.toolbar = None
        self._is_idle_drawing = False
        figure._original_dpi = figure.dpi
        self._device_pixel_ratio = 1
        super().__init__()
    callbacks = property(lambda self: self.figure._canvas_callbacks)
    button_pick_id = property(lambda self: self.figure._button_pick_id)
    scroll_pick_id = property(lambda self: self.figure._scroll_pick_id)

    @classmethod
    @functools.cache
    def _fix_ipython_backend2gui(cls):
        mod_ipython = sys.modules.get('IPython')
        if mod_ipython is None or mod_ipython.version_info[:2] >= (8, 24):
            return
        import IPython
        ip = IPython.get_ipython()
        if not ip:
            return
        from IPython.core import pylabtools as pt
        if not hasattr(pt, 'backend2gui') or not hasattr(ip, 'enable_matplotlib'):
            return
        backend2gui_rif = {'qt': 'qt', 'gtk3': 'gtk3', 'gtk4': 'gtk4', 'wx': 'wx', 'macosx': 'osx'}.get(cls.required_interactive_framework)
        if backend2gui_rif:
            if _is_non_interactive_terminal_ipython(ip):
                ip.enable_gui(backend2gui_rif)

    @classmethod
    def new_manager(cls, figure, num):
        return cls.manager_class.create_with_canvas(cls, figure, num)

    @contextmanager
    def _idle_draw_cntx(self):
        self._is_idle_drawing = True
        try:
            yield
        finally:
            self._is_idle_drawing = False

    def is_saving(self):
        return self._is_saving

    def blit(self, bbox=None):

    def inaxes(self, xy):
        axes_list = [a for a in self.figure.get_axes() if a.patch.contains_point(xy) and a.get_visible()]
        if axes_list:
            axes = cbook._topmost_artist(axes_list)
        else:
            axes = None
        return axes

    def grab_mouse(self, ax):
        if self.mouse_grabber not in (None, ax):
            raise RuntimeError('Another Axes already grabs mouse input')
        self.mouse_grabber = ax

    def release_mouse(self, ax):
        if self.mouse_grabber is ax:
            self.mouse_grabber = None

    def set_cursor(self, cursor):

    def draw(self, *args, **kwargs):

    def draw_idle(self, *args, **kwargs):
        if not self._is_idle_drawing:
            with self._idle_draw_cntx():
                self.draw(*args, **kwargs)

    @property
    def device_pixel_ratio(self):
        return self._device_pixel_ratio

    def _set_device_pixel_ratio(self, ratio):
        if self._device_pixel_ratio == ratio:
            return False
        dpi = ratio * self.figure._original_dpi
        self.figure._set_dpi(dpi, forward=False)
        self._device_pixel_ratio = ratio
        return True

    def get_width_height(self, *, physical=False):
        return tuple((int(size / (1 if physical else self.device_pixel_ratio)) for size in self.figure.bbox.max))

    @classmethod
    def get_supported_filetypes(cls):
        return cls.filetypes

    @classmethod
    def get_supported_filetypes_grouped(cls):
        groupings = {}
        for (ext, name) in cls.filetypes.items():
            groupings.setdefault(name, []).append(ext)
            groupings[name].sort()
        return groupings

    @contextmanager
    def _switch_canvas_and_return_print_method(self, fmt, backend=None):
        canvas = None
        if backend is not None:
            from .backends.registry import backend_registry
            canvas_class = backend_registry.load_backend_module(backend).FigureCanvas
            if not hasattr(canvas_class, f'print_{fmt}'):
                raise ValueError(f'The {backend!r} backend does not support {fmt} output')
            canvas = canvas_class(self.figure)
        elif hasattr(self, f'print_{fmt}'):
            canvas = self
        else:
            canvas_class = get_registered_canvas_class(fmt)
            if canvas_class is None:
                raise ValueError('Format {!r} is not supported (supported formats: {})'.format(fmt, ', '.join(sorted(self.get_supported_filetypes()))))
            canvas = canvas_class(self.figure)
        canvas._is_saving = self._is_saving
        meth = getattr(canvas, f'print_{fmt}')
        mod = meth.func.__module__ if hasattr(meth, 'func') else meth.__module__
        if mod.startswith(('matplotlib.', 'mpl_toolkits.')):
            optional_kws = {'dpi', 'facecolor', 'edgecolor', 'orientation', 'bbox_inches_restore'}
            skip = optional_kws - {*inspect.signature(meth).parameters}
            print_method = functools.wraps(meth)(lambda *args, **kwargs: meth(*args, **{k: v for (k, v) in kwargs.items() if k not in skip}))
        else:
            print_method = meth
        try:
            yield print_method
        finally:
            self.figure.canvas = self

    def print_figure(self, filename, dpi=None, facecolor=None, edgecolor=None, orientation='portrait', format=None, *, bbox_inches=None, pad_inches=None, bbox_extra_artists=None, backend=None, **kwargs):
        if format is None:
            if isinstance(filename, os.PathLike):
                filename = os.fspath(filename)
            if isinstance(filename, str):
                format = os.path.splitext(filename)[1][1:]
            if format is None or format == '':
                format = self.get_default_filetype()
                if isinstance(filename, str):
                    filename = filename.rstrip('.') + '.' + format
        format = format.lower()
        if dpi is None:
            dpi = rcParams['savefig.dpi']
        if dpi == 'figure':
            dpi = getattr(self.figure, '_original_dpi', self.figure.dpi)
        if kwargs.get('papertype') == 'auto':
            _api.warn_deprecated('3.8', name="papertype='auto'", addendum="Pass an explicit paper type, 'figure', or omit the *papertype* argument entirely.")
        with cbook._setattr_cm(self, manager=None), self._switch_canvas_and_return_print_method(format, backend) as print_method, cbook._setattr_cm(self.figure, dpi=dpi), cbook._setattr_cm(self.figure.canvas, _device_pixel_ratio=1), cbook._setattr_cm(self.figure.canvas, _is_saving=True), ExitStack() as stack:
            for prop in ['facecolor', 'edgecolor']:
                color = locals()[prop]
                if color is None:
                    color = rcParams[f'savefig.{prop}']
                if not cbook._str_equal(color, 'auto'):
                    stack.enter_context(self.figure._cm_set(**{prop: color}))
            if bbox_inches is None:
                bbox_inches = rcParams['savefig.bbox']
            layout_engine = self.figure.get_layout_engine()
            if layout_engine is not None or bbox_inches == 'tight':
                renderer = _get_renderer(self.figure, functools.partial(print_method, orientation=orientation))
                with getattr(renderer, '_draw_disabled', nullcontext)():
                    self.figure.draw(renderer)
            if bbox_inches:
                if bbox_inches == 'tight':
                    bbox_inches = self.figure.get_tightbbox(renderer, bbox_extra_artists=bbox_extra_artists)
                    if isinstance(layout_engine, ConstrainedLayoutEngine) and pad_inches == 'layout':
                        h_pad = layout_engine.get()['h_pad']
                        w_pad = layout_engine.get()['w_pad']
                    else:
                        if pad_inches in [None, 'layout']:
                            pad_inches = rcParams['savefig.pad_inches']
                        h_pad = w_pad = pad_inches
                    bbox_inches = bbox_inches.padded(w_pad, h_pad)
                restore_bbox = _tight_bbox.adjust_bbox(self.figure, bbox_inches, self.figure.canvas.fixed_dpi)
                _bbox_inches_restore = (bbox_inches, restore_bbox)
            else:
                _bbox_inches_restore = None
            stack.enter_context(self.figure._cm_set(layout_engine='none'))
            try:
                with cbook._setattr_cm(self.figure, dpi=dpi):
                    result = print_method(filename, facecolor=facecolor, edgecolor=edgecolor, orientation=orientation, bbox_inches_restore=_bbox_inches_restore, **kwargs)
            finally:
                if bbox_inches and restore_bbox:
                    restore_bbox()
            return result

    @classmethod
    def get_default_filetype(cls):
        return rcParams['savefig.format']

    def get_default_filename(self):
        default_basename = self.manager.get_window_title() if self.manager is not None else ''
        default_basename = default_basename or 'image'
        removed_chars = '<>:"/\\|?*\\0 '
        default_basename = default_basename.translate({ord(c): '_' for c in removed_chars})
        default_filetype = self.get_default_filetype()
        return f'{default_basename}.{default_filetype}'

    @_api.deprecated('3.8')
    def switch_backends(self, FigureCanvasClass):
        newCanvas = FigureCanvasClass(self.figure)
        newCanvas._is_saving = self._is_saving
        return newCanvas

    def mpl_connect(self, s, func):
        return self.callbacks.connect(s, func)

    def mpl_disconnect(self, cid):
        self.callbacks.disconnect(cid)
    _timer_cls = TimerBase

    def new_timer(self, interval=None, callbacks=None):
        return self._timer_cls(interval=interval, callbacks=callbacks)

    def flush_events(self):

    def start_event_loop(self, timeout=0):
        if timeout <= 0:
            timeout = np.inf
        timestep = 0.01
        counter = 0
        self._looping = True
        while self._looping and counter * timestep < timeout:
            self.flush_events()
            time.sleep(timestep)
            counter += 1

    def stop_event_loop(self):
        self._looping = False

def key_press_handler(event, canvas=None, toolbar=None):
    if event.key is None:
        return
    if canvas is None:
        canvas = event.canvas
    if toolbar is None:
        toolbar = canvas.toolbar
    if event.key in rcParams['keymap.fullscreen']:
        try:
            canvas.manager.full_screen_toggle()
        except AttributeError:
            pass
    if event.key in rcParams['keymap.quit']:
        Gcf.destroy_fig(canvas.figure)
    if event.key in rcParams['keymap.quit_all']:
        Gcf.destroy_all()
    if toolbar is not None:
        if event.key in rcParams['keymap.home']:
            toolbar.home()
        elif event.key in rcParams['keymap.back']:
            toolbar.back()
        elif event.key in rcParams['keymap.forward']:
            toolbar.forward()
        elif event.key in rcParams['keymap.pan']:
            toolbar.pan()
            toolbar._update_cursor(event)
        elif event.key in rcParams['keymap.zoom']:
            toolbar.zoom()
            toolbar._update_cursor(event)
        elif event.key in rcParams['keymap.save']:
            toolbar.save_figure()
    if event.inaxes is None:
        return

    def _get_uniform_gridstate(ticks):
        return True if all((tick.gridline.get_visible() for tick in ticks)) else False if not any((tick.gridline.get_visible() for tick in ticks)) else None
    ax = event.inaxes
    if event.key in rcParams['keymap.grid'] and None not in [_get_uniform_gridstate(ax.xaxis.minorTicks), _get_uniform_gridstate(ax.yaxis.minorTicks)]:
        x_state = _get_uniform_gridstate(ax.xaxis.majorTicks)
        y_state = _get_uniform_gridstate(ax.yaxis.majorTicks)
        cycle = [(False, False), (True, False), (True, True), (False, True)]
        try:
            (x_state, y_state) = cycle[(cycle.index((x_state, y_state)) + 1) % len(cycle)]
        except ValueError:
            pass
        else:
            ax.grid(x_state, which='major' if x_state else 'both', axis='x')
            ax.grid(y_state, which='major' if y_state else 'both', axis='y')
            canvas.draw_idle()
    if event.key in rcParams['keymap.grid_minor'] and None not in [_get_uniform_gridstate(ax.xaxis.majorTicks), _get_uniform_gridstate(ax.yaxis.majorTicks)]:
        x_state = _get_uniform_gridstate(ax.xaxis.minorTicks)
        y_state = _get_uniform_gridstate(ax.yaxis.minorTicks)
        cycle = [(False, False), (True, False), (True, True), (False, True)]
        try:
            (x_state, y_state) = cycle[(cycle.index((x_state, y_state)) + 1) % len(cycle)]
        except ValueError:
            pass
        else:
            ax.grid(x_state, which='both', axis='x')
            ax.grid(y_state, which='both', axis='y')
            canvas.draw_idle()
    elif event.key in rcParams['keymap.yscale']:
        scale = ax.get_yscale()
        if scale == 'log':
            ax.set_yscale('linear')
            ax.get_figure(root=True).canvas.draw_idle()
        elif scale == 'linear':
            try:
                ax.set_yscale('log')
            except ValueError as exc:
                _log.warning(str(exc))
                ax.set_yscale('linear')
            ax.get_figure(root=True).canvas.draw_idle()
    elif event.key in rcParams['keymap.xscale']:
        scalex = ax.get_xscale()
        if scalex == 'log':
            ax.set_xscale('linear')
            ax.get_figure(root=True).canvas.draw_idle()
        elif scalex == 'linear':
            try:
                ax.set_xscale('log')
            except ValueError as exc:
                _log.warning(str(exc))
                ax.set_xscale('linear')
            ax.get_figure(root=True).canvas.draw_idle()

def button_press_handler(event, canvas=None, toolbar=None):
    if canvas is None:
        canvas = event.canvas
    if toolbar is None:
        toolbar = canvas.toolbar
    if toolbar is not None:
        button_name = str(MouseButton(event.button))
        if button_name in rcParams['keymap.back']:
            toolbar.back()
        elif button_name in rcParams['keymap.forward']:
            toolbar.forward()

class NonGuiException(Exception):
    pass

class FigureManagerBase:
    _toolbar2_class = None
    _toolmanager_toolbar_class = None

    def __init__(self, canvas, num):
        self.canvas = canvas
        canvas.manager = self
        self.num = num
        self.set_window_title(f'Figure {num:d}')
        self.key_press_handler_id = None
        self.button_press_handler_id = None
        if rcParams['toolbar'] != 'toolmanager':
            self.key_press_handler_id = self.canvas.mpl_connect('key_press_event', key_press_handler)
            self.button_press_handler_id = self.canvas.mpl_connect('button_press_event', button_press_handler)
        self.toolmanager = ToolManager(canvas.figure) if mpl.rcParams['toolbar'] == 'toolmanager' else None
        if mpl.rcParams['toolbar'] == 'toolbar2' and self._toolbar2_class:
            self.toolbar = self._toolbar2_class(self.canvas)
        elif mpl.rcParams['toolbar'] == 'toolmanager' and self._toolmanager_toolbar_class:
            self.toolbar = self._toolmanager_toolbar_class(self.toolmanager)
        else:
            self.toolbar = None
        if self.toolmanager:
            tools.add_tools_to_manager(self.toolmanager)
            if self.toolbar:
                tools.add_tools_to_container(self.toolbar)

        @self.canvas.figure.add_axobserver
        def notify_axes_change(fig):
            if self.toolmanager is None and self.toolbar is not None:
                self.toolbar.update()

    @classmethod
    def create_with_canvas(cls, canvas_class, figure, num):
        return cls(canvas_class(figure), num)

    @classmethod
    def start_main_loop(cls):

    @classmethod
    def pyplot_show(cls, *, block=None):
        managers = Gcf.get_all_fig_managers()
        if not managers:
            return
        for manager in managers:
            try:
                manager.show()
            except NonGuiException as exc:
                _api.warn_external(str(exc))
        if block is None:
            pyplot_show = getattr(sys.modules.get('matplotlib.pyplot'), 'show', None)
            ipython_pylab = hasattr(pyplot_show, '_needmain')
            block = not ipython_pylab and (not is_interactive())
        if block:
            cls.start_main_loop()

    def show(self):
        if sys.platform == 'linux' and (not os.environ.get('DISPLAY')):
            return
        raise NonGuiException(f'{type(self.canvas).__name__} is non-interactive, and thus cannot be shown')

    def destroy(self):
        pass

    def full_screen_toggle(self):
        pass

    def resize(self, w, h):

    def get_window_title(self):
        return 'image'

    def set_window_title(self, title):
cursors = tools.cursors

class _Mode(str, Enum):
    NONE = ''
    PAN = 'pan/zoom'
    ZOOM = 'zoom rect'

    def __str__(self):
        return self.value

    @property
    def _navigate_mode(self):
        return self.name if self is not _Mode.NONE else None

class NavigationToolbar2:
    toolitems = (('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'back', 'back'), ('Forward', 'Forward to next view', 'forward', 'forward'), (None, None, None, None), ('Pan', 'Left button pans, Right button zooms\nx/y fixes axis, CTRL fixes aspect', 'move', 'pan'), ('Zoom', 'Zoom to rectangle\nx/y fixes axis', 'zoom_to_rect', 'zoom'), ('Subplots', 'Configure subplots', 'subplots', 'configure_subplots'), (None, None, None, None), ('Save', 'Save the figure', 'filesave', 'save_figure'))

    def __init__(self, canvas):
        self.canvas = canvas
        canvas.toolbar = self
        self._nav_stack = cbook._Stack()
        self._last_cursor = tools.Cursors.POINTER
        self._id_press = self.canvas.mpl_connect('button_press_event', self._zoom_pan_handler)
        self._id_release = self.canvas.mpl_connect('button_release_event', self._zoom_pan_handler)
        self._id_drag = self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
        self._pan_info = None
        self._zoom_info = None
        self.mode = _Mode.NONE
        self.set_history_buttons()

    def set_message(self, s):

    def draw_rubberband(self, event, x0, y0, x1, y1):

    def remove_rubberband(self):

    def home(self, *args):
        self._nav_stack.home()
        self.set_history_buttons()
        self._update_view()

    def back(self, *args):
        self._nav_stack.back()
        self.set_history_buttons()
        self._update_view()

    def forward(self, *args):
        self._nav_stack.forward()
        self.set_history_buttons()
        self._update_view()

    def _update_cursor(self, event):
        if self.mode and event.inaxes and event.inaxes.get_navigate():
            if self.mode == _Mode.ZOOM and self._last_cursor != tools.Cursors.SELECT_REGION:
                self.canvas.set_cursor(tools.Cursors.SELECT_REGION)
                self._last_cursor = tools.Cursors.SELECT_REGION
            elif self.mode == _Mode.PAN and self._last_cursor != tools.Cursors.MOVE:
                self.canvas.set_cursor(tools.Cursors.MOVE)
                self._last_cursor = tools.Cursors.MOVE
        elif self._last_cursor != tools.Cursors.POINTER:
            self.canvas.set_cursor(tools.Cursors.POINTER)
            self._last_cursor = tools.Cursors.POINTER

    @contextmanager
    def _wait_cursor_for_draw_cm(self):
        (self._draw_time, last_draw_time) = (time.time(), getattr(self, '_draw_time', -np.inf))
        if self._draw_time - last_draw_time > 1:
            try:
                self.canvas.set_cursor(tools.Cursors.WAIT)
                yield
            finally:
                self.canvas.set_cursor(self._last_cursor)
        else:
            yield

    @staticmethod
    def _mouse_event_to_message(event):
        if event.inaxes and event.inaxes.get_navigate():
            try:
                s = event.inaxes.format_coord(event.xdata, event.ydata)
            except (ValueError, OverflowError):
                pass
            else:
                s = s.rstrip()
                artists = [a for a in event.inaxes._mouseover_set if a.contains(event)[0] and a.get_visible()]
                if artists:
                    a = cbook._topmost_artist(artists)
                    if a is not event.inaxes.patch:
                        data = a.get_cursor_data(event)
                        if data is not None:
                            data_str = a.format_cursor_data(data).rstrip()
                            if data_str:
                                s = s + '\n' + data_str
                return s
        return ''

    def mouse_move(self, event):
        self._update_cursor(event)
        self.set_message(self._mouse_event_to_message(event))

    def _zoom_pan_handler(self, event):
        if self.mode == _Mode.PAN:
            if event.name == 'button_press_event':
                self.press_pan(event)
            elif event.name == 'button_release_event':
                self.release_pan(event)
        if self.mode == _Mode.ZOOM:
            if event.name == 'button_press_event':
                self.press_zoom(event)
            elif event.name == 'button_release_event':
                self.release_zoom(event)

    def _start_event_axes_interaction(self, event, *, method):

        def _ax_filter(ax):
            return ax.in_axes(event) and ax.get_navigate() and getattr(ax, f'can_{method}')()

        def _capture_events(ax):
            f = ax.get_forward_navigation_events()
            if f == 'auto':
                f = not ax.patch.get_visible()
            return not f
        axes = list(filter(_ax_filter, self.canvas.figure.get_axes()))
        if len(axes) == 0:
            return []
        if self._nav_stack() is None:
            self.push_current()
        grps = dict()
        for ax in reversed(axes):
            grps.setdefault(ax.get_zorder(), []).append(ax)
        axes_to_trigger = []
        for zorder in sorted(grps, reverse=True):
            for ax in grps[zorder]:
                axes_to_trigger.append(ax)
                axes_to_trigger.extend(ax._twinned_axes.get_siblings(ax))
                if _capture_events(ax):
                    break
            else:
                continue
            break
        axes_to_trigger = list(dict.fromkeys(axes_to_trigger))
        return axes_to_trigger

    def pan(self, *args):
        if not self.canvas.widgetlock.available(self):
            self.set_message('pan unavailable')
            return
        if self.mode == _Mode.PAN:
            self.mode = _Mode.NONE
            self.canvas.widgetlock.release(self)
        else:
            self.mode = _Mode.PAN
            self.canvas.widgetlock(self)
        for a in self.canvas.figure.get_axes():
            a.set_navigate_mode(self.mode._navigate_mode)
    _PanInfo = namedtuple('_PanInfo', 'button axes cid')

    def press_pan(self, event):
        if event.button not in [MouseButton.LEFT, MouseButton.RIGHT] or event.x is None or event.y is None:
            return
        axes = self._start_event_axes_interaction(event, method='pan')
        if not axes:
            return
        for ax in axes:
            ax.start_pan(event.x, event.y, event.button)
        self.canvas.mpl_disconnect(self._id_drag)
        id_drag = self.canvas.mpl_connect('motion_notify_event', self.drag_pan)
        self._pan_info = self._PanInfo(button=event.button, axes=axes, cid=id_drag)

    def drag_pan(self, event):
        for ax in self._pan_info.axes:
            ax.drag_pan(self._pan_info.button, event.key, event.x, event.y)
        self.canvas.draw_idle()

    def release_pan(self, event):
        if self._pan_info is None:
            return
        self.canvas.mpl_disconnect(self._pan_info.cid)
        self._id_drag = self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
        for ax in self._pan_info.axes:
            ax.end_pan()
        self.canvas.draw_idle()
        self._pan_info = None
        self.push_current()

    def zoom(self, *args):
        if not self.canvas.widgetlock.available(self):
            self.set_message('zoom unavailable')
            return
        ''
        if self.mode == _Mode.ZOOM:
            self.mode = _Mode.NONE
            self.canvas.widgetlock.release(self)
        else:
            self.mode = _Mode.ZOOM
            self.canvas.widgetlock(self)
        for a in self.canvas.figure.get_axes():
            a.set_navigate_mode(self.mode._navigate_mode)
    _ZoomInfo = namedtuple('_ZoomInfo', 'direction start_xy axes cid cbar')

    def press_zoom(self, event):
        if event.button not in [MouseButton.LEFT, MouseButton.RIGHT] or event.x is None or event.y is None:
            return
        axes = self._start_event_axes_interaction(event, method='zoom')
        if not axes:
            return
        id_zoom = self.canvas.mpl_connect('motion_notify_event', self.drag_zoom)
        parent_ax = axes[0]
        if hasattr(parent_ax, '_colorbar'):
            cbar = parent_ax._colorbar.orientation
        else:
            cbar = None
        self._zoom_info = self._ZoomInfo(direction='in' if event.button == 1 else 'out', start_xy=(event.x, event.y), axes=axes, cid=id_zoom, cbar=cbar)

    def drag_zoom(self, event):
        start_xy = self._zoom_info.start_xy
        ax = self._zoom_info.axes[0]
        ((x1, y1), (x2, y2)) = np.clip([start_xy, [event.x, event.y]], ax.bbox.min, ax.bbox.max)
        key = event.key
        if self._zoom_info.cbar == 'horizontal':
            key = 'x'
        elif self._zoom_info.cbar == 'vertical':
            key = 'y'
        if key == 'x':
            (y1, y2) = ax.bbox.intervaly
        elif key == 'y':
            (x1, x2) = ax.bbox.intervalx
        self.draw_rubberband(event, x1, y1, x2, y2)

    def release_zoom(self, event):
        if self._zoom_info is None:
            return
        self.canvas.mpl_disconnect(self._zoom_info.cid)
        self.remove_rubberband()
        (start_x, start_y) = self._zoom_info.start_xy
        key = event.key
        if self._zoom_info.cbar == 'horizontal':
            key = 'x'
        elif self._zoom_info.cbar == 'vertical':
            key = 'y'
        if abs(event.x - start_x) < 5 and key != 'y' or (abs(event.y - start_y) < 5 and key != 'x'):
            self.canvas.draw_idle()
            self._zoom_info = None
            return
        for (i, ax) in enumerate(self._zoom_info.axes):
            twinx = any((ax.get_shared_x_axes().joined(ax, prev) for prev in self._zoom_info.axes[:i]))
            twiny = any((ax.get_shared_y_axes().joined(ax, prev) for prev in self._zoom_info.axes[:i]))
            ax._set_view_from_bbox((start_x, start_y, event.x, event.y), self._zoom_info.direction, key, twinx, twiny)
        self.canvas.draw_idle()
        self._zoom_info = None
        self.push_current()

    def push_current(self):
        self._nav_stack.push(WeakKeyDictionary({ax: (ax._get_view(), (ax.get_position(True).frozen(), ax.get_position().frozen())) for ax in self.canvas.figure.axes}))
        self.set_history_buttons()

    def _update_view(self):
        nav_info = self._nav_stack()
        if nav_info is None:
            return
        items = list(nav_info.items())
        for (ax, (view, (pos_orig, pos_active))) in items:
            ax._set_view(view)
            ax._set_position(pos_orig, 'original')
            ax._set_position(pos_active, 'active')
        self.canvas.draw_idle()

    def configure_subplots(self, *args):
        if hasattr(self, 'subplot_tool'):
            self.subplot_tool.figure.canvas.manager.show()
            return
        from matplotlib.figure import Figure
        with mpl.rc_context({'toolbar': 'none'}):
            manager = type(self.canvas).new_manager(Figure(figsize=(6, 3)), -1)
        manager.set_window_title('Subplot configuration tool')
        tool_fig = manager.canvas.figure
        tool_fig.subplots_adjust(top=0.9)
        self.subplot_tool = widgets.SubplotTool(self.canvas.figure, tool_fig)
        cid = self.canvas.mpl_connect('close_event', lambda e: manager.destroy())

        def on_tool_fig_close(e):
            self.canvas.mpl_disconnect(cid)
            del self.subplot_tool
        tool_fig.canvas.mpl_connect('close_event', on_tool_fig_close)
        manager.show()
        return self.subplot_tool

    def save_figure(self, *args):
        raise NotImplementedError

    def update(self):
        self._nav_stack.clear()
        self.set_history_buttons()

    def set_history_buttons(self):

class ToolContainerBase:
    _icon_extension = '.png'
    ''

    def __init__(self, toolmanager):
        self.toolmanager = toolmanager
        toolmanager.toolmanager_connect('tool_message_event', lambda event: self.set_message(event.message))
        toolmanager.toolmanager_connect('tool_removed_event', lambda event: self.remove_toolitem(event.tool.name))

    def _tool_toggled_cbk(self, event):
        self.toggle_toolitem(event.tool.name, event.tool.toggled)

    def add_tool(self, tool, group, position=-1):
        tool = self.toolmanager.get_tool(tool)
        image = self._get_image_filename(tool)
        toggle = getattr(tool, 'toggled', None) is not None
        self.add_toolitem(tool.name, group, position, image, tool.description, toggle)
        if toggle:
            self.toolmanager.toolmanager_connect('tool_trigger_%s' % tool.name, self._tool_toggled_cbk)
            if tool.toggled:
                self.toggle_toolitem(tool.name, True)

    def _get_image_filename(self, tool):
        if not tool.image:
            return None
        if os.path.isabs(tool.image):
            filename = tool.image
        else:
            if 'image' in getattr(tool, '__dict__', {}):
                raise ValueError("If 'tool.image' is an instance variable, it must be an absolute path")
            for cls in type(tool).__mro__:
                if 'image' in vars(cls):
                    try:
                        src = inspect.getfile(cls)
                        break
                    except (OSError, TypeError):
                        raise ValueError("Failed to locate source file where 'tool.image' is defined") from None
            else:
                raise ValueError("Failed to find parent class defining 'tool.image'")
            filename = str(pathlib.Path(src).parent / tool.image)
        for filename in [filename, filename + self._icon_extension]:
            if os.path.isfile(filename):
                return os.path.abspath(filename)
        for fname in [tool.image, tool.image + self._icon_extension, cbook._get_data_path('images', tool.image), cbook._get_data_path('images', tool.image + self._icon_extension)]:
            if os.path.isfile(fname):
                _api.warn_deprecated('3.9', message=f"Loading icon {tool.image!r} from the current directory or from Matplotlib's image directory.  This behavior is deprecated since %(since)s and will be removed %(removal)s; Tool.image should be set to a path relative to the Tool's source file, or to an absolute path.")
                return os.path.abspath(fname)

    def trigger_tool(self, name):
        self.toolmanager.trigger_tool(name, sender=self)

    def add_toolitem(self, name, group, position, image, description, toggle):
        raise NotImplementedError

    def toggle_toolitem(self, name, toggled):
        raise NotImplementedError

    def remove_toolitem(self, name):
        raise NotImplementedError

    def set_message(self, s):
        raise NotImplementedError

class _Backend:
    backend_version = 'unknown'
    FigureCanvas = None
    FigureManager = FigureManagerBase
    mainloop = None

    @classmethod
    def new_figure_manager(cls, num, *args, **kwargs):
        from matplotlib.figure import Figure
        fig_cls = kwargs.pop('FigureClass', Figure)
        fig = fig_cls(*args, **kwargs)
        return cls.new_figure_manager_given_figure(num, fig)

    @classmethod
    def new_figure_manager_given_figure(cls, num, figure):
        return cls.FigureCanvas.new_manager(figure, num)

    @classmethod
    def draw_if_interactive(cls):
        manager_class = cls.FigureCanvas.manager_class
        backend_is_interactive = manager_class.start_main_loop != FigureManagerBase.start_main_loop or manager_class.pyplot_show != FigureManagerBase.pyplot_show
        if backend_is_interactive and is_interactive():
            manager = Gcf.get_active()
            if manager:
                manager.canvas.draw_idle()

    @classmethod
    def show(cls, *, block=None):
        managers = Gcf.get_all_fig_managers()
        if not managers:
            return
        for manager in managers:
            try:
                manager.show()
            except NonGuiException as exc:
                _api.warn_external(str(exc))
        if cls.mainloop is None:
            return
        if block is None:
            pyplot_show = getattr(sys.modules.get('matplotlib.pyplot'), 'show', None)
            ipython_pylab = hasattr(pyplot_show, '_needmain')
            block = not ipython_pylab and (not is_interactive())
        if block:
            cls.mainloop()

    @staticmethod
    def export(cls):
        for name in ['backend_version', 'FigureCanvas', 'FigureManager', 'new_figure_manager', 'new_figure_manager_given_figure', 'draw_if_interactive', 'show']:
            setattr(sys.modules[cls.__module__], name, getattr(cls, name))

        class Show(ShowBase):

            def mainloop(self):
                return cls.mainloop()
        setattr(sys.modules[cls.__module__], 'Show', Show)
        return cls

class ShowBase(_Backend):

    def __call__(self, block=None):
        return self.show(block=block)

# File: matplotlib-main/lib/matplotlib/backend_managers.py
from matplotlib import _api, backend_tools, cbook, widgets

class ToolEvent:

    def __init__(self, name, sender, tool, data=None):
        self.name = name
        self.sender = sender
        self.tool = tool
        self.data = data

class ToolTriggerEvent(ToolEvent):

    def __init__(self, name, sender, tool, canvasevent=None, data=None):
        super().__init__(name, sender, tool, data)
        self.canvasevent = canvasevent

class ToolManagerMessageEvent:

    def __init__(self, name, sender, message):
        self.name = name
        self.sender = sender
        self.message = message

class ToolManager:

    def __init__(self, figure=None):
        self._key_press_handler_id = None
        self._tools = {}
        self._keys = {}
        self._toggled = {}
        self._callbacks = cbook.CallbackRegistry()
        self.keypresslock = widgets.LockDraw()
        self.messagelock = widgets.LockDraw()
        self._figure = None
        self.set_figure(figure)

    @property
    def canvas(self):
        if not self._figure:
            return None
        return self._figure.canvas

    @property
    def figure(self):
        return self._figure

    @figure.setter
    def figure(self, figure):
        self.set_figure(figure)

    def set_figure(self, figure, update_tools=True):
        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):
        return self._callbacks.connect(s, func)

    def toolmanager_disconnect(self, cid):
        return self._callbacks.disconnect(cid)

    def message_event(self, message, sender=None):
        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):
        return self._toggled

    def get_tool_keymap(self, name):
        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):
        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):
        tool = self.get_tool(name)
        if getattr(tool, 'toggled', False):
            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):
        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)
        if isinstance(tool_obj, backend_tools.ToolToggleBase):
            if tool_obj.radio_group is None:
                self._toggled.setdefault(None, set())
            else:
                self._toggled.setdefault(tool_obj.radio_group, None)
            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):
        radio_group = tool.radio_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 self._toggled[radio_group] == tool.name:
            toggled = None
        elif self._toggled[radio_group] is None:
            toggled = tool.name
        else:
            self.trigger_tool(self._toggled[radio_group], self, canvasevent, data)
            toggled = tool.name
        self._toggled[radio_group] = toggled

    def trigger_tool(self, name, sender=None, canvasevent=None, data=None):
        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)
        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):
        return self._tools

    def get_tool(self, name, warn=True):
        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]

# File: matplotlib-main/lib/matplotlib/backend_tools.py
""""""
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):
    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
_tool_registry = set()

def _register_tool_class(canvas_cls, tool_cls=None):
    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):
    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 = 'viewpos'

class ToolBase:
    default_keymap = None
    ''
    description = None
    ''
    image = None
    ''

    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, lambda self, figure: self.set_figure(figure), doc='The Figure affected by this tool, or None.')

    def _make_classic_style_pseudo_toolbar(self):
        return SimpleNamespace(canvas=self.canvas)

    def trigger(self, sender, event, data=None):
        pass

class ToolToggleBase(ToolBase):
    radio_group = None
    ''
    cursor = None
    ''
    default_toggled = False
    ''

    def __init__(self, *args, **kwargs):
        self._toggled = kwargs.pop('toggled', self.default_toggled)
        super().__init__(*args, **kwargs)

    def trigger(self, sender, event, data=None):
        if self._toggled:
            self.disable(event)
        else:
            self.enable(event)
        self._toggled = not self._toggled

    def enable(self, event=None):
        pass

    def disable(self, event=None):
        pass

    @property
    def toggled(self):
        return self._toggled

    def set_figure(self, figure):
        toggled = self.toggled
        if toggled:
            if self.figure:
                self.trigger(self, None)
            else:
                self._toggled = False
        super().set_figure(figure)
        if toggled:
            if figure:
                self.trigger(self, None)
            else:
                self._toggled = True

class ToolSetCursor(ToolBase):

    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():
            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):
        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):

    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):
        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):

    def trigger(self, sender, event, data=None):
        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):
        raise NotImplementedError

    def remove_rubberband(self):
        pass

class ToolQuit(ToolBase):
    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):
    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):
    description = 'Toggle major grids'
    default_keymap = property(lambda self: mpl.rcParams['keymap.grid'])

    def trigger(self, sender, event, data=None):
        sentinel = str(uuid.uuid4())
        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):
    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())
        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):
    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):

    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):
    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):
    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):

    def __init__(self, *args, **kwargs):
        self.views = WeakKeyDictionary()
        self.positions = WeakKeyDictionary()
        self.home_views = WeakKeyDictionary()
        super().__init__(*args, **kwargs)

    def add_figure(self, figure):
        if figure not in self.views:
            self.views[figure] = cbook._Stack()
            self.positions[figure] = cbook._Stack()
            self.home_views[figure] = WeakKeyDictionary()
            self.push_current(figure)
            figure.add_axobserver(lambda fig: self.update_home_views(fig))

    def clear(self, figure):
        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):
        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:
                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):
        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 (ax.get_position(True).frozen(), ax.get_position().frozen())

    def update_home_views(self, figure=None):
        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):
        self.views[self.figure].home()
        self.positions[self.figure].home()

    def back(self):
        self.views[self.figure].back()
        self.positions[self.figure].back()

    def forward(self):
        self.views[self.figure].forward()
        self.positions[self.figure].forward()

class ViewsPositionsBase(ToolBase):
    _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):
    description = 'Reset original view'
    image = 'mpl-data/images/home'
    default_keymap = property(lambda self: mpl.rcParams['keymap.home'])
    _on_trigger = 'home'

class ToolBack(ViewsPositionsBase):
    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):
    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):
    description = 'Configure subplots'
    image = 'mpl-data/images/subplots'

class SaveFigureBase(ToolBase):
    description = 'Save the figure'
    image = 'mpl-data/images/filesave'
    default_keymap = property(lambda self: mpl.rcParams['keymap.save'])

class ZoomPanBase(ToolToggleBase):

    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.0
        self.scrollthresh = 0.5
        self.lastscroll = time.time() - self.scrollthresh

    def enable(self, event=None):
        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):
        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):
        if event.inaxes is None:
            return
        if event.button == 'up':
            scl = self.base_scale
        elif event.button == 'down':
            scl = 1 / self.base_scale
        else:
            scl = 1
        ax = event.inaxes
        ax._set_view_from_bbox([event.x, event.y, scl])
        if time.time() - self.lastscroll < self.scrollthresh:
            self.toolmanager.get_tool(_views_positions).back()
        self.figure.canvas.draw_idle()
        self.lastscroll = time.time()
        self.toolmanager.get_tool(_views_positions).push_current()

class ToolZoom(ZoomPanBase):
    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):
        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):
        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):
        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
            if abs(x - lastx) < 5 or abs(y - lasty) < 5:
                self._cancel_action()
                return
            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):
    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:
            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):
        return key_sequence if len(key_sequence) == 1 else re.sub('\\+[A-Z]', '+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):
    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):
    for (name, tool) in tools.items():
        toolmanager.add_tool(name, tool)

def add_tools_to_container(container, tools=default_toolbar_tools):
    for (group, grouptools) in tools:
        for (position, tool) in enumerate(grouptools):
            container.add_tool(tool, group, position)

# File: matplotlib-main/lib/matplotlib/backends/_backend_gtk.py
""""""
import logging
import sys
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2, TimerBase
from matplotlib.backend_tools import Cursors
import gi
from gi.repository import Gdk, Gio, GLib, Gtk
try:
    gi.require_foreign('cairo')
except ImportError as e:
    raise ImportError('Gtk-based backends require cairo') from e
_log = logging.getLogger(__name__)
_application = None

def _shutdown_application(app):
    for win in app.get_windows():
        win.close()
    app._created_by_matplotlib = True
    global _application
    _application = None

def _create_application():
    global _application
    if _application is None:
        app = Gio.Application.get_default()
        if app is None or getattr(app, '_created_by_matplotlib', False):
            if not mpl._c_internal_utils.display_is_valid():
                raise RuntimeError('Invalid DISPLAY variable')
            _application = Gtk.Application.new('org.matplotlib.Matplotlib3', Gio.ApplicationFlags.NON_UNIQUE)
            _application.connect('activate', lambda *args, **kwargs: None)
            _application.connect('shutdown', _shutdown_application)
            _application.register()
            cbook._setup_new_guiapp()
        else:
            _application = app
    return _application

def mpl_to_gtk_cursor_name(mpl_cursor):
    return _api.check_getitem({Cursors.MOVE: 'move', Cursors.HAND: 'pointer', Cursors.POINTER: 'default', Cursors.SELECT_REGION: 'crosshair', Cursors.WAIT: 'wait', Cursors.RESIZE_HORIZONTAL: 'ew-resize', Cursors.RESIZE_VERTICAL: 'ns-resize'}, cursor=mpl_cursor)

class TimerGTK(TimerBase):

    def __init__(self, *args, **kwargs):
        self._timer = None
        super().__init__(*args, **kwargs)

    def _timer_start(self):
        self._timer_stop()
        self._timer = GLib.timeout_add(self._interval, self._on_timer)

    def _timer_stop(self):
        if self._timer is not None:
            GLib.source_remove(self._timer)
            self._timer = None

    def _timer_set_interval(self):
        if self._timer is not None:
            self._timer_stop()
            self._timer_start()

    def _on_timer(self):
        super()._on_timer()
        if self.callbacks and (not self._single):
            return True
        else:
            self._timer = None
            return False

class _FigureCanvasGTK(FigureCanvasBase):
    _timer_cls = TimerGTK

class _FigureManagerGTK(FigureManagerBase):

    def __init__(self, canvas, num):
        self._gtk_ver = gtk_ver = Gtk.get_major_version()
        app = _create_application()
        self.window = Gtk.Window()
        app.add_window(self.window)
        super().__init__(canvas, num)
        if gtk_ver == 3:
            self.window.set_wmclass('matplotlib', 'Matplotlib')
            icon_ext = 'png' if sys.platform == 'win32' else 'svg'
            self.window.set_icon_from_file(str(cbook._get_data_path(f'images/matplotlib.{icon_ext}')))
        self.vbox = Gtk.Box()
        self.vbox.set_property('orientation', Gtk.Orientation.VERTICAL)
        if gtk_ver == 3:
            self.window.add(self.vbox)
            self.vbox.show()
            self.canvas.show()
            self.vbox.pack_start(self.canvas, True, True, 0)
        elif gtk_ver == 4:
            self.window.set_child(self.vbox)
            self.vbox.prepend(self.canvas)
        (w, h) = self.canvas.get_width_height()
        if self.toolbar is not None:
            if gtk_ver == 3:
                self.toolbar.show()
                self.vbox.pack_end(self.toolbar, False, False, 0)
            elif gtk_ver == 4:
                sw = Gtk.ScrolledWindow(vscrollbar_policy=Gtk.PolicyType.NEVER)
                sw.set_child(self.toolbar)
                self.vbox.append(sw)
            (min_size, nat_size) = self.toolbar.get_preferred_size()
            h += nat_size.height
        self.window.set_default_size(w, h)
        self._destroying = False
        self.window.connect('destroy', lambda *args: Gcf.destroy(self))
        self.window.connect({3: 'delete_event', 4: 'close-request'}[gtk_ver], lambda *args: Gcf.destroy(self))
        if mpl.is_interactive():
            self.window.show()
            self.canvas.draw_idle()
        self.canvas.grab_focus()

    def destroy(self, *args):
        if self._destroying:
            return
        self._destroying = True
        self.window.destroy()
        self.canvas.destroy()

    @classmethod
    def start_main_loop(cls):
        global _application
        if _application is None:
            return
        try:
            _application.run()
        except KeyboardInterrupt:
            context = GLib.MainContext.default()
            while context.pending():
                context.iteration(True)
            raise
        finally:
            _application = None

    def show(self):
        self.window.show()
        self.canvas.draw()
        if mpl.rcParams['figure.raise_window']:
            meth_name = {3: 'get_window', 4: 'get_surface'}[self._gtk_ver]
            if getattr(self.window, meth_name)():
                self.window.present()
            else:
                _api.warn_external('Cannot raise window yet to be setup')

    def full_screen_toggle(self):
        is_fullscreen = {3: lambda w: w.get_window().get_state() & Gdk.WindowState.FULLSCREEN, 4: lambda w: w.is_fullscreen()}[self._gtk_ver]
        if is_fullscreen(self.window):
            self.window.unfullscreen()
        else:
            self.window.fullscreen()

    def get_window_title(self):
        return self.window.get_title()

    def set_window_title(self, title):
        self.window.set_title(title)

    def resize(self, width, height):
        width = int(width / self.canvas.device_pixel_ratio)
        height = int(height / self.canvas.device_pixel_ratio)
        if self.toolbar:
            (min_size, nat_size) = self.toolbar.get_preferred_size()
            height += nat_size.height
        canvas_size = self.canvas.get_allocation()
        if self._gtk_ver >= 4 or canvas_size.width == canvas_size.height == 1:
            self.window.set_default_size(width, height)
        else:
            self.window.resize(width, height)

class _NavigationToolbar2GTK(NavigationToolbar2):

    def set_message(self, s):
        escaped = GLib.markup_escape_text(s)
        self.message.set_markup(f'<small>{escaped}</small>')

    def draw_rubberband(self, event, x0, y0, x1, y1):
        height = self.canvas.figure.bbox.height
        y1 = height - y1
        y0 = height - y0
        rect = [int(val) for val in (x0, y0, x1 - x0, y1 - y0)]
        self.canvas._draw_rubberband(rect)

    def remove_rubberband(self):
        self.canvas._draw_rubberband(None)

    def _update_buttons_checked(self):
        for (name, active) in [('Pan', 'PAN'), ('Zoom', 'ZOOM')]:
            button = self._gtk_ids.get(name)
            if button:
                with button.handler_block(button._signal_handler):
                    button.set_active(self.mode.name == active)

    def pan(self, *args):
        super().pan(*args)
        self._update_buttons_checked()

    def zoom(self, *args):
        super().zoom(*args)
        self._update_buttons_checked()

    def set_history_buttons(self):
        can_backward = self._nav_stack._pos > 0
        can_forward = self._nav_stack._pos < len(self._nav_stack) - 1
        if 'Back' in self._gtk_ids:
            self._gtk_ids['Back'].set_sensitive(can_backward)
        if 'Forward' in self._gtk_ids:
            self._gtk_ids['Forward'].set_sensitive(can_forward)

class RubberbandGTK(backend_tools.RubberbandBase):

    def draw_rubberband(self, x0, y0, x1, y1):
        _NavigationToolbar2GTK.draw_rubberband(self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)

    def remove_rubberband(self):
        _NavigationToolbar2GTK.remove_rubberband(self._make_classic_style_pseudo_toolbar())

class ConfigureSubplotsGTK(backend_tools.ConfigureSubplotsBase):

    def trigger(self, *args):
        _NavigationToolbar2GTK.configure_subplots(self, None)

class _BackendGTK(_Backend):
    backend_version = '{}.{}.{}'.format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
    mainloop = _FigureManagerGTK.start_main_loop

# File: matplotlib-main/lib/matplotlib/backends/_backend_pdf_ps.py
""""""
from io import BytesIO
import functools
from fontTools import subset
import matplotlib as mpl
from .. import font_manager, ft2font
from .._afm import AFM
from ..backend_bases import RendererBase

@functools.lru_cache(50)
def _cached_get_afm_from_fname(fname):
    with open(fname, 'rb') as fh:
        return AFM(fh)

def get_glyphs_subset(fontfile, characters):
    options = subset.Options(glyph_names=True, recommended_glyphs=True)
    options.drop_tables += ['FFTM', 'PfEd', 'BDF', 'meta']
    if fontfile.endswith('.ttc'):
        options.font_number = 0
    with subset.load_font(fontfile, options) as font:
        subsetter = subset.Subsetter(options=options)
        subsetter.populate(text=characters)
        subsetter.subset(font)
        fh = BytesIO()
        font.save(fh, reorderTables=False)
        return fh

class CharacterTracker:

    def __init__(self):
        self.used = {}

    def track(self, font, s):
        char_to_font = font._get_fontmap(s)
        for (_c, _f) in char_to_font.items():
            self.used.setdefault(_f.fname, set()).add(ord(_c))

    def track_glyph(self, font, glyph):
        self.used.setdefault(font.fname, set()).add(glyph)

class RendererPDFPSBase(RendererBase):

    def __init__(self, width, height):
        super().__init__()
        self.width = width
        self.height = height

    def flipy(self):
        return False

    def option_scale_image(self):
        return True

    def option_image_nocomposite(self):
        return not mpl.rcParams['image.composite_image']

    def get_canvas_width_height(self):
        return (self.width * 72.0, self.height * 72.0)

    def get_text_width_height_descent(self, s, prop, ismath):
        if ismath == 'TeX':
            return super().get_text_width_height_descent(s, prop, ismath)
        elif ismath:
            parse = self._text2path.mathtext_parser.parse(s, 72, prop)
            return (parse.width, parse.height, parse.depth)
        elif mpl.rcParams[self._use_afm_rc_name]:
            font = self._get_font_afm(prop)
            (l, b, w, h, d) = font.get_str_bbox_and_descent(s)
            scale = prop.get_size_in_points() / 1000
            w *= scale
            h *= scale
            d *= scale
            return (w, h, d)
        else:
            font = self._get_font_ttf(prop)
            font.set_text(s, 0.0, flags=ft2font.LOAD_NO_HINTING)
            (w, h) = font.get_width_height()
            d = font.get_descent()
            scale = 1 / 64
            w *= scale
            h *= scale
            d *= scale
            return (w, h, d)

    def _get_font_afm(self, prop):
        fname = font_manager.findfont(prop, fontext='afm', directory=self._afm_font_dir)
        return _cached_get_afm_from_fname(fname)

    def _get_font_ttf(self, prop):
        fnames = font_manager.fontManager._find_fonts_by_props(prop)
        font = font_manager.get_font(fnames)
        font.clear()
        font.set_size(prop.get_size_in_points(), 72)
        return font

# File: matplotlib-main/lib/matplotlib/backends/_backend_tk.py
import uuid
import weakref
from contextlib import contextmanager
import logging
import math
import os.path
import pathlib
import sys
import tkinter as tk
import tkinter.filedialog
import tkinter.font
import tkinter.messagebox
from tkinter.simpledialog import SimpleDialog
import numpy as np
from PIL import Image, ImageTk
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook, _c_internal_utils
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2, TimerBase, ToolContainerBase, cursors, _Mode, CloseEvent, KeyEvent, LocationEvent, MouseEvent, ResizeEvent
from matplotlib._pylab_helpers import Gcf
from . import _tkagg
from ._tkagg import TK_PHOTO_COMPOSITE_OVERLAY, TK_PHOTO_COMPOSITE_SET
_log = logging.getLogger(__name__)
cursord = {cursors.MOVE: 'fleur', cursors.HAND: 'hand2', cursors.POINTER: 'arrow', cursors.SELECT_REGION: 'crosshair', cursors.WAIT: 'watch', cursors.RESIZE_HORIZONTAL: 'sb_h_double_arrow', cursors.RESIZE_VERTICAL: 'sb_v_double_arrow'}

@contextmanager
def _restore_foreground_window_at_end():
    foreground = _c_internal_utils.Win32_GetForegroundWindow()
    try:
        yield
    finally:
        if foreground and mpl.rcParams['tk.window_focus']:
            _c_internal_utils.Win32_SetForegroundWindow(foreground)
_blit_args = {}
_blit_tcl_name = 'mpl_blit_' + uuid.uuid4().hex

def _blit(argsid):
    (photoimage, data, offsets, bbox, comp_rule) = _blit_args.pop(argsid)
    if not photoimage.tk.call('info', 'commands', photoimage):
        return
    _tkagg.blit(photoimage.tk.interpaddr(), str(photoimage), data, comp_rule, offsets, bbox)

def blit(photoimage, aggimage, offsets, bbox=None):
    data = np.asarray(aggimage)
    (height, width) = data.shape[:2]
    if bbox is not None:
        ((x1, y1), (x2, y2)) = bbox.__array__()
        x1 = max(math.floor(x1), 0)
        x2 = min(math.ceil(x2), width)
        y1 = max(math.floor(y1), 0)
        y2 = min(math.ceil(y2), height)
        if x1 > x2 or y1 > y2:
            return
        bboxptr = (x1, x2, y1, y2)
        comp_rule = TK_PHOTO_COMPOSITE_OVERLAY
    else:
        bboxptr = (0, width, 0, height)
        comp_rule = TK_PHOTO_COMPOSITE_SET
    args = (photoimage, data, offsets, bboxptr, comp_rule)
    argsid = str(id(args))
    _blit_args[argsid] = args
    try:
        photoimage.tk.call(_blit_tcl_name, argsid)
    except tk.TclError as e:
        if 'invalid command name' not in str(e):
            raise
        photoimage.tk.createcommand(_blit_tcl_name, _blit)
        photoimage.tk.call(_blit_tcl_name, argsid)

class TimerTk(TimerBase):

    def __init__(self, parent, *args, **kwargs):
        self._timer = None
        super().__init__(*args, **kwargs)
        self.parent = parent

    def _timer_start(self):
        self._timer_stop()
        self._timer = self.parent.after(self._interval, self._on_timer)

    def _timer_stop(self):
        if self._timer is not None:
            self.parent.after_cancel(self._timer)
        self._timer = None

    def _on_timer(self):
        super()._on_timer()
        if not self._single and self._timer:
            if self._interval > 0:
                self._timer = self.parent.after(self._interval, self._on_timer)
            else:
                self._timer = self.parent.after_idle(lambda : self.parent.after(self._interval, self._on_timer))
        else:
            self._timer = None

class FigureCanvasTk(FigureCanvasBase):
    required_interactive_framework = 'tk'
    manager_class = _api.classproperty(lambda cls: FigureManagerTk)

    def __init__(self, figure=None, master=None):
        super().__init__(figure)
        self._idle_draw_id = None
        self._event_loop_id = None
        (w, h) = self.get_width_height(physical=True)
        self._tkcanvas = tk.Canvas(master=master, background='white', width=w, height=h, borderwidth=0, highlightthickness=0)
        self._tkphoto = tk.PhotoImage(master=self._tkcanvas, width=w, height=h)
        self._tkcanvas_image_region = self._tkcanvas.create_image(w // 2, h // 2, image=self._tkphoto)
        self._tkcanvas.bind('<Configure>', self.resize)
        if sys.platform == 'win32':
            self._tkcanvas.bind('<Map>', self._update_device_pixel_ratio)
        self._tkcanvas.bind('<Key>', self.key_press)
        self._tkcanvas.bind('<Motion>', self.motion_notify_event)
        self._tkcanvas.bind('<Enter>', self.enter_notify_event)
        self._tkcanvas.bind('<Leave>', self.leave_notify_event)
        self._tkcanvas.bind('<KeyRelease>', self.key_release)
        for name in ['<Button-1>', '<Button-2>', '<Button-3>']:
            self._tkcanvas.bind(name, self.button_press_event)
        for name in ['<Double-Button-1>', '<Double-Button-2>', '<Double-Button-3>']:
            self._tkcanvas.bind(name, self.button_dblclick_event)
        for name in ['<ButtonRelease-1>', '<ButtonRelease-2>', '<ButtonRelease-3>']:
            self._tkcanvas.bind(name, self.button_release_event)
        for name in ('<Button-4>', '<Button-5>'):
            self._tkcanvas.bind(name, self.scroll_event)
        root = self._tkcanvas.winfo_toplevel()
        weakself = weakref.ref(self)
        weakroot = weakref.ref(root)

        def scroll_event_windows(event):
            self = weakself()
            if self is None:
                root = weakroot()
                if root is not None:
                    root.unbind('<MouseWheel>', scroll_event_windows_id)
                return
            return self.scroll_event_windows(event)
        scroll_event_windows_id = root.bind('<MouseWheel>', scroll_event_windows, '+')

        def filter_destroy(event):
            self = weakself()
            if self is None:
                root = weakroot()
                if root is not None:
                    root.unbind('<Destroy>', filter_destroy_id)
                return
            if event.widget is self._tkcanvas:
                CloseEvent('close_event', self)._process()
        filter_destroy_id = root.bind('<Destroy>', filter_destroy, '+')
        self._tkcanvas.focus_set()
        self._rubberband_rect_black = None
        self._rubberband_rect_white = None

    def _update_device_pixel_ratio(self, event=None):
        ratio = round(self._tkcanvas.tk.call('tk', 'scaling') / (96 / 72), 2)
        if self._set_device_pixel_ratio(ratio):
            (w, h) = self.get_width_height(physical=True)
            self._tkcanvas.configure(width=w, height=h)

    def resize(self, event):
        (width, height) = (event.width, event.height)
        dpival = self.figure.dpi
        winch = width / dpival
        hinch = height / dpival
        self.figure.set_size_inches(winch, hinch, forward=False)
        self._tkcanvas.delete(self._tkcanvas_image_region)
        self._tkphoto.configure(width=int(width), height=int(height))
        self._tkcanvas_image_region = self._tkcanvas.create_image(int(width / 2), int(height / 2), image=self._tkphoto)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    def draw_idle(self):
        if self._idle_draw_id:
            return

        def idle_draw(*args):
            try:
                self.draw()
            finally:
                self._idle_draw_id = None
        self._idle_draw_id = self._tkcanvas.after_idle(idle_draw)

    def get_tk_widget(self):
        return self._tkcanvas

    def _event_mpl_coords(self, event):
        return (self._tkcanvas.canvasx(event.x), self.figure.bbox.height - self._tkcanvas.canvasy(event.y))

    def motion_notify_event(self, event):
        MouseEvent('motion_notify_event', self, *self._event_mpl_coords(event), modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def enter_notify_event(self, event):
        LocationEvent('figure_enter_event', self, *self._event_mpl_coords(event), modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def leave_notify_event(self, event):
        LocationEvent('figure_leave_event', self, *self._event_mpl_coords(event), modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def button_press_event(self, event, dblclick=False):
        self._tkcanvas.focus_set()
        num = getattr(event, 'num', None)
        if sys.platform == 'darwin':
            num = {2: 3, 3: 2}.get(num, num)
        MouseEvent('button_press_event', self, *self._event_mpl_coords(event), num, dblclick=dblclick, modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def button_dblclick_event(self, event):
        self.button_press_event(event, dblclick=True)

    def button_release_event(self, event):
        num = getattr(event, 'num', None)
        if sys.platform == 'darwin':
            num = {2: 3, 3: 2}.get(num, num)
        MouseEvent('button_release_event', self, *self._event_mpl_coords(event), num, modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def scroll_event(self, event):
        num = getattr(event, 'num', None)
        step = 1 if num == 4 else -1 if num == 5 else 0
        MouseEvent('scroll_event', self, *self._event_mpl_coords(event), step=step, modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def scroll_event_windows(self, event):
        w = event.widget.winfo_containing(event.x_root, event.y_root)
        if w != self._tkcanvas:
            return
        x = self._tkcanvas.canvasx(event.x_root - w.winfo_rootx())
        y = self.figure.bbox.height - self._tkcanvas.canvasy(event.y_root - w.winfo_rooty())
        step = event.delta / 120
        MouseEvent('scroll_event', self, x, y, step=step, modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    @staticmethod
    def _mpl_modifiers(event, *, exclude=None):
        modifiers = [('ctrl', 1 << 2, 'control'), ('alt', 1 << 17, 'alt'), ('shift', 1 << 0, 'shift')] if sys.platform == 'win32' else [('ctrl', 1 << 2, 'control'), ('alt', 1 << 4, 'alt'), ('shift', 1 << 0, 'shift'), ('cmd', 1 << 3, 'cmd')] if sys.platform == 'darwin' else [('ctrl', 1 << 2, 'control'), ('alt', 1 << 3, 'alt'), ('shift', 1 << 0, 'shift'), ('super', 1 << 6, 'super')]
        return [name for (name, mask, key) in modifiers if event.state & mask and exclude != key]

    def _get_key(self, event):
        unikey = event.char
        key = cbook._unikey_or_keysym_to_mplkey(unikey, event.keysym)
        if key is not None:
            mods = self._mpl_modifiers(event, exclude=key)
            if 'shift' in mods and unikey:
                mods.remove('shift')
            return '+'.join([*mods, key])

    def key_press(self, event):
        KeyEvent('key_press_event', self, self._get_key(event), *self._event_mpl_coords(event), guiEvent=event)._process()

    def key_release(self, event):
        KeyEvent('key_release_event', self, self._get_key(event), *self._event_mpl_coords(event), guiEvent=event)._process()

    def new_timer(self, *args, **kwargs):
        return TimerTk(self._tkcanvas, *args, **kwargs)

    def flush_events(self):
        self._tkcanvas.update()

    def start_event_loop(self, timeout=0):
        if timeout > 0:
            milliseconds = int(1000 * timeout)
            if milliseconds > 0:
                self._event_loop_id = self._tkcanvas.after(milliseconds, self.stop_event_loop)
            else:
                self._event_loop_id = self._tkcanvas.after_idle(self.stop_event_loop)
        self._tkcanvas.mainloop()

    def stop_event_loop(self):
        if self._event_loop_id:
            self._tkcanvas.after_cancel(self._event_loop_id)
            self._event_loop_id = None
        self._tkcanvas.quit()

    def set_cursor(self, cursor):
        try:
            self._tkcanvas.configure(cursor=cursord[cursor])
        except tkinter.TclError:
            pass

class FigureManagerTk(FigureManagerBase):
    _owns_mainloop = False

    def __init__(self, canvas, num, window):
        self.window = window
        super().__init__(canvas, num)
        self.window.withdraw()
        self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
        window_frame = int(window.wm_frame(), 16)
        self._window_dpi = tk.IntVar(master=window, value=96, name=f'window_dpi{window_frame}')
        self._window_dpi_cbname = ''
        if _tkagg.enable_dpi_awareness(window_frame, window.tk.interpaddr()):
            self._window_dpi_cbname = self._window_dpi.trace_add('write', self._update_window_dpi)
        self._shown = False

    @classmethod
    def create_with_canvas(cls, canvas_class, figure, num):
        with _restore_foreground_window_at_end():
            if cbook._get_running_interactive_framework() is None:
                cbook._setup_new_guiapp()
                _c_internal_utils.Win32_SetProcessDpiAwareness_max()
            window = tk.Tk(className='matplotlib')
            window.withdraw()
            icon_fname = str(cbook._get_data_path('images/matplotlib.png'))
            icon_img = ImageTk.PhotoImage(file=icon_fname, master=window)
            icon_fname_large = str(cbook._get_data_path('images/matplotlib_large.png'))
            icon_img_large = ImageTk.PhotoImage(file=icon_fname_large, master=window)
            window.iconphoto(False, icon_img_large, icon_img)
            canvas = canvas_class(figure, master=window)
            manager = cls(canvas, num, window)
            if mpl.is_interactive():
                manager.show()
                canvas.draw_idle()
            return manager

    @classmethod
    def start_main_loop(cls):
        managers = Gcf.get_all_fig_managers()
        if managers:
            first_manager = managers[0]
            manager_class = type(first_manager)
            if manager_class._owns_mainloop:
                return
            manager_class._owns_mainloop = True
            try:
                first_manager.window.mainloop()
            finally:
                manager_class._owns_mainloop = False

    def _update_window_dpi(self, *args):
        newdpi = self._window_dpi.get()
        self.window.call('tk', 'scaling', newdpi / 72)
        if self.toolbar and hasattr(self.toolbar, '_rescale'):
            self.toolbar._rescale()
        self.canvas._update_device_pixel_ratio()

    def resize(self, width, height):
        max_size = 1400000
        if (width > max_size or height > max_size) and sys.platform == 'linux':
            raise ValueError(f'You have requested to resize the Tk window to ({width}, {height}), one of which is bigger than {max_size}.  At larger sizes xorg will either exit with an error on newer versions (~1.20) or cause corruption on older version (~1.19).  We do not expect a window over a million pixel wide or tall to be intended behavior.')
        self.canvas._tkcanvas.configure(width=width, height=height)

    def show(self):
        with _restore_foreground_window_at_end():
            if not self._shown:

                def destroy(*args):
                    Gcf.destroy(self)
                self.window.protocol('WM_DELETE_WINDOW', destroy)
                self.window.deiconify()
                self.canvas._tkcanvas.focus_set()
            else:
                self.canvas.draw_idle()
            if mpl.rcParams['figure.raise_window']:
                self.canvas.manager.window.attributes('-topmost', 1)
                self.canvas.manager.window.attributes('-topmost', 0)
            self._shown = True

    def destroy(self, *args):
        if self.canvas._idle_draw_id:
            self.canvas._tkcanvas.after_cancel(self.canvas._idle_draw_id)
        if self.canvas._event_loop_id:
            self.canvas._tkcanvas.after_cancel(self.canvas._event_loop_id)
        if self._window_dpi_cbname:
            self._window_dpi.trace_remove('write', self._window_dpi_cbname)

        def delayed_destroy():
            self.window.destroy()
            if self._owns_mainloop and (not Gcf.get_num_fig_managers()):
                self.window.quit()
        if cbook._get_running_interactive_framework() == 'tk':
            self.window.after_idle(self.window.after, 0, delayed_destroy)
        else:
            self.window.update()
            delayed_destroy()

    def get_window_title(self):
        return self.window.wm_title()

    def set_window_title(self, title):
        self.window.wm_title(title)

    def full_screen_toggle(self):
        is_fullscreen = bool(self.window.attributes('-fullscreen'))
        self.window.attributes('-fullscreen', not is_fullscreen)

class NavigationToolbar2Tk(NavigationToolbar2, tk.Frame):

    def __init__(self, canvas, window=None, *, pack_toolbar=True):
        if window is None:
            window = canvas.get_tk_widget().master
        tk.Frame.__init__(self, master=window, borderwidth=2, width=int(canvas.figure.bbox.width), height=50)
        self._buttons = {}
        for (text, tooltip_text, image_file, callback) in self.toolitems:
            if text is None:
                self._Spacer()
            else:
                self._buttons[text] = button = self._Button(text, str(cbook._get_data_path(f'images/{image_file}.png')), toggle=callback in ['zoom', 'pan'], command=getattr(self, callback))
                if tooltip_text is not None:
                    add_tooltip(button, tooltip_text)
        self._label_font = tkinter.font.Font(root=window, size=10)
        label = tk.Label(master=self, font=self._label_font, text='\xa0\n\xa0')
        label.pack(side=tk.RIGHT)
        self.message = tk.StringVar(master=self)
        self._message_label = tk.Label(master=self, font=self._label_font, textvariable=self.message, justify=tk.RIGHT)
        self._message_label.pack(side=tk.RIGHT)
        NavigationToolbar2.__init__(self, canvas)
        if pack_toolbar:
            self.pack(side=tk.BOTTOM, fill=tk.X)

    def _rescale(self):
        for widget in self.winfo_children():
            if isinstance(widget, (tk.Button, tk.Checkbutton)):
                if hasattr(widget, '_image_file'):
                    NavigationToolbar2Tk._set_image_for_button(self, widget)
                else:
                    pass
            elif isinstance(widget, tk.Frame):
                widget.configure(height='18p')
                widget.pack_configure(padx='3p')
            elif isinstance(widget, tk.Label):
                pass
            else:
                _log.warning('Unknown child class %s', widget.winfo_class)
        self._label_font.configure(size=10)

    def _update_buttons_checked(self):
        for (text, mode) in [('Zoom', _Mode.ZOOM), ('Pan', _Mode.PAN)]:
            if text in self._buttons:
                if self.mode == mode:
                    self._buttons[text].select()
                else:
                    self._buttons[text].deselect()

    def pan(self, *args):
        super().pan(*args)
        self._update_buttons_checked()

    def zoom(self, *args):
        super().zoom(*args)
        self._update_buttons_checked()

    def set_message(self, s):
        self.message.set(s)

    def draw_rubberband(self, event, x0, y0, x1, y1):
        if self.canvas._rubberband_rect_white:
            self.canvas._tkcanvas.delete(self.canvas._rubberband_rect_white)
        if self.canvas._rubberband_rect_black:
            self.canvas._tkcanvas.delete(self.canvas._rubberband_rect_black)
        height = self.canvas.figure.bbox.height
        y0 = height - y0
        y1 = height - y1
        self.canvas._rubberband_rect_black = self.canvas._tkcanvas.create_rectangle(x0, y0, x1, y1)
        self.canvas._rubberband_rect_white = self.canvas._tkcanvas.create_rectangle(x0, y0, x1, y1, outline='white', dash=(3, 3))

    def remove_rubberband(self):
        if self.canvas._rubberband_rect_white:
            self.canvas._tkcanvas.delete(self.canvas._rubberband_rect_white)
            self.canvas._rubberband_rect_white = None
        if self.canvas._rubberband_rect_black:
            self.canvas._tkcanvas.delete(self.canvas._rubberband_rect_black)
            self.canvas._rubberband_rect_black = None

    def _set_image_for_button(self, button):
        if button._image_file is None:
            return
        path_regular = cbook._get_data_path('images', button._image_file)
        path_large = path_regular.with_name(path_regular.name.replace('.png', '_large.png'))
        size = button.winfo_pixels('18p')

        def _get_color(color_name):
            return button.winfo_rgb(button.cget(color_name))

        def _is_dark(color):
            if isinstance(color, str):
                color = _get_color(color)
            return max(color) < 65535 / 2

        def _recolor_icon(image, color):
            image_data = np.asarray(image).copy()
            black_mask = (image_data[..., :3] == 0).all(axis=-1)
            image_data[black_mask, :3] = color
            return Image.fromarray(image_data, mode='RGBA')
        with Image.open(path_large if size > 24 and path_large.exists() else path_regular) as im:
            im = im.convert('RGBA')
            image = ImageTk.PhotoImage(im.resize((size, size)), master=self)
            button._ntimage = image
            foreground = 255 / 65535 * np.array(button.winfo_rgb(button.cget('foreground')))
            im_alt = _recolor_icon(im, foreground)
            image_alt = ImageTk.PhotoImage(im_alt.resize((size, size)), master=self)
            button._ntimage_alt = image_alt
        if _is_dark('background'):
            image_kwargs = {'image': image_alt}
        else:
            image_kwargs = {'image': image}
        if isinstance(button, tk.Checkbutton) and button.cget('selectcolor') != '':
            if self._windowingsystem != 'x11':
                selectcolor = 'selectcolor'
            else:
                (r1, g1, b1) = _get_color('selectcolor')
                (r2, g2, b2) = _get_color('activebackground')
                selectcolor = ((r1 + r2) / 2, (g1 + g2) / 2, (b1 + b2) / 2)
            if _is_dark(selectcolor):
                image_kwargs['selectimage'] = image_alt
            else:
                image_kwargs['selectimage'] = image
        button.configure(**image_kwargs, height='18p', width='18p')

    def _Button(self, text, image_file, toggle, command):
        if not toggle:
            b = tk.Button(master=self, text=text, command=command, relief='flat', overrelief='groove', borderwidth=1)
        else:
            var = tk.IntVar(master=self)
            b = tk.Checkbutton(master=self, text=text, command=command, indicatoron=False, variable=var, offrelief='flat', overrelief='groove', borderwidth=1)
            b.var = var
        b._image_file = image_file
        if image_file is not None:
            NavigationToolbar2Tk._set_image_for_button(self, b)
        else:
            b.configure(font=self._label_font)
        b.pack(side=tk.LEFT)
        return b

    def _Spacer(self):
        s = tk.Frame(master=self, height='18p', relief=tk.RIDGE, bg='DarkGray')
        s.pack(side=tk.LEFT, padx='3p')
        return s

    def save_figure(self, *args):
        filetypes = self.canvas.get_supported_filetypes_grouped()
        tk_filetypes = [(name, ' '.join((f'*.{ext}' for ext in exts))) for (name, exts) in sorted(filetypes.items())]
        default_extension = self.canvas.get_default_filetype()
        default_filetype = self.canvas.get_supported_filetypes()[default_extension]
        filetype_variable = tk.StringVar(self.canvas.get_tk_widget(), default_filetype)
        defaultextension = ''
        initialdir = os.path.expanduser(mpl.rcParams['savefig.directory'])
        initialfile = pathlib.Path(self.canvas.get_default_filename()).stem
        fname = tkinter.filedialog.asksaveasfilename(master=self.canvas.get_tk_widget().master, title='Save the figure', filetypes=tk_filetypes, defaultextension=defaultextension, initialdir=initialdir, initialfile=initialfile, typevariable=filetype_variable)
        if fname in ['', ()]:
            return
        if initialdir != '':
            mpl.rcParams['savefig.directory'] = os.path.dirname(str(fname))
        if pathlib.Path(fname).suffix[1:] != '':
            extension = None
        else:
            extension = filetypes[filetype_variable.get()][0]
        try:
            self.canvas.figure.savefig(fname, format=extension)
        except Exception as e:
            tkinter.messagebox.showerror('Error saving file', str(e))

    def set_history_buttons(self):
        state_map = {True: tk.NORMAL, False: tk.DISABLED}
        can_back = self._nav_stack._pos > 0
        can_forward = self._nav_stack._pos < len(self._nav_stack) - 1
        if 'Back' in self._buttons:
            self._buttons['Back']['state'] = state_map[can_back]
        if 'Forward' in self._buttons:
            self._buttons['Forward']['state'] = state_map[can_forward]

def add_tooltip(widget, text):
    tipwindow = None

    def showtip(event):
        nonlocal tipwindow
        if tipwindow or not text:
            return
        (x, y, _, _) = widget.bbox('insert')
        x = x + widget.winfo_rootx() + widget.winfo_width()
        y = y + widget.winfo_rooty()
        tipwindow = tk.Toplevel(widget)
        tipwindow.overrideredirect(1)
        tipwindow.geometry(f'+{x}+{y}')
        try:
            tipwindow.tk.call('::tk::unsupported::MacWindowStyle', 'style', tipwindow._w, 'help', 'noActivates')
        except tk.TclError:
            pass
        label = tk.Label(tipwindow, text=text, justify=tk.LEFT, relief=tk.SOLID, borderwidth=1)
        label.pack(ipadx=1)

    def hidetip(event):
        nonlocal tipwindow
        if tipwindow:
            tipwindow.destroy()
        tipwindow = None
    widget.bind('<Enter>', showtip)
    widget.bind('<Leave>', hidetip)

@backend_tools._register_tool_class(FigureCanvasTk)
class RubberbandTk(backend_tools.RubberbandBase):

    def draw_rubberband(self, x0, y0, x1, y1):
        NavigationToolbar2Tk.draw_rubberband(self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)

    def remove_rubberband(self):
        NavigationToolbar2Tk.remove_rubberband(self._make_classic_style_pseudo_toolbar())

class ToolbarTk(ToolContainerBase, tk.Frame):

    def __init__(self, toolmanager, window=None):
        ToolContainerBase.__init__(self, toolmanager)
        if window is None:
            window = self.toolmanager.canvas.get_tk_widget().master
        (xmin, xmax) = self.toolmanager.canvas.figure.bbox.intervalx
        (height, width) = (50, xmax - xmin)
        tk.Frame.__init__(self, master=window, width=int(width), height=int(height), borderwidth=2)
        self._label_font = tkinter.font.Font(size=10)
        label = tk.Label(master=self, font=self._label_font, text='\xa0\n\xa0')
        label.pack(side=tk.RIGHT)
        self._message = tk.StringVar(master=self)
        self._message_label = tk.Label(master=self, font=self._label_font, textvariable=self._message)
        self._message_label.pack(side=tk.RIGHT)
        self._toolitems = {}
        self.pack(side=tk.TOP, fill=tk.X)
        self._groups = {}

    def _rescale(self):
        return NavigationToolbar2Tk._rescale(self)

    def add_toolitem(self, name, group, position, image_file, description, toggle):
        frame = self._get_groupframe(group)
        buttons = frame.pack_slaves()
        if position >= len(buttons) or position < 0:
            before = None
        else:
            before = buttons[position]
        button = NavigationToolbar2Tk._Button(frame, name, image_file, toggle, lambda : self._button_click(name))
        button.pack_configure(before=before)
        if description is not None:
            add_tooltip(button, description)
        self._toolitems.setdefault(name, [])
        self._toolitems[name].append(button)

    def _get_groupframe(self, group):
        if group not in self._groups:
            if self._groups:
                self._add_separator()
            frame = tk.Frame(master=self, borderwidth=0)
            frame.pack(side=tk.LEFT, fill=tk.Y)
            frame._label_font = self._label_font
            self._groups[group] = frame
        return self._groups[group]

    def _add_separator(self):
        return NavigationToolbar2Tk._Spacer(self)

    def _button_click(self, name):
        self.trigger_tool(name)

    def toggle_toolitem(self, name, toggled):
        if name not in self._toolitems:
            return
        for toolitem in self._toolitems[name]:
            if toggled:
                toolitem.select()
            else:
                toolitem.deselect()

    def remove_toolitem(self, name):
        for toolitem in self._toolitems.pop(name, []):
            toolitem.pack_forget()

    def set_message(self, s):
        self._message.set(s)

@backend_tools._register_tool_class(FigureCanvasTk)
class SaveFigureTk(backend_tools.SaveFigureBase):

    def trigger(self, *args):
        NavigationToolbar2Tk.save_figure(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(FigureCanvasTk)
class ConfigureSubplotsTk(backend_tools.ConfigureSubplotsBase):

    def trigger(self, *args):
        NavigationToolbar2Tk.configure_subplots(self)

@backend_tools._register_tool_class(FigureCanvasTk)
class HelpTk(backend_tools.ToolHelpBase):

    def trigger(self, *args):
        dialog = SimpleDialog(self.figure.canvas._tkcanvas, self._get_help_text(), ['OK'])
        dialog.done = lambda num: dialog.frame.master.withdraw()
Toolbar = ToolbarTk
FigureManagerTk._toolbar2_class = NavigationToolbar2Tk
FigureManagerTk._toolmanager_toolbar_class = ToolbarTk

@_Backend.export
class _BackendTk(_Backend):
    backend_version = tk.TkVersion
    FigureCanvas = FigureCanvasTk
    FigureManager = FigureManagerTk
    mainloop = FigureManagerTk.start_main_loop

# File: matplotlib-main/lib/matplotlib/backends/backend_agg.py
""""""
from contextlib import nullcontext
from math import radians, cos, sin
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, RendererBase
from matplotlib.font_manager import fontManager as _fontManager, get_font
from matplotlib.ft2font import LOAD_FORCE_AUTOHINT, LOAD_NO_HINTING, LOAD_DEFAULT, LOAD_NO_AUTOHINT
from matplotlib.mathtext import MathTextParser
from matplotlib.path import Path
from matplotlib.transforms import Bbox, BboxBase
from matplotlib.backends._backend_agg import RendererAgg as _RendererAgg

def get_hinting_flag():
    mapping = {'default': LOAD_DEFAULT, 'no_autohint': LOAD_NO_AUTOHINT, 'force_autohint': LOAD_FORCE_AUTOHINT, 'no_hinting': LOAD_NO_HINTING, True: LOAD_FORCE_AUTOHINT, False: LOAD_NO_HINTING, 'either': LOAD_DEFAULT, 'native': LOAD_NO_AUTOHINT, 'auto': LOAD_FORCE_AUTOHINT, 'none': LOAD_NO_HINTING}
    return mapping[mpl.rcParams['text.hinting']]

class RendererAgg(RendererBase):

    def __init__(self, width, height, dpi):
        super().__init__()
        self.dpi = dpi
        self.width = width
        self.height = height
        self._renderer = _RendererAgg(int(width), int(height), dpi)
        self._filter_renderers = []
        self._update_methods()
        self.mathtext_parser = MathTextParser('agg')
        self.bbox = Bbox.from_bounds(0, 0, self.width, self.height)

    def __getstate__(self):
        return {'width': self.width, 'height': self.height, 'dpi': self.dpi}

    def __setstate__(self, state):
        self.__init__(state['width'], state['height'], state['dpi'])

    def _update_methods(self):
        self.draw_gouraud_triangles = self._renderer.draw_gouraud_triangles
        self.draw_image = self._renderer.draw_image
        self.draw_markers = self._renderer.draw_markers
        self.draw_path_collection = self._renderer.draw_path_collection
        self.draw_quad_mesh = self._renderer.draw_quad_mesh
        self.copy_from_bbox = self._renderer.copy_from_bbox

    def draw_path(self, gc, path, transform, rgbFace=None):
        nmax = mpl.rcParams['agg.path.chunksize']
        npts = path.vertices.shape[0]
        if npts > nmax > 100 and path.should_simplify and (rgbFace is None) and (gc.get_hatch() is None):
            nch = np.ceil(npts / nmax)
            chsize = int(np.ceil(npts / nch))
            i0 = np.arange(0, npts, chsize)
            i1 = np.zeros_like(i0)
            i1[:-1] = i0[1:] - 1
            i1[-1] = npts
            for (ii0, ii1) in zip(i0, i1):
                v = path.vertices[ii0:ii1, :]
                c = path.codes
                if c is not None:
                    c = c[ii0:ii1]
                    c[0] = Path.MOVETO
                p = Path(v, c)
                p.simplify_threshold = path.simplify_threshold
                try:
                    self._renderer.draw_path(gc, p, transform, rgbFace)
                except OverflowError:
                    msg = f"Exceeded cell block limit in Agg.\n\nPlease reduce the value of rcParams['agg.path.chunksize'] (currently {nmax}) or increase the path simplification threshold(rcParams['path.simplify_threshold'] = {mpl.rcParams['path.simplify_threshold']:.2f} by default and path.simplify_threshold = {path.simplify_threshold:.2f} on the input)."
                    raise OverflowError(msg) from None
        else:
            try:
                self._renderer.draw_path(gc, path, transform, rgbFace)
            except OverflowError:
                cant_chunk = ''
                if rgbFace is not None:
                    cant_chunk += '- cannot split filled path\n'
                if gc.get_hatch() is not None:
                    cant_chunk += '- cannot split hatched path\n'
                if not path.should_simplify:
                    cant_chunk += '- path.should_simplify is False\n'
                if len(cant_chunk):
                    msg = f'Exceeded cell block limit in Agg, however for the following reasons:\n\n{cant_chunk}\nwe cannot automatically split up this path to draw.\n\nPlease manually simplify your path.'
                else:
                    inc_threshold = f"or increase the path simplification threshold(rcParams['path.simplify_threshold'] = {mpl.rcParams['path.simplify_threshold']} by default and path.simplify_threshold = {path.simplify_threshold} on the input)."
                    if nmax > 100:
                        msg = f"Exceeded cell block limit in Agg.  Please reduce the value of rcParams['agg.path.chunksize'] (currently {nmax}) {inc_threshold}"
                    else:
                        msg = f"Exceeded cell block limit in Agg.  Please set the value of rcParams['agg.path.chunksize'], (currently {nmax}) to be greater than 100 " + inc_threshold
                raise OverflowError(msg) from None

    def draw_mathtext(self, gc, x, y, s, prop, angle):
        (ox, oy, width, height, descent, font_image) = self.mathtext_parser.parse(s, self.dpi, prop, antialiased=gc.get_antialiased())
        xd = descent * sin(radians(angle))
        yd = descent * cos(radians(angle))
        x = round(x + ox + xd)
        y = round(y - oy + yd)
        self._renderer.draw_text_image(font_image, x, y + 1, angle, gc)

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        if ismath:
            return self.draw_mathtext(gc, x, y, s, prop, angle)
        font = self._prepare_font(prop)
        font.set_text(s, 0, flags=get_hinting_flag())
        font.draw_glyphs_to_bitmap(antialiased=gc.get_antialiased())
        d = font.get_descent() / 64.0
        (xo, yo) = font.get_bitmap_offset()
        xo /= 64.0
        yo /= 64.0
        xd = d * sin(radians(angle))
        yd = d * cos(radians(angle))
        x = round(x + xo + xd)
        y = round(y + yo + yd)
        self._renderer.draw_text_image(font, x, y + 1, angle, gc)

    def get_text_width_height_descent(self, s, prop, ismath):
        _api.check_in_list(['TeX', True, False], ismath=ismath)
        if ismath == 'TeX':
            return super().get_text_width_height_descent(s, prop, ismath)
        if ismath:
            (ox, oy, width, height, descent, font_image) = self.mathtext_parser.parse(s, self.dpi, prop)
            return (width, height, descent)
        font = self._prepare_font(prop)
        font.set_text(s, 0.0, flags=get_hinting_flag())
        (w, h) = font.get_width_height()
        d = font.get_descent()
        w /= 64.0
        h /= 64.0
        d /= 64.0
        return (w, h, d)

    def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
        size = prop.get_size_in_points()
        texmanager = self.get_texmanager()
        Z = texmanager.get_grey(s, size, self.dpi)
        Z = np.array(Z * 255.0, np.uint8)
        (w, h, d) = self.get_text_width_height_descent(s, prop, ismath='TeX')
        xd = d * sin(radians(angle))
        yd = d * cos(radians(angle))
        x = round(x + xd)
        y = round(y + yd)
        self._renderer.draw_text_image(Z, x, y, angle, gc)

    def get_canvas_width_height(self):
        return (self.width, self.height)

    def _prepare_font(self, font_prop):
        font = get_font(_fontManager._find_fonts_by_props(font_prop))
        font.clear()
        size = font_prop.get_size_in_points()
        font.set_size(size, self.dpi)
        return font

    def points_to_pixels(self, points):
        return points * self.dpi / 72

    def buffer_rgba(self):
        return memoryview(self._renderer)

    def tostring_argb(self):
        return np.asarray(self._renderer).take([3, 0, 1, 2], axis=2).tobytes()

    @_api.deprecated('3.8', alternative='buffer_rgba')
    def tostring_rgb(self):
        return np.asarray(self._renderer).take([0, 1, 2], axis=2).tobytes()

    def clear(self):
        self._renderer.clear()

    def option_image_nocomposite(self):
        return True

    def option_scale_image(self):
        return False

    def restore_region(self, region, bbox=None, xy=None):
        if bbox is not None or xy is not None:
            if bbox is None:
                (x1, y1, x2, y2) = region.get_extents()
            elif isinstance(bbox, BboxBase):
                (x1, y1, x2, y2) = bbox.extents
            else:
                (x1, y1, x2, y2) = bbox
            if xy is None:
                (ox, oy) = (x1, y1)
            else:
                (ox, oy) = xy
            self._renderer.restore_region(region, int(x1), int(y1), int(x2), int(y2), int(ox), int(oy))
        else:
            self._renderer.restore_region(region)

    def start_filter(self):
        self._filter_renderers.append(self._renderer)
        self._renderer = _RendererAgg(int(self.width), int(self.height), self.dpi)
        self._update_methods()

    def stop_filter(self, post_processing):
        orig_img = np.asarray(self.buffer_rgba())
        (slice_y, slice_x) = cbook._get_nonzero_slices(orig_img[..., 3])
        cropped_img = orig_img[slice_y, slice_x]
        self._renderer = self._filter_renderers.pop()
        self._update_methods()
        if cropped_img.size:
            (img, ox, oy) = post_processing(cropped_img / 255, self.dpi)
            gc = self.new_gc()
            if img.dtype.kind == 'f':
                img = np.asarray(img * 255.0, np.uint8)
            self._renderer.draw_image(gc, slice_x.start + ox, int(self.height) - slice_y.stop + oy, img[::-1])

class FigureCanvasAgg(FigureCanvasBase):
    _lastKey = None

    def copy_from_bbox(self, bbox):
        renderer = self.get_renderer()
        return renderer.copy_from_bbox(bbox)

    def restore_region(self, region, bbox=None, xy=None):
        renderer = self.get_renderer()
        return renderer.restore_region(region, bbox, xy)

    def draw(self):
        self.renderer = self.get_renderer()
        self.renderer.clear()
        with self.toolbar._wait_cursor_for_draw_cm() if self.toolbar else nullcontext():
            self.figure.draw(self.renderer)
            super().draw()

    def get_renderer(self):
        (w, h) = self.figure.bbox.size
        key = (w, h, self.figure.dpi)
        reuse_renderer = self._lastKey == key
        if not reuse_renderer:
            self.renderer = RendererAgg(w, h, self.figure.dpi)
            self._lastKey = key
        return self.renderer

    @_api.deprecated('3.8', alternative='buffer_rgba')
    def tostring_rgb(self):
        return self.renderer.tostring_rgb()

    def tostring_argb(self):
        return self.renderer.tostring_argb()

    def buffer_rgba(self):
        return self.renderer.buffer_rgba()

    def print_raw(self, filename_or_obj, *, metadata=None):
        if metadata is not None:
            raise ValueError('metadata not supported for raw/rgba')
        FigureCanvasAgg.draw(self)
        renderer = self.get_renderer()
        with cbook.open_file_cm(filename_or_obj, 'wb') as fh:
            fh.write(renderer.buffer_rgba())
    print_rgba = print_raw

    def _print_pil(self, filename_or_obj, fmt, pil_kwargs, metadata=None):
        FigureCanvasAgg.draw(self)
        mpl.image.imsave(filename_or_obj, self.buffer_rgba(), format=fmt, origin='upper', dpi=self.figure.dpi, metadata=metadata, pil_kwargs=pil_kwargs)

    def print_png(self, filename_or_obj, *, metadata=None, pil_kwargs=None):
        self._print_pil(filename_or_obj, 'png', pil_kwargs, metadata)

    def print_to_buffer(self):
        FigureCanvasAgg.draw(self)
        renderer = self.get_renderer()
        return (bytes(renderer.buffer_rgba()), (int(renderer.width), int(renderer.height)))

    def print_jpg(self, filename_or_obj, *, metadata=None, pil_kwargs=None):
        with mpl.rc_context({'savefig.facecolor': 'white'}):
            self._print_pil(filename_or_obj, 'jpeg', pil_kwargs, metadata)
    print_jpeg = print_jpg

    def print_tif(self, filename_or_obj, *, metadata=None, pil_kwargs=None):
        self._print_pil(filename_or_obj, 'tiff', pil_kwargs, metadata)
    print_tiff = print_tif

    def print_webp(self, filename_or_obj, *, metadata=None, pil_kwargs=None):
        self._print_pil(filename_or_obj, 'webp', pil_kwargs, metadata)
    (print_jpg.__doc__, print_tif.__doc__, print_webp.__doc__) = map('\n        Write the figure to a {} file.\n\n        Parameters\n        ----------\n        filename_or_obj : str or path-like or file-like\n            The file to write to.\n        pil_kwargs : dict, optional\n            Additional keyword arguments that are passed to\n            `PIL.Image.Image.save` when saving the figure.\n        '.format, ['JPEG', 'TIFF', 'WebP'])

@_Backend.export
class _BackendAgg(_Backend):
    backend_version = 'v2.2'
    FigureCanvas = FigureCanvasAgg
    FigureManager = FigureManagerBase

# File: matplotlib-main/lib/matplotlib/backends/backend_cairo.py
""""""
import functools
import gzip
import math
import numpy as np
try:
    import cairo
    if cairo.version_info < (1, 14, 0):
        raise ImportError(f'Cairo backend requires cairo>=1.14.0, but only {cairo.version_info} is available')
except ImportError:
    try:
        import cairocffi as cairo
    except ImportError as err:
        raise ImportError('cairo backend requires that pycairo>=1.14.0 or cairocffi is installed') from err
from .. import _api, cbook, font_manager
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase, RendererBase
from matplotlib.font_manager import ttfFontProperty
from matplotlib.path import Path
from matplotlib.transforms import Affine2D

def _set_rgba(ctx, color, alpha, forced_alpha):
    if len(color) == 3 or forced_alpha:
        ctx.set_source_rgba(*color[:3], alpha)
    else:
        ctx.set_source_rgba(*color)

def _append_path(ctx, path, transform, clip=None):
    for (points, code) in path.iter_segments(transform, remove_nans=True, clip=clip):
        if code == Path.MOVETO:
            ctx.move_to(*points)
        elif code == Path.CLOSEPOLY:
            ctx.close_path()
        elif code == Path.LINETO:
            ctx.line_to(*points)
        elif code == Path.CURVE3:
            cur = np.asarray(ctx.get_current_point())
            a = points[:2]
            b = points[-2:]
            ctx.curve_to(*cur / 3 + a * 2 / 3, *a * 2 / 3 + b / 3, *b)
        elif code == Path.CURVE4:
            ctx.curve_to(*points)

def _cairo_font_args_from_font_prop(prop):

    def attr(field):
        try:
            return getattr(prop, f'get_{field}')()
        except AttributeError:
            return getattr(prop, field)
    name = attr('name')
    slant = getattr(cairo, f"FONT_SLANT_{attr('style').upper()}")
    weight = attr('weight')
    weight = cairo.FONT_WEIGHT_NORMAL if font_manager.weight_dict.get(weight, weight) < 550 else cairo.FONT_WEIGHT_BOLD
    return (name, slant, weight)

class RendererCairo(RendererBase):

    def __init__(self, dpi):
        self.dpi = dpi
        self.gc = GraphicsContextCairo(renderer=self)
        self.width = None
        self.height = None
        self.text_ctx = cairo.Context(cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1))
        super().__init__()

    def set_context(self, ctx):
        surface = ctx.get_target()
        if hasattr(surface, 'get_width') and hasattr(surface, 'get_height'):
            size = (surface.get_width(), surface.get_height())
        elif hasattr(surface, 'get_extents'):
            ext = surface.get_extents()
            size = (ext.width, ext.height)
        else:
            ctx.save()
            ctx.reset_clip()
            (rect, *rest) = ctx.copy_clip_rectangle_list()
            if rest:
                raise TypeError('Cannot infer surface size')
            (_, _, *size) = rect
            ctx.restore()
        self.gc.ctx = ctx
        (self.width, self.height) = size

    @staticmethod
    def _fill_and_stroke(ctx, fill_c, alpha, alpha_overrides):
        if fill_c is not None:
            ctx.save()
            _set_rgba(ctx, fill_c, alpha, alpha_overrides)
            ctx.fill_preserve()
            ctx.restore()
        ctx.stroke()

    def draw_path(self, gc, path, transform, rgbFace=None):
        ctx = gc.ctx
        clip = ctx.clip_extents() if rgbFace is None and gc.get_hatch() is None else None
        transform = transform + Affine2D().scale(1, -1).translate(0, self.height)
        ctx.new_path()
        _append_path(ctx, path, transform, clip)
        if rgbFace is not None:
            ctx.save()
            _set_rgba(ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
            ctx.fill_preserve()
            ctx.restore()
        hatch_path = gc.get_hatch_path()
        if hatch_path:
            dpi = int(self.dpi)
            hatch_surface = ctx.get_target().create_similar(cairo.Content.COLOR_ALPHA, dpi, dpi)
            hatch_ctx = cairo.Context(hatch_surface)
            _append_path(hatch_ctx, hatch_path, Affine2D().scale(dpi, -dpi).translate(0, dpi), None)
            hatch_ctx.set_line_width(self.points_to_pixels(gc.get_hatch_linewidth()))
            hatch_ctx.set_source_rgba(*gc.get_hatch_color())
            hatch_ctx.fill_preserve()
            hatch_ctx.stroke()
            hatch_pattern = cairo.SurfacePattern(hatch_surface)
            hatch_pattern.set_extend(cairo.Extend.REPEAT)
            ctx.save()
            ctx.set_source(hatch_pattern)
            ctx.fill_preserve()
            ctx.restore()
        ctx.stroke()

    def draw_markers(self, gc, marker_path, marker_trans, path, transform, rgbFace=None):
        ctx = gc.ctx
        ctx.new_path()
        _append_path(ctx, marker_path, marker_trans + Affine2D().scale(1, -1))
        marker_path = ctx.copy_path_flat()
        (x1, y1, x2, y2) = ctx.fill_extents()
        if x1 == 0 and y1 == 0 and (x2 == 0) and (y2 == 0):
            filled = False
            rgbFace = None
        else:
            filled = True
        transform = transform + Affine2D().scale(1, -1).translate(0, self.height)
        ctx.new_path()
        for (i, (vertices, codes)) in enumerate(path.iter_segments(transform, simplify=False)):
            if len(vertices):
                (x, y) = vertices[-2:]
                ctx.save()
                ctx.translate(x, y)
                ctx.append_path(marker_path)
                ctx.restore()
                if filled or i % 1000 == 0:
                    self._fill_and_stroke(ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
        if not filled:
            self._fill_and_stroke(ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())

    def draw_image(self, gc, x, y, im):
        im = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(im[::-1])
        surface = cairo.ImageSurface.create_for_data(im.ravel().data, cairo.FORMAT_ARGB32, im.shape[1], im.shape[0], im.shape[1] * 4)
        ctx = gc.ctx
        y = self.height - y - im.shape[0]
        ctx.save()
        ctx.set_source_surface(surface, float(x), float(y))
        ctx.paint()
        ctx.restore()

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        if ismath:
            self._draw_mathtext(gc, x, y, s, prop, angle)
        else:
            ctx = gc.ctx
            ctx.new_path()
            ctx.move_to(x, y)
            ctx.save()
            ctx.select_font_face(*_cairo_font_args_from_font_prop(prop))
            ctx.set_font_size(self.points_to_pixels(prop.get_size_in_points()))
            opts = cairo.FontOptions()
            opts.set_antialias(gc.get_antialiased())
            ctx.set_font_options(opts)
            if angle:
                ctx.rotate(np.deg2rad(-angle))
            ctx.show_text(s)
            ctx.restore()

    def _draw_mathtext(self, gc, x, y, s, prop, angle):
        ctx = gc.ctx
        (width, height, descent, glyphs, rects) = self._text2path.mathtext_parser.parse(s, self.dpi, prop)
        ctx.save()
        ctx.translate(x, y)
        if angle:
            ctx.rotate(np.deg2rad(-angle))
        for (font, fontsize, idx, ox, oy) in glyphs:
            ctx.new_path()
            ctx.move_to(ox, -oy)
            ctx.select_font_face(*_cairo_font_args_from_font_prop(ttfFontProperty(font)))
            ctx.set_font_size(self.points_to_pixels(fontsize))
            ctx.show_text(chr(idx))
        for (ox, oy, w, h) in rects:
            ctx.new_path()
            ctx.rectangle(ox, -oy, w, -h)
            ctx.set_source_rgb(0, 0, 0)
            ctx.fill_preserve()
        ctx.restore()

    def get_canvas_width_height(self):
        return (self.width, self.height)

    def get_text_width_height_descent(self, s, prop, ismath):
        if ismath == 'TeX':
            return super().get_text_width_height_descent(s, prop, ismath)
        if ismath:
            (width, height, descent, *_) = self._text2path.mathtext_parser.parse(s, self.dpi, prop)
            return (width, height, descent)
        ctx = self.text_ctx
        ctx.save()
        ctx.select_font_face(*_cairo_font_args_from_font_prop(prop))
        ctx.set_font_size(self.points_to_pixels(prop.get_size_in_points()))
        (y_bearing, w, h) = ctx.text_extents(s)[1:4]
        ctx.restore()
        return (w, h, h + y_bearing)

    def new_gc(self):
        self.gc.ctx.save()
        self.gc._alpha = 1
        self.gc._forced_alpha = False
        self.gc._hatch = None
        return self.gc

    def points_to_pixels(self, points):
        return points / 72 * self.dpi

class GraphicsContextCairo(GraphicsContextBase):
    _joind = {'bevel': cairo.LINE_JOIN_BEVEL, 'miter': cairo.LINE_JOIN_MITER, 'round': cairo.LINE_JOIN_ROUND}
    _capd = {'butt': cairo.LINE_CAP_BUTT, 'projecting': cairo.LINE_CAP_SQUARE, 'round': cairo.LINE_CAP_ROUND}

    def __init__(self, renderer):
        super().__init__()
        self.renderer = renderer

    def restore(self):
        self.ctx.restore()

    def set_alpha(self, alpha):
        super().set_alpha(alpha)
        _set_rgba(self.ctx, self._rgb, self.get_alpha(), self.get_forced_alpha())

    def set_antialiased(self, b):
        self.ctx.set_antialias(cairo.ANTIALIAS_DEFAULT if b else cairo.ANTIALIAS_NONE)

    def get_antialiased(self):
        return self.ctx.get_antialias()

    def set_capstyle(self, cs):
        self.ctx.set_line_cap(_api.check_getitem(self._capd, capstyle=cs))
        self._capstyle = cs

    def set_clip_rectangle(self, rectangle):
        if not rectangle:
            return
        (x, y, w, h) = np.round(rectangle.bounds)
        ctx = self.ctx
        ctx.new_path()
        ctx.rectangle(x, self.renderer.height - h - y, w, h)
        ctx.clip()

    def set_clip_path(self, path):
        if not path:
            return
        (tpath, affine) = path.get_transformed_path_and_affine()
        ctx = self.ctx
        ctx.new_path()
        affine = affine + Affine2D().scale(1, -1).translate(0, self.renderer.height)
        _append_path(ctx, tpath, affine)
        ctx.clip()

    def set_dashes(self, offset, dashes):
        self._dashes = (offset, dashes)
        if dashes is None:
            self.ctx.set_dash([], 0)
        else:
            self.ctx.set_dash(list(self.renderer.points_to_pixels(np.asarray(dashes))), offset)

    def set_foreground(self, fg, isRGBA=None):
        super().set_foreground(fg, isRGBA)
        if len(self._rgb) == 3:
            self.ctx.set_source_rgb(*self._rgb)
        else:
            self.ctx.set_source_rgba(*self._rgb)

    def get_rgb(self):
        return self.ctx.get_source().get_rgba()[:3]

    def set_joinstyle(self, js):
        self.ctx.set_line_join(_api.check_getitem(self._joind, joinstyle=js))
        self._joinstyle = js

    def set_linewidth(self, w):
        self._linewidth = float(w)
        self.ctx.set_line_width(self.renderer.points_to_pixels(w))

class _CairoRegion:

    def __init__(self, slices, data):
        self._slices = slices
        self._data = data

class FigureCanvasCairo(FigureCanvasBase):

    @property
    def _renderer(self):
        if not hasattr(self, '_cached_renderer'):
            self._cached_renderer = RendererCairo(self.figure.dpi)
        return self._cached_renderer

    def get_renderer(self):
        return self._renderer

    def copy_from_bbox(self, bbox):
        surface = self._renderer.gc.ctx.get_target()
        if not isinstance(surface, cairo.ImageSurface):
            raise RuntimeError('copy_from_bbox only works when rendering to an ImageSurface')
        sw = surface.get_width()
        sh = surface.get_height()
        x0 = math.ceil(bbox.x0)
        x1 = math.floor(bbox.x1)
        y0 = math.ceil(sh - bbox.y1)
        y1 = math.floor(sh - bbox.y0)
        if not (0 <= x0 and x1 <= sw and (bbox.x0 <= bbox.x1) and (0 <= y0) and (y1 <= sh) and (bbox.y0 <= bbox.y1)):
            raise ValueError('Invalid bbox')
        sls = (slice(y0, y0 + max(y1 - y0, 0)), slice(x0, x0 + max(x1 - x0, 0)))
        data = np.frombuffer(surface.get_data(), np.uint32).reshape((sh, sw))[sls].copy()
        return _CairoRegion(sls, data)

    def restore_region(self, region):
        surface = self._renderer.gc.ctx.get_target()
        if not isinstance(surface, cairo.ImageSurface):
            raise RuntimeError('restore_region only works when rendering to an ImageSurface')
        surface.flush()
        sw = surface.get_width()
        sh = surface.get_height()
        (sly, slx) = region._slices
        np.frombuffer(surface.get_data(), np.uint32).reshape((sh, sw))[sly, slx] = region._data
        surface.mark_dirty_rectangle(slx.start, sly.start, slx.stop - slx.start, sly.stop - sly.start)

    def print_png(self, fobj):
        self._get_printed_image_surface().write_to_png(fobj)

    def print_rgba(self, fobj):
        (width, height) = self.get_width_height()
        buf = self._get_printed_image_surface().get_data()
        fobj.write(cbook._premultiplied_argb32_to_unmultiplied_rgba8888(np.asarray(buf).reshape((width, height, 4))))
    print_raw = print_rgba

    def _get_printed_image_surface(self):
        self._renderer.dpi = self.figure.dpi
        (width, height) = self.get_width_height()
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
        self._renderer.set_context(cairo.Context(surface))
        self.figure.draw(self._renderer)
        return surface

    def _save(self, fmt, fobj, *, orientation='portrait'):
        dpi = 72
        self.figure.dpi = dpi
        (w_in, h_in) = self.figure.get_size_inches()
        (width_in_points, height_in_points) = (w_in * dpi, h_in * dpi)
        if orientation == 'landscape':
            (width_in_points, height_in_points) = (height_in_points, width_in_points)
        if fmt == 'ps':
            if not hasattr(cairo, 'PSSurface'):
                raise RuntimeError('cairo has not been compiled with PS support enabled')
            surface = cairo.PSSurface(fobj, width_in_points, height_in_points)
        elif fmt == 'pdf':
            if not hasattr(cairo, 'PDFSurface'):
                raise RuntimeError('cairo has not been compiled with PDF support enabled')
            surface = cairo.PDFSurface(fobj, width_in_points, height_in_points)
        elif fmt in ('svg', 'svgz'):
            if not hasattr(cairo, 'SVGSurface'):
                raise RuntimeError('cairo has not been compiled with SVG support enabled')
            if fmt == 'svgz':
                if isinstance(fobj, str):
                    fobj = gzip.GzipFile(fobj, 'wb')
                else:
                    fobj = gzip.GzipFile(None, 'wb', fileobj=fobj)
            surface = cairo.SVGSurface(fobj, width_in_points, height_in_points)
        else:
            raise ValueError(f'Unknown format: {fmt!r}')
        self._renderer.dpi = self.figure.dpi
        self._renderer.set_context(cairo.Context(surface))
        ctx = self._renderer.gc.ctx
        if orientation == 'landscape':
            ctx.rotate(np.pi / 2)
            ctx.translate(0, -height_in_points)
        self.figure.draw(self._renderer)
        ctx.show_page()
        surface.finish()
        if fmt == 'svgz':
            fobj.close()
    print_pdf = functools.partialmethod(_save, 'pdf')
    print_ps = functools.partialmethod(_save, 'ps')
    print_svg = functools.partialmethod(_save, 'svg')
    print_svgz = functools.partialmethod(_save, 'svgz')

@_Backend.export
class _BackendCairo(_Backend):
    backend_version = cairo.version
    FigureCanvas = FigureCanvasCairo
    FigureManager = FigureManagerBase

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk3.py
import functools
import logging
import os
from pathlib import Path
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook
from matplotlib.backend_bases import ToolContainerBase, CloseEvent, KeyEvent, LocationEvent, MouseEvent, ResizeEvent
try:
    import gi
except ImportError as err:
    raise ImportError('The GTK3 backends require PyGObject') from err
try:
    gi.require_version('Gtk', '3.0')
except ValueError as e:
    raise ImportError(e) from e
from gi.repository import Gio, GLib, GObject, Gtk, Gdk
from . import _backend_gtk
from ._backend_gtk import _BackendGTK, _FigureCanvasGTK, _FigureManagerGTK, _NavigationToolbar2GTK, TimerGTK as TimerGTK3
_log = logging.getLogger(__name__)

@functools.cache
def _mpl_to_gtk_cursor(mpl_cursor):
    return Gdk.Cursor.new_from_name(Gdk.Display.get_default(), _backend_gtk.mpl_to_gtk_cursor_name(mpl_cursor))

class FigureCanvasGTK3(_FigureCanvasGTK, Gtk.DrawingArea):
    required_interactive_framework = 'gtk3'
    manager_class = _api.classproperty(lambda cls: FigureManagerGTK3)
    event_mask = Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.EXPOSURE_MASK | Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.KEY_RELEASE_MASK | Gdk.EventMask.ENTER_NOTIFY_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.SCROLL_MASK

    def __init__(self, figure=None):
        super().__init__(figure=figure)
        self._idle_draw_id = 0
        self._rubberband_rect = None
        self.connect('scroll_event', self.scroll_event)
        self.connect('button_press_event', self.button_press_event)
        self.connect('button_release_event', self.button_release_event)
        self.connect('configure_event', self.configure_event)
        self.connect('screen-changed', self._update_device_pixel_ratio)
        self.connect('notify::scale-factor', self._update_device_pixel_ratio)
        self.connect('draw', self.on_draw_event)
        self.connect('draw', self._post_draw)
        self.connect('key_press_event', self.key_press_event)
        self.connect('key_release_event', self.key_release_event)
        self.connect('motion_notify_event', self.motion_notify_event)
        self.connect('enter_notify_event', self.enter_notify_event)
        self.connect('leave_notify_event', self.leave_notify_event)
        self.connect('size_allocate', self.size_allocate)
        self.set_events(self.__class__.event_mask)
        self.set_can_focus(True)
        css = Gtk.CssProvider()
        css.load_from_data(b'.matplotlib-canvas { background-color: white; }')
        style_ctx = self.get_style_context()
        style_ctx.add_provider(css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
        style_ctx.add_class('matplotlib-canvas')

    def destroy(self):
        CloseEvent('close_event', self)._process()

    def set_cursor(self, cursor):
        window = self.get_property('window')
        if window is not None:
            window.set_cursor(_mpl_to_gtk_cursor(cursor))
            context = GLib.MainContext.default()
            context.iteration(True)

    def _mpl_coords(self, event=None):
        if event is None:
            window = self.get_window()
            (t, x, y, state) = window.get_device_position(window.get_display().get_device_manager().get_client_pointer())
        else:
            (x, y) = (event.x, event.y)
        x = x * self.device_pixel_ratio
        y = self.figure.bbox.height - y * self.device_pixel_ratio
        return (x, y)

    def scroll_event(self, widget, event):
        step = 1 if event.direction == Gdk.ScrollDirection.UP else -1
        MouseEvent('scroll_event', self, *self._mpl_coords(event), step=step, modifiers=self._mpl_modifiers(event.state), guiEvent=event)._process()
        return False

    def button_press_event(self, widget, event):
        MouseEvent('button_press_event', self, *self._mpl_coords(event), event.button, modifiers=self._mpl_modifiers(event.state), guiEvent=event)._process()
        return False

    def button_release_event(self, widget, event):
        MouseEvent('button_release_event', self, *self._mpl_coords(event), event.button, modifiers=self._mpl_modifiers(event.state), guiEvent=event)._process()
        return False

    def key_press_event(self, widget, event):
        KeyEvent('key_press_event', self, self._get_key(event), *self._mpl_coords(), guiEvent=event)._process()
        return True

    def key_release_event(self, widget, event):
        KeyEvent('key_release_event', self, self._get_key(event), *self._mpl_coords(), guiEvent=event)._process()
        return True

    def motion_notify_event(self, widget, event):
        MouseEvent('motion_notify_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(event.state), guiEvent=event)._process()
        return False

    def enter_notify_event(self, widget, event):
        gtk_mods = Gdk.Keymap.get_for_display(self.get_display()).get_modifier_state()
        LocationEvent('figure_enter_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(gtk_mods), guiEvent=event)._process()

    def leave_notify_event(self, widget, event):
        gtk_mods = Gdk.Keymap.get_for_display(self.get_display()).get_modifier_state()
        LocationEvent('figure_leave_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(gtk_mods), guiEvent=event)._process()

    def size_allocate(self, widget, allocation):
        dpival = self.figure.dpi
        winch = allocation.width * self.device_pixel_ratio / dpival
        hinch = allocation.height * self.device_pixel_ratio / dpival
        self.figure.set_size_inches(winch, hinch, forward=False)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    @staticmethod
    def _mpl_modifiers(event_state, *, exclude=None):
        modifiers = [('ctrl', Gdk.ModifierType.CONTROL_MASK, 'control'), ('alt', Gdk.ModifierType.MOD1_MASK, 'alt'), ('shift', Gdk.ModifierType.SHIFT_MASK, 'shift'), ('super', Gdk.ModifierType.MOD4_MASK, 'super')]
        return [name for (name, mask, key) in modifiers if exclude != key and event_state & mask]

    def _get_key(self, event):
        unikey = chr(Gdk.keyval_to_unicode(event.keyval))
        key = cbook._unikey_or_keysym_to_mplkey(unikey, Gdk.keyval_name(event.keyval))
        mods = self._mpl_modifiers(event.state, exclude=key)
        if 'shift' in mods and unikey.isprintable():
            mods.remove('shift')
        return '+'.join([*mods, key])

    def _update_device_pixel_ratio(self, *args, **kwargs):
        if self._set_device_pixel_ratio(self.get_scale_factor()):
            self.queue_resize()
            self.queue_draw()

    def configure_event(self, widget, event):
        if widget.get_property('window') is None:
            return
        w = event.width * self.device_pixel_ratio
        h = event.height * self.device_pixel_ratio
        if w < 3 or h < 3:
            return
        dpi = self.figure.dpi
        self.figure.set_size_inches(w / dpi, h / dpi, forward=False)
        return False

    def _draw_rubberband(self, rect):
        self._rubberband_rect = rect
        self.queue_draw()

    def _post_draw(self, widget, ctx):
        if self._rubberband_rect is None:
            return
        (x0, y0, w, h) = (dim / self.device_pixel_ratio for dim in self._rubberband_rect)
        x1 = x0 + w
        y1 = y0 + h
        ctx.move_to(x0, y0)
        ctx.line_to(x0, y1)
        ctx.move_to(x0, y0)
        ctx.line_to(x1, y0)
        ctx.move_to(x0, y1)
        ctx.line_to(x1, y1)
        ctx.move_to(x1, y0)
        ctx.line_to(x1, y1)
        ctx.set_antialias(1)
        ctx.set_line_width(1)
        ctx.set_dash((3, 3), 0)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke_preserve()
        ctx.set_dash((3, 3), 3)
        ctx.set_source_rgb(1, 1, 1)
        ctx.stroke()

    def on_draw_event(self, widget, ctx):
        pass

    def draw(self):
        if self.is_drawable():
            self.queue_draw()

    def draw_idle(self):
        if self._idle_draw_id != 0:
            return

        def idle_draw(*args):
            try:
                self.draw()
            finally:
                self._idle_draw_id = 0
            return False
        self._idle_draw_id = GLib.idle_add(idle_draw)

    def flush_events(self):
        context = GLib.MainContext.default()
        while context.pending():
            context.iteration(True)

class NavigationToolbar2GTK3(_NavigationToolbar2GTK, Gtk.Toolbar):

    def __init__(self, canvas):
        GObject.GObject.__init__(self)
        self.set_style(Gtk.ToolbarStyle.ICONS)
        self._gtk_ids = {}
        for (text, tooltip_text, image_file, callback) in self.toolitems:
            if text is None:
                self.insert(Gtk.SeparatorToolItem(), -1)
                continue
            image = Gtk.Image.new_from_gicon(Gio.Icon.new_for_string(str(cbook._get_data_path('images', f'{image_file}-symbolic.svg'))), Gtk.IconSize.LARGE_TOOLBAR)
            self._gtk_ids[text] = button = Gtk.ToggleToolButton() if callback in ['zoom', 'pan'] else Gtk.ToolButton()
            button.set_label(text)
            button.set_icon_widget(image)
            button._signal_handler = button.connect('clicked', getattr(self, callback))
            button.set_tooltip_text(tooltip_text)
            self.insert(button, -1)
        toolitem = Gtk.ToolItem()
        self.insert(toolitem, -1)
        label = Gtk.Label()
        label.set_markup('<small>\xa0\n\xa0</small>')
        toolitem.set_expand(True)
        toolitem.add(label)
        toolitem = Gtk.ToolItem()
        self.insert(toolitem, -1)
        self.message = Gtk.Label()
        self.message.set_justify(Gtk.Justification.RIGHT)
        toolitem.add(self.message)
        self.show_all()
        _NavigationToolbar2GTK.__init__(self, canvas)

    def save_figure(self, *args):
        dialog = Gtk.FileChooserDialog(title='Save the figure', parent=self.canvas.get_toplevel(), action=Gtk.FileChooserAction.SAVE, buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
        for (name, fmts) in self.canvas.get_supported_filetypes_grouped().items():
            ff = Gtk.FileFilter()
            ff.set_name(name)
            for fmt in fmts:
                ff.add_pattern(f'*.{fmt}')
            dialog.add_filter(ff)
            if self.canvas.get_default_filetype() in fmts:
                dialog.set_filter(ff)

        @functools.partial(dialog.connect, 'notify::filter')
        def on_notify_filter(*args):
            name = dialog.get_filter().get_name()
            fmt = self.canvas.get_supported_filetypes_grouped()[name][0]
            dialog.set_current_name(str(Path(dialog.get_current_name()).with_suffix(f'.{fmt}')))
        dialog.set_current_folder(mpl.rcParams['savefig.directory'])
        dialog.set_current_name(self.canvas.get_default_filename())
        dialog.set_do_overwrite_confirmation(True)
        response = dialog.run()
        fname = dialog.get_filename()
        ff = dialog.get_filter()
        fmt = self.canvas.get_supported_filetypes_grouped()[ff.get_name()][0]
        dialog.destroy()
        if response != Gtk.ResponseType.OK:
            return
        if mpl.rcParams['savefig.directory']:
            mpl.rcParams['savefig.directory'] = os.path.dirname(fname)
        try:
            self.canvas.figure.savefig(fname, format=fmt)
        except Exception as e:
            dialog = Gtk.MessageDialog(parent=self.canvas.get_toplevel(), message_format=str(e), type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
            dialog.run()
            dialog.destroy()

class ToolbarGTK3(ToolContainerBase, Gtk.Box):
    _icon_extension = '-symbolic.svg'

    def __init__(self, toolmanager):
        ToolContainerBase.__init__(self, toolmanager)
        Gtk.Box.__init__(self)
        self.set_property('orientation', Gtk.Orientation.HORIZONTAL)
        self._message = Gtk.Label()
        self._message.set_justify(Gtk.Justification.RIGHT)
        self.pack_end(self._message, False, False, 0)
        self.show_all()
        self._groups = {}
        self._toolitems = {}

    def add_toolitem(self, name, group, position, image_file, description, toggle):
        if toggle:
            button = Gtk.ToggleToolButton()
        else:
            button = Gtk.ToolButton()
        button.set_label(name)
        if image_file is not None:
            image = Gtk.Image.new_from_gicon(Gio.Icon.new_for_string(image_file), Gtk.IconSize.LARGE_TOOLBAR)
            button.set_icon_widget(image)
        if position is None:
            position = -1
        self._add_button(button, group, position)
        signal = button.connect('clicked', self._call_tool, name)
        button.set_tooltip_text(description)
        button.show_all()
        self._toolitems.setdefault(name, [])
        self._toolitems[name].append((button, signal))

    def _add_button(self, button, group, position):
        if group not in self._groups:
            if self._groups:
                self._add_separator()
            toolbar = Gtk.Toolbar()
            toolbar.set_style(Gtk.ToolbarStyle.ICONS)
            self.pack_start(toolbar, False, False, 0)
            toolbar.show_all()
            self._groups[group] = toolbar
        self._groups[group].insert(button, position)

    def _call_tool(self, btn, name):
        self.trigger_tool(name)

    def toggle_toolitem(self, name, toggled):
        if name not in self._toolitems:
            return
        for (toolitem, signal) in self._toolitems[name]:
            toolitem.handler_block(signal)
            toolitem.set_active(toggled)
            toolitem.handler_unblock(signal)

    def remove_toolitem(self, name):
        for (toolitem, _signal) in self._toolitems.pop(name, []):
            for group in self._groups:
                if toolitem in self._groups[group]:
                    self._groups[group].remove(toolitem)

    def _add_separator(self):
        sep = Gtk.Separator()
        sep.set_property('orientation', Gtk.Orientation.VERTICAL)
        self.pack_start(sep, False, True, 0)
        sep.show_all()

    def set_message(self, s):
        self._message.set_label(s)

@backend_tools._register_tool_class(FigureCanvasGTK3)
class SaveFigureGTK3(backend_tools.SaveFigureBase):

    def trigger(self, *args, **kwargs):
        NavigationToolbar2GTK3.save_figure(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(FigureCanvasGTK3)
class HelpGTK3(backend_tools.ToolHelpBase):

    def _normalize_shortcut(self, key):
        special = {'backspace': 'BackSpace', 'pagedown': 'Page_Down', 'pageup': 'Page_Up', 'scroll_lock': 'Scroll_Lock'}
        parts = key.split('+')
        mods = ['<' + mod + '>' for mod in parts[:-1]]
        key = parts[-1]
        if key in special:
            key = special[key]
        elif len(key) > 1:
            key = key.capitalize()
        elif key.isupper():
            mods += ['<shift>']
        return ''.join(mods) + key

    def _is_valid_shortcut(self, key):
        return 'cmd+' not in key and (not key.startswith('MouseButton.'))

    def _show_shortcuts_window(self):
        section = Gtk.ShortcutsSection()
        for (name, tool) in sorted(self.toolmanager.tools.items()):
            if not tool.description:
                continue
            group = Gtk.ShortcutsGroup()
            section.add(group)
            group.forall(lambda widget, data: widget.set_visible(False), None)
            shortcut = Gtk.ShortcutsShortcut(accelerator=' '.join((self._normalize_shortcut(key) for key in self.toolmanager.get_tool_keymap(name) if self._is_valid_shortcut(key))), title=tool.name, subtitle=tool.description)
            group.add(shortcut)
        window = Gtk.ShortcutsWindow(title='Help', modal=True, transient_for=self._figure.canvas.get_toplevel())
        section.show()
        window.add(section)
        window.show_all()

    def _show_shortcuts_dialog(self):
        dialog = Gtk.MessageDialog(self._figure.canvas.get_toplevel(), 0, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, self._get_help_text(), title='Help')
        dialog.run()
        dialog.destroy()

    def trigger(self, *args):
        if Gtk.check_version(3, 20, 0) is None:
            self._show_shortcuts_window()
        else:
            self._show_shortcuts_dialog()

@backend_tools._register_tool_class(FigureCanvasGTK3)
class ToolCopyToClipboardGTK3(backend_tools.ToolCopyToClipboardBase):

    def trigger(self, *args, **kwargs):
        clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
        window = self.canvas.get_window()
        (x, y, width, height) = window.get_geometry()
        pb = Gdk.pixbuf_get_from_window(window, x, y, width, height)
        clipboard.set_image(pb)
Toolbar = ToolbarGTK3
backend_tools._register_tool_class(FigureCanvasGTK3, _backend_gtk.ConfigureSubplotsGTK)
backend_tools._register_tool_class(FigureCanvasGTK3, _backend_gtk.RubberbandGTK)

class FigureManagerGTK3(_FigureManagerGTK):
    _toolbar2_class = NavigationToolbar2GTK3
    _toolmanager_toolbar_class = ToolbarGTK3

@_BackendGTK.export
class _BackendGTK3(_BackendGTK):
    FigureCanvas = FigureCanvasGTK3
    FigureManager = FigureManagerGTK3

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk3agg.py
import numpy as np
from .. import cbook, transforms
from . import backend_agg, backend_gtk3
from .backend_gtk3 import GLib, Gtk, _BackendGTK3
import cairo

class FigureCanvasGTK3Agg(backend_agg.FigureCanvasAgg, backend_gtk3.FigureCanvasGTK3):

    def __init__(self, figure):
        super().__init__(figure=figure)
        self._bbox_queue = []

    def on_draw_event(self, widget, ctx):
        if self._idle_draw_id:
            GLib.source_remove(self._idle_draw_id)
            self._idle_draw_id = 0
            self.draw()
        scale = self.device_pixel_ratio
        allocation = self.get_allocation()
        w = allocation.width * scale
        h = allocation.height * scale
        if not len(self._bbox_queue):
            Gtk.render_background(self.get_style_context(), ctx, allocation.x, allocation.y, allocation.width, allocation.height)
            bbox_queue = [transforms.Bbox([[0, 0], [w, h]])]
        else:
            bbox_queue = self._bbox_queue
        for bbox in bbox_queue:
            x = int(bbox.x0)
            y = h - int(bbox.y1)
            width = int(bbox.x1) - int(bbox.x0)
            height = int(bbox.y1) - int(bbox.y0)
            buf = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(np.asarray(self.copy_from_bbox(bbox)))
            image = cairo.ImageSurface.create_for_data(buf.ravel().data, cairo.FORMAT_ARGB32, width, height)
            image.set_device_scale(scale, scale)
            ctx.set_source_surface(image, x / scale, y / scale)
            ctx.paint()
        if len(self._bbox_queue):
            self._bbox_queue = []
        return False

    def blit(self, bbox=None):
        if bbox is None:
            bbox = self.figure.bbox
        scale = self.device_pixel_ratio
        allocation = self.get_allocation()
        x = int(bbox.x0 / scale)
        y = allocation.height - int(bbox.y1 / scale)
        width = (int(bbox.x1) - int(bbox.x0)) // scale
        height = (int(bbox.y1) - int(bbox.y0)) // scale
        self._bbox_queue.append(bbox)
        self.queue_draw_area(x, y, width, height)

@_BackendGTK3.export
class _BackendGTK3Cairo(_BackendGTK3):
    FigureCanvas = FigureCanvasGTK3Agg

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk3cairo.py
from contextlib import nullcontext
from .backend_cairo import FigureCanvasCairo
from .backend_gtk3 import GLib, Gtk, FigureCanvasGTK3, _BackendGTK3

class FigureCanvasGTK3Cairo(FigureCanvasCairo, FigureCanvasGTK3):

    def on_draw_event(self, widget, ctx):
        if self._idle_draw_id:
            GLib.source_remove(self._idle_draw_id)
            self._idle_draw_id = 0
            self.draw()
        with self.toolbar._wait_cursor_for_draw_cm() if self.toolbar else nullcontext():
            allocation = self.get_allocation()
            Gtk.render_background(self.get_style_context(), ctx, 0, 0, allocation.width, allocation.height)
            scale = self.device_pixel_ratio
            ctx.scale(1 / scale, 1 / scale)
            self._renderer.set_context(ctx)
            self._renderer.width = allocation.width * scale
            self._renderer.height = allocation.height * scale
            self._renderer.dpi = self.figure.dpi
            self.figure.draw(self._renderer)

@_BackendGTK3.export
class _BackendGTK3Cairo(_BackendGTK3):
    FigureCanvas = FigureCanvasGTK3Cairo

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk4.py
import functools
import io
import os
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook
from matplotlib.backend_bases import ToolContainerBase, KeyEvent, LocationEvent, MouseEvent, ResizeEvent, CloseEvent
try:
    import gi
except ImportError as err:
    raise ImportError('The GTK4 backends require PyGObject') from err
try:
    gi.require_version('Gtk', '4.0')
except ValueError as e:
    raise ImportError(e) from e
from gi.repository import Gio, GLib, Gtk, Gdk, GdkPixbuf
from . import _backend_gtk
from ._backend_gtk import _BackendGTK, _FigureCanvasGTK, _FigureManagerGTK, _NavigationToolbar2GTK, TimerGTK as TimerGTK4

class FigureCanvasGTK4(_FigureCanvasGTK, Gtk.DrawingArea):
    required_interactive_framework = 'gtk4'
    supports_blit = False
    manager_class = _api.classproperty(lambda cls: FigureManagerGTK4)

    def __init__(self, figure=None):
        super().__init__(figure=figure)
        self.set_hexpand(True)
        self.set_vexpand(True)
        self._idle_draw_id = 0
        self._rubberband_rect = None
        self.set_draw_func(self._draw_func)
        self.connect('resize', self.resize_event)
        self.connect('notify::scale-factor', self._update_device_pixel_ratio)
        click = Gtk.GestureClick()
        click.set_button(0)
        click.connect('pressed', self.button_press_event)
        click.connect('released', self.button_release_event)
        self.add_controller(click)
        key = Gtk.EventControllerKey()
        key.connect('key-pressed', self.key_press_event)
        key.connect('key-released', self.key_release_event)
        self.add_controller(key)
        motion = Gtk.EventControllerMotion()
        motion.connect('motion', self.motion_notify_event)
        motion.connect('enter', self.enter_notify_event)
        motion.connect('leave', self.leave_notify_event)
        self.add_controller(motion)
        scroll = Gtk.EventControllerScroll.new(Gtk.EventControllerScrollFlags.VERTICAL)
        scroll.connect('scroll', self.scroll_event)
        self.add_controller(scroll)
        self.set_focusable(True)
        css = Gtk.CssProvider()
        style = '.matplotlib-canvas { background-color: white; }'
        if Gtk.check_version(4, 9, 3) is None:
            css.load_from_data(style, -1)
        else:
            css.load_from_data(style.encode('utf-8'))
        style_ctx = self.get_style_context()
        style_ctx.add_provider(css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
        style_ctx.add_class('matplotlib-canvas')

    def destroy(self):
        CloseEvent('close_event', self)._process()

    def set_cursor(self, cursor):
        self.set_cursor_from_name(_backend_gtk.mpl_to_gtk_cursor_name(cursor))

    def _mpl_coords(self, xy=None):
        if xy is None:
            surface = self.get_native().get_surface()
            (is_over, x, y, mask) = surface.get_device_position(self.get_display().get_default_seat().get_pointer())
        else:
            (x, y) = xy
        x = x * self.device_pixel_ratio
        y = self.figure.bbox.height - y * self.device_pixel_ratio
        return (x, y)

    def scroll_event(self, controller, dx, dy):
        MouseEvent('scroll_event', self, *self._mpl_coords(), step=dy, modifiers=self._mpl_modifiers(controller))._process()
        return True

    def button_press_event(self, controller, n_press, x, y):
        MouseEvent('button_press_event', self, *self._mpl_coords((x, y)), controller.get_current_button(), modifiers=self._mpl_modifiers(controller))._process()
        self.grab_focus()

    def button_release_event(self, controller, n_press, x, y):
        MouseEvent('button_release_event', self, *self._mpl_coords((x, y)), controller.get_current_button(), modifiers=self._mpl_modifiers(controller))._process()

    def key_press_event(self, controller, keyval, keycode, state):
        KeyEvent('key_press_event', self, self._get_key(keyval, keycode, state), *self._mpl_coords())._process()
        return True

    def key_release_event(self, controller, keyval, keycode, state):
        KeyEvent('key_release_event', self, self._get_key(keyval, keycode, state), *self._mpl_coords())._process()
        return True

    def motion_notify_event(self, controller, x, y):
        MouseEvent('motion_notify_event', self, *self._mpl_coords((x, y)), modifiers=self._mpl_modifiers(controller))._process()

    def enter_notify_event(self, controller, x, y):
        LocationEvent('figure_enter_event', self, *self._mpl_coords((x, y)), modifiers=self._mpl_modifiers())._process()

    def leave_notify_event(self, controller):
        LocationEvent('figure_leave_event', self, *self._mpl_coords(), modifiers=self._mpl_modifiers())._process()

    def resize_event(self, area, width, height):
        self._update_device_pixel_ratio()
        dpi = self.figure.dpi
        winch = width * self.device_pixel_ratio / dpi
        hinch = height * self.device_pixel_ratio / dpi
        self.figure.set_size_inches(winch, hinch, forward=False)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    def _mpl_modifiers(self, controller=None):
        if controller is None:
            surface = self.get_native().get_surface()
            (is_over, x, y, event_state) = surface.get_device_position(self.get_display().get_default_seat().get_pointer())
        else:
            event_state = controller.get_current_event_state()
        mod_table = [('ctrl', Gdk.ModifierType.CONTROL_MASK), ('alt', Gdk.ModifierType.ALT_MASK), ('shift', Gdk.ModifierType.SHIFT_MASK), ('super', Gdk.ModifierType.SUPER_MASK)]
        return [name for (name, mask) in mod_table if event_state & mask]

    def _get_key(self, keyval, keycode, state):
        unikey = chr(Gdk.keyval_to_unicode(keyval))
        key = cbook._unikey_or_keysym_to_mplkey(unikey, Gdk.keyval_name(keyval))
        modifiers = [('ctrl', Gdk.ModifierType.CONTROL_MASK, 'control'), ('alt', Gdk.ModifierType.ALT_MASK, 'alt'), ('shift', Gdk.ModifierType.SHIFT_MASK, 'shift'), ('super', Gdk.ModifierType.SUPER_MASK, 'super')]
        mods = [mod for (mod, mask, mod_key) in modifiers if mod_key != key and state & mask and (not (mod == 'shift' and unikey.isprintable()))]
        return '+'.join([*mods, key])

    def _update_device_pixel_ratio(self, *args, **kwargs):
        if self._set_device_pixel_ratio(self.get_scale_factor()):
            self.draw()

    def _draw_rubberband(self, rect):
        self._rubberband_rect = rect
        self.queue_draw()

    def _draw_func(self, drawing_area, ctx, width, height):
        self.on_draw_event(self, ctx)
        self._post_draw(self, ctx)

    def _post_draw(self, widget, ctx):
        if self._rubberband_rect is None:
            return
        lw = 1
        dash = 3
        (x0, y0, w, h) = (dim / self.device_pixel_ratio for dim in self._rubberband_rect)
        x1 = x0 + w
        y1 = y0 + h
        ctx.move_to(x0, y0)
        ctx.line_to(x0, y1)
        ctx.move_to(x0, y0)
        ctx.line_to(x1, y0)
        ctx.move_to(x0, y1)
        ctx.line_to(x1, y1)
        ctx.move_to(x1, y0)
        ctx.line_to(x1, y1)
        ctx.set_antialias(1)
        ctx.set_line_width(lw)
        ctx.set_dash((dash, dash), 0)
        ctx.set_source_rgb(0, 0, 0)
        ctx.stroke_preserve()
        ctx.set_dash((dash, dash), dash)
        ctx.set_source_rgb(1, 1, 1)
        ctx.stroke()

    def on_draw_event(self, widget, ctx):
        pass

    def draw(self):
        if self.is_drawable():
            self.queue_draw()

    def draw_idle(self):
        if self._idle_draw_id != 0:
            return

        def idle_draw(*args):
            try:
                self.draw()
            finally:
                self._idle_draw_id = 0
            return False
        self._idle_draw_id = GLib.idle_add(idle_draw)

    def flush_events(self):
        context = GLib.MainContext.default()
        while context.pending():
            context.iteration(True)

class NavigationToolbar2GTK4(_NavigationToolbar2GTK, Gtk.Box):

    def __init__(self, canvas):
        Gtk.Box.__init__(self)
        self.add_css_class('toolbar')
        self._gtk_ids = {}
        for (text, tooltip_text, image_file, callback) in self.toolitems:
            if text is None:
                self.append(Gtk.Separator())
                continue
            image = Gtk.Image.new_from_gicon(Gio.Icon.new_for_string(str(cbook._get_data_path('images', f'{image_file}-symbolic.svg'))))
            self._gtk_ids[text] = button = Gtk.ToggleButton() if callback in ['zoom', 'pan'] else Gtk.Button()
            button.set_child(image)
            button.add_css_class('flat')
            button.add_css_class('image-button')
            button._signal_handler = button.connect('clicked', getattr(self, callback))
            button.set_tooltip_text(tooltip_text)
            self.append(button)
        label = Gtk.Label()
        label.set_markup('<small>\xa0\n\xa0</small>')
        label.set_hexpand(True)
        self.append(label)
        self.message = Gtk.Label()
        self.message.set_justify(Gtk.Justification.RIGHT)
        self.append(self.message)
        _NavigationToolbar2GTK.__init__(self, canvas)

    def save_figure(self, *args):
        dialog = Gtk.FileChooserNative(title='Save the figure', transient_for=self.canvas.get_root(), action=Gtk.FileChooserAction.SAVE, modal=True)
        self._save_dialog = dialog
        ff = Gtk.FileFilter()
        ff.set_name('All files')
        ff.add_pattern('*')
        dialog.add_filter(ff)
        dialog.set_filter(ff)
        formats = []
        default_format = None
        for (i, (name, fmts)) in enumerate(self.canvas.get_supported_filetypes_grouped().items()):
            ff = Gtk.FileFilter()
            ff.set_name(name)
            for fmt in fmts:
                ff.add_pattern(f'*.{fmt}')
            dialog.add_filter(ff)
            formats.append(name)
            if self.canvas.get_default_filetype() in fmts:
                default_format = i
        formats = [formats[default_format], *formats[:default_format], *formats[default_format + 1:]]
        dialog.add_choice('format', 'File format', formats, formats)
        dialog.set_choice('format', formats[0])
        dialog.set_current_folder(Gio.File.new_for_path(os.path.expanduser(mpl.rcParams['savefig.directory'])))
        dialog.set_current_name(self.canvas.get_default_filename())

        @functools.partial(dialog.connect, 'response')
        def on_response(dialog, response):
            file = dialog.get_file()
            fmt = dialog.get_choice('format')
            fmt = self.canvas.get_supported_filetypes_grouped()[fmt][0]
            dialog.destroy()
            self._save_dialog = None
            if response != Gtk.ResponseType.ACCEPT:
                return
            if mpl.rcParams['savefig.directory']:
                parent = file.get_parent()
                mpl.rcParams['savefig.directory'] = parent.get_path()
            try:
                self.canvas.figure.savefig(file.get_path(), format=fmt)
            except Exception as e:
                msg = Gtk.MessageDialog(transient_for=self.canvas.get_root(), message_type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK, modal=True, text=str(e))
                msg.show()
        dialog.show()

class ToolbarGTK4(ToolContainerBase, Gtk.Box):
    _icon_extension = '-symbolic.svg'

    def __init__(self, toolmanager):
        ToolContainerBase.__init__(self, toolmanager)
        Gtk.Box.__init__(self)
        self.set_property('orientation', Gtk.Orientation.HORIZONTAL)
        self._tool_box = Gtk.Box()
        self.append(self._tool_box)
        self._groups = {}
        self._toolitems = {}
        label = Gtk.Label()
        label.set_markup('<small>\xa0\n\xa0</small>')
        label.set_hexpand(True)
        self.append(label)
        self._message = Gtk.Label()
        self._message.set_justify(Gtk.Justification.RIGHT)
        self.append(self._message)

    def add_toolitem(self, name, group, position, image_file, description, toggle):
        if toggle:
            button = Gtk.ToggleButton()
        else:
            button = Gtk.Button()
        button.set_label(name)
        button.add_css_class('flat')
        if image_file is not None:
            image = Gtk.Image.new_from_gicon(Gio.Icon.new_for_string(image_file))
            button.set_child(image)
            button.add_css_class('image-button')
        if position is None:
            position = -1
        self._add_button(button, group, position)
        signal = button.connect('clicked', self._call_tool, name)
        button.set_tooltip_text(description)
        self._toolitems.setdefault(name, [])
        self._toolitems[name].append((button, signal))

    def _find_child_at_position(self, group, position):
        children = [None]
        child = self._groups[group].get_first_child()
        while child is not None:
            children.append(child)
            child = child.get_next_sibling()
        return children[position]

    def _add_button(self, button, group, position):
        if group not in self._groups:
            if self._groups:
                self._add_separator()
            group_box = Gtk.Box()
            self._tool_box.append(group_box)
            self._groups[group] = group_box
        self._groups[group].insert_child_after(button, self._find_child_at_position(group, position))

    def _call_tool(self, btn, name):
        self.trigger_tool(name)

    def toggle_toolitem(self, name, toggled):
        if name not in self._toolitems:
            return
        for (toolitem, signal) in self._toolitems[name]:
            toolitem.handler_block(signal)
            toolitem.set_active(toggled)
            toolitem.handler_unblock(signal)

    def remove_toolitem(self, name):
        for (toolitem, _signal) in self._toolitems.pop(name, []):
            for group in self._groups:
                if toolitem in self._groups[group]:
                    self._groups[group].remove(toolitem)

    def _add_separator(self):
        sep = Gtk.Separator()
        sep.set_property('orientation', Gtk.Orientation.VERTICAL)
        self._tool_box.append(sep)

    def set_message(self, s):
        self._message.set_label(s)

@backend_tools._register_tool_class(FigureCanvasGTK4)
class SaveFigureGTK4(backend_tools.SaveFigureBase):

    def trigger(self, *args, **kwargs):
        NavigationToolbar2GTK4.save_figure(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(FigureCanvasGTK4)
class HelpGTK4(backend_tools.ToolHelpBase):

    def _normalize_shortcut(self, key):
        special = {'backspace': 'BackSpace', 'pagedown': 'Page_Down', 'pageup': 'Page_Up', 'scroll_lock': 'Scroll_Lock'}
        parts = key.split('+')
        mods = ['<' + mod + '>' for mod in parts[:-1]]
        key = parts[-1]
        if key in special:
            key = special[key]
        elif len(key) > 1:
            key = key.capitalize()
        elif key.isupper():
            mods += ['<shift>']
        return ''.join(mods) + key

    def _is_valid_shortcut(self, key):
        return 'cmd+' not in key and (not key.startswith('MouseButton.'))

    def trigger(self, *args):
        section = Gtk.ShortcutsSection()
        for (name, tool) in sorted(self.toolmanager.tools.items()):
            if not tool.description:
                continue
            group = Gtk.ShortcutsGroup()
            section.append(group)
            child = group.get_first_child()
            while child is not None:
                child.set_visible(False)
                child = child.get_next_sibling()
            shortcut = Gtk.ShortcutsShortcut(accelerator=' '.join((self._normalize_shortcut(key) for key in self.toolmanager.get_tool_keymap(name) if self._is_valid_shortcut(key))), title=tool.name, subtitle=tool.description)
            group.append(shortcut)
        window = Gtk.ShortcutsWindow(title='Help', modal=True, transient_for=self._figure.canvas.get_root())
        window.set_child(section)
        window.show()

@backend_tools._register_tool_class(FigureCanvasGTK4)
class ToolCopyToClipboardGTK4(backend_tools.ToolCopyToClipboardBase):

    def trigger(self, *args, **kwargs):
        with io.BytesIO() as f:
            self.canvas.print_rgba(f)
            (w, h) = self.canvas.get_width_height()
            pb = GdkPixbuf.Pixbuf.new_from_data(f.getbuffer(), GdkPixbuf.Colorspace.RGB, True, 8, w, h, w * 4)
        clipboard = self.canvas.get_clipboard()
        clipboard.set(pb)
backend_tools._register_tool_class(FigureCanvasGTK4, _backend_gtk.ConfigureSubplotsGTK)
backend_tools._register_tool_class(FigureCanvasGTK4, _backend_gtk.RubberbandGTK)
Toolbar = ToolbarGTK4

class FigureManagerGTK4(_FigureManagerGTK):
    _toolbar2_class = NavigationToolbar2GTK4
    _toolmanager_toolbar_class = ToolbarGTK4

@_BackendGTK.export
class _BackendGTK4(_BackendGTK):
    FigureCanvas = FigureCanvasGTK4
    FigureManager = FigureManagerGTK4

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk4agg.py
import numpy as np
from .. import cbook
from . import backend_agg, backend_gtk4
from .backend_gtk4 import GLib, Gtk, _BackendGTK4
import cairo

class FigureCanvasGTK4Agg(backend_agg.FigureCanvasAgg, backend_gtk4.FigureCanvasGTK4):

    def on_draw_event(self, widget, ctx):
        if self._idle_draw_id:
            GLib.source_remove(self._idle_draw_id)
            self._idle_draw_id = 0
            self.draw()
        scale = self.device_pixel_ratio
        allocation = self.get_allocation()
        Gtk.render_background(self.get_style_context(), ctx, allocation.x, allocation.y, allocation.width, allocation.height)
        buf = cbook._unmultiplied_rgba8888_to_premultiplied_argb32(np.asarray(self.get_renderer().buffer_rgba()))
        (height, width, _) = buf.shape
        image = cairo.ImageSurface.create_for_data(buf.ravel().data, cairo.FORMAT_ARGB32, width, height)
        image.set_device_scale(scale, scale)
        ctx.set_source_surface(image, 0, 0)
        ctx.paint()
        return False

@_BackendGTK4.export
class _BackendGTK4Agg(_BackendGTK4):
    FigureCanvas = FigureCanvasGTK4Agg

# File: matplotlib-main/lib/matplotlib/backends/backend_gtk4cairo.py
from contextlib import nullcontext
from .backend_cairo import FigureCanvasCairo
from .backend_gtk4 import GLib, Gtk, FigureCanvasGTK4, _BackendGTK4

class FigureCanvasGTK4Cairo(FigureCanvasCairo, FigureCanvasGTK4):

    def _set_device_pixel_ratio(self, ratio):
        return False

    def on_draw_event(self, widget, ctx):
        if self._idle_draw_id:
            GLib.source_remove(self._idle_draw_id)
            self._idle_draw_id = 0
            self.draw()
        with self.toolbar._wait_cursor_for_draw_cm() if self.toolbar else nullcontext():
            self._renderer.set_context(ctx)
            allocation = self.get_allocation()
            Gtk.render_background(self.get_style_context(), ctx, allocation.x, allocation.y, allocation.width, allocation.height)
            self.figure.draw(self._renderer)

@_BackendGTK4.export
class _BackendGTK4Cairo(_BackendGTK4):
    FigureCanvas = FigureCanvasGTK4Cairo

# File: matplotlib-main/lib/matplotlib/backends/backend_macosx.py
import os
import matplotlib as mpl
from matplotlib import _api, cbook
from matplotlib._pylab_helpers import Gcf
from . import _macosx
from .backend_agg import FigureCanvasAgg
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2, ResizeEvent, TimerBase, _allow_interrupt

class TimerMac(_macosx.Timer, TimerBase):

def _allow_interrupt_macos():
    return _allow_interrupt(lambda rsock: _macosx.wake_on_fd_write(rsock.fileno()), _macosx.stop)

class FigureCanvasMac(FigureCanvasAgg, _macosx.FigureCanvas, FigureCanvasBase):
    required_interactive_framework = 'macosx'
    _timer_cls = TimerMac
    manager_class = _api.classproperty(lambda cls: FigureManagerMac)

    def __init__(self, figure):
        super().__init__(figure=figure)
        self._draw_pending = False
        self._is_drawing = False
        self._timers = set()

    def draw(self):
        if self._is_drawing:
            return
        with cbook._setattr_cm(self, _is_drawing=True):
            super().draw()
        self.update()

    def draw_idle(self):
        if not (getattr(self, '_draw_pending', False) or getattr(self, '_is_drawing', False)):
            self._draw_pending = True
            self._single_shot_timer(self._draw_idle)

    def _single_shot_timer(self, callback):

        def callback_func(callback, timer):
            callback()
            self._timers.remove(timer)
        timer = self.new_timer(interval=0)
        timer.single_shot = True
        timer.add_callback(callback_func, callback, timer)
        self._timers.add(timer)
        timer.start()

    def _draw_idle(self):
        with self._idle_draw_cntx():
            if not self._draw_pending:
                return
            self._draw_pending = False
            self.draw()

    def blit(self, bbox=None):
        super().blit(bbox)
        self.update()

    def resize(self, width, height):
        scale = self.figure.dpi / self.device_pixel_ratio
        width /= scale
        height /= scale
        self.figure.set_size_inches(width, height, forward=False)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    def start_event_loop(self, timeout=0):
        with _allow_interrupt_macos():
            self._start_event_loop(timeout=timeout)

class NavigationToolbar2Mac(_macosx.NavigationToolbar2, NavigationToolbar2):

    def __init__(self, canvas):
        data_path = cbook._get_data_path('images')
        (_, tooltips, image_names, _) = zip(*NavigationToolbar2.toolitems)
        _macosx.NavigationToolbar2.__init__(self, canvas, tuple((str(data_path / image_name) + '.pdf' for image_name in image_names if image_name is not None)), tuple((tooltip for tooltip in tooltips if tooltip is not None)))
        NavigationToolbar2.__init__(self, canvas)

    def draw_rubberband(self, event, x0, y0, x1, y1):
        self.canvas.set_rubberband(int(x0), int(y0), int(x1), int(y1))

    def remove_rubberband(self):
        self.canvas.remove_rubberband()

    def save_figure(self, *args):
        directory = os.path.expanduser(mpl.rcParams['savefig.directory'])
        filename = _macosx.choose_save_file('Save the figure', directory, self.canvas.get_default_filename())
        if filename is None:
            return
        if mpl.rcParams['savefig.directory']:
            mpl.rcParams['savefig.directory'] = os.path.dirname(filename)
        self.canvas.figure.savefig(filename)

class FigureManagerMac(_macosx.FigureManager, FigureManagerBase):
    _toolbar2_class = NavigationToolbar2Mac

    def __init__(self, canvas, num):
        self._shown = False
        _macosx.FigureManager.__init__(self, canvas)
        icon_path = str(cbook._get_data_path('images/matplotlib.pdf'))
        _macosx.FigureManager.set_icon(icon_path)
        FigureManagerBase.__init__(self, canvas, num)
        self._set_window_mode(mpl.rcParams['macosx.window_mode'])
        if self.toolbar is not None:
            self.toolbar.update()
        if mpl.is_interactive():
            self.show()
            self.canvas.draw_idle()

    def _close_button_pressed(self):
        Gcf.destroy(self)
        self.canvas.flush_events()

    def destroy(self):
        while self.canvas._timers:
            timer = self.canvas._timers.pop()
            timer.stop()
        super().destroy()

    @classmethod
    def start_main_loop(cls):
        with _allow_interrupt_macos():
            _macosx.show()

    def show(self):
        if self.canvas.figure.stale:
            self.canvas.draw_idle()
        if not self._shown:
            self._show()
            self._shown = True
        if mpl.rcParams['figure.raise_window']:
            self._raise()

@_Backend.export
class _BackendMac(_Backend):
    FigureCanvas = FigureCanvasMac
    FigureManager = FigureManagerMac
    mainloop = FigureManagerMac.start_main_loop

# File: matplotlib-main/lib/matplotlib/backends/backend_mixed.py
import numpy as np
from matplotlib import cbook
from .backend_agg import RendererAgg
from matplotlib._tight_bbox import process_figure_for_rasterizing

class MixedModeRenderer:

    def __init__(self, figure, width, height, dpi, vector_renderer, raster_renderer_class=None, bbox_inches_restore=None):
        if raster_renderer_class is None:
            raster_renderer_class = RendererAgg
        self._raster_renderer_class = raster_renderer_class
        self._width = width
        self._height = height
        self.dpi = dpi
        self._vector_renderer = vector_renderer
        self._raster_renderer = None
        self.figure = figure
        self._figdpi = figure.dpi
        self._bbox_inches_restore = bbox_inches_restore
        self._renderer = vector_renderer

    def __getattr__(self, attr):
        return getattr(self._renderer, attr)

    def start_rasterizing(self):
        self.figure.dpi = self.dpi
        if self._bbox_inches_restore:
            r = process_figure_for_rasterizing(self.figure, self._bbox_inches_restore)
            self._bbox_inches_restore = r
        self._raster_renderer = self._raster_renderer_class(self._width * self.dpi, self._height * self.dpi, self.dpi)
        self._renderer = self._raster_renderer

    def stop_rasterizing(self):
        self._renderer = self._vector_renderer
        height = self._height * self.dpi
        img = np.asarray(self._raster_renderer.buffer_rgba())
        (slice_y, slice_x) = cbook._get_nonzero_slices(img[..., 3])
        cropped_img = img[slice_y, slice_x]
        if cropped_img.size:
            gc = self._renderer.new_gc()
            self._renderer.draw_image(gc, slice_x.start * self._figdpi / self.dpi, (height - slice_y.stop) * self._figdpi / self.dpi, cropped_img[::-1])
        self._raster_renderer = None
        self.figure.dpi = self._figdpi
        if self._bbox_inches_restore:
            r = process_figure_for_rasterizing(self.figure, self._bbox_inches_restore, self._figdpi)
            self._bbox_inches_restore = r

# File: matplotlib-main/lib/matplotlib/backends/backend_nbagg.py
""""""
from base64 import b64encode
import io
import json
import pathlib
import uuid
from ipykernel.comm import Comm
from IPython.display import display, Javascript, HTML
from matplotlib import is_interactive
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import _Backend, CloseEvent, NavigationToolbar2
from .backend_webagg_core import FigureCanvasWebAggCore, FigureManagerWebAgg, NavigationToolbar2WebAgg
from .backend_webagg_core import TimerTornado, TimerAsyncio

def connection_info():
    result = ['{fig} - {socket}'.format(fig=manager.canvas.figure.get_label() or f'Figure {manager.num}', socket=manager.web_sockets) for manager in Gcf.get_all_fig_managers()]
    if not is_interactive():
        result.append(f'Figures pending show: {len(Gcf.figs)}')
    return '\n'.join(result)
_FONT_AWESOME_CLASSES = {'home': 'fa fa-home', 'back': 'fa fa-arrow-left', 'forward': 'fa fa-arrow-right', 'zoom_to_rect': 'fa fa-square-o', 'move': 'fa fa-arrows', 'download': 'fa fa-floppy-o', None: None}

class NavigationIPy(NavigationToolbar2WebAgg):
    toolitems = [(text, tooltip_text, _FONT_AWESOME_CLASSES[image_file], name_of_method) for (text, tooltip_text, image_file, name_of_method) in NavigationToolbar2.toolitems + (('Download', 'Download plot', 'download', 'download'),) if image_file in _FONT_AWESOME_CLASSES]

class FigureManagerNbAgg(FigureManagerWebAgg):
    _toolbar2_class = ToolbarCls = NavigationIPy

    def __init__(self, canvas, num):
        self._shown = False
        super().__init__(canvas, num)

    @classmethod
    def create_with_canvas(cls, canvas_class, figure, num):
        canvas = canvas_class(figure)
        manager = cls(canvas, num)
        if is_interactive():
            manager.show()
            canvas.draw_idle()

        def destroy(event):
            canvas.mpl_disconnect(cid)
            Gcf.destroy(manager)
        cid = canvas.mpl_connect('close_event', destroy)
        return manager

    def display_js(self):
        display(Javascript(FigureManagerNbAgg.get_javascript()))

    def show(self):
        if not self._shown:
            self.display_js()
            self._create_comm()
        else:
            self.canvas.draw_idle()
        self._shown = True
        if hasattr(self, '_cidgcf'):
            self.canvas.mpl_disconnect(self._cidgcf)
        if not is_interactive():
            from matplotlib._pylab_helpers import Gcf
            Gcf.figs.pop(self.num, None)

    def reshow(self):
        self._shown = False
        self.show()

    @property
    def connected(self):
        return bool(self.web_sockets)

    @classmethod
    def get_javascript(cls, stream=None):
        if stream is None:
            output = io.StringIO()
        else:
            output = stream
        super().get_javascript(stream=output)
        output.write((pathlib.Path(__file__).parent / 'web_backend/js/nbagg_mpl.js').read_text(encoding='utf-8'))
        if stream is None:
            return output.getvalue()

    def _create_comm(self):
        comm = CommSocket(self)
        self.add_web_socket(comm)
        return comm

    def destroy(self):
        self._send_event('close')
        for comm in list(self.web_sockets):
            comm.on_close()
        self.clearup_closed()

    def clearup_closed(self):
        self.web_sockets = {socket for socket in self.web_sockets if socket.is_open()}
        if len(self.web_sockets) == 0:
            CloseEvent('close_event', self.canvas)._process()

    def remove_comm(self, comm_id):
        self.web_sockets = {socket for socket in self.web_sockets if socket.comm.comm_id != comm_id}

class FigureCanvasNbAgg(FigureCanvasWebAggCore):
    manager_class = FigureManagerNbAgg

class CommSocket:

    def __init__(self, manager):
        self.supports_binary = None
        self.manager = manager
        self.uuid = str(uuid.uuid4())
        display(HTML('<div id=%r></div>' % self.uuid))
        try:
            self.comm = Comm('matplotlib', data={'id': self.uuid})
        except AttributeError as err:
            raise RuntimeError('Unable to create an IPython notebook Comm instance. Are you in the IPython notebook?') from err
        self.comm.on_msg(self.on_message)
        manager = self.manager
        self._ext_close = False

        def _on_close(close_message):
            self._ext_close = True
            manager.remove_comm(close_message['content']['comm_id'])
            manager.clearup_closed()
        self.comm.on_close(_on_close)

    def is_open(self):
        return not (self._ext_close or self.comm._closed)

    def on_close(self):
        if self.is_open():
            try:
                self.comm.close()
            except KeyError:
                pass

    def send_json(self, content):
        self.comm.send({'data': json.dumps(content)})

    def send_binary(self, blob):
        if self.supports_binary:
            self.comm.send({'blob': 'image/png'}, buffers=[blob])
        else:
            data = b64encode(blob).decode('ascii')
            data_uri = f'data:image/png;base64,{data}'
            self.comm.send({'data': data_uri})

    def on_message(self, message):
        message = json.loads(message['content']['data'])
        if message['type'] == 'closing':
            self.on_close()
            self.manager.clearup_closed()
        elif message['type'] == 'supports_binary':
            self.supports_binary = message['value']
        else:
            self.manager.handle_json(message)

@_Backend.export
class _BackendNbAgg(_Backend):
    FigureCanvas = FigureCanvasNbAgg
    FigureManager = FigureManagerNbAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_pdf.py
""""""
import codecs
from datetime import timezone
from datetime import datetime
from enum import Enum
from functools import total_ordering
from io import BytesIO
import itertools
import logging
import math
import os
import string
import struct
import sys
import time
import types
import warnings
import zlib
import numpy as np
from PIL import Image
import matplotlib as mpl
from matplotlib import _api, _text_helpers, _type1font, cbook, dviread
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase, RendererBase
from matplotlib.backends.backend_mixed import MixedModeRenderer
from matplotlib.figure import Figure
from matplotlib.font_manager import get_font, fontManager as _fontManager
from matplotlib._afm import AFM
from matplotlib.ft2font import FIXED_WIDTH, ITALIC, LOAD_NO_SCALE, LOAD_NO_HINTING, KERNING_UNFITTED, FT2Font
from matplotlib.transforms import Affine2D, BboxBase
from matplotlib.path import Path
from matplotlib.dates import UTC
from matplotlib import _path
from . import _backend_pdf_ps
_log = logging.getLogger(__name__)

def _fill(strings, linelen=75):
    currpos = 0
    lasti = 0
    result = []
    for (i, s) in enumerate(strings):
        length = len(s)
        if currpos + length < linelen:
            currpos += length + 1
        else:
            result.append(b' '.join(strings[lasti:i]))
            lasti = i
            currpos = length
    result.append(b' '.join(strings[lasti:]))
    return b'\n'.join(result)

def _create_pdf_info_dict(backend, metadata):
    source_date_epoch = os.getenv('SOURCE_DATE_EPOCH')
    if source_date_epoch:
        source_date = datetime.fromtimestamp(int(source_date_epoch), timezone.utc)
        source_date = source_date.replace(tzinfo=UTC)
    else:
        source_date = datetime.today()
    info = {'Creator': f'Matplotlib v{mpl.__version__}, https://matplotlib.org', 'Producer': f'Matplotlib {backend} backend v{mpl.__version__}', 'CreationDate': source_date, **metadata}
    info = {k: v for (k, v) in info.items() if v is not None}

    def is_string_like(x):
        return isinstance(x, str)
    is_string_like.text_for_warning = 'an instance of str'

    def is_date(x):
        return isinstance(x, datetime)
    is_date.text_for_warning = 'an instance of datetime.datetime'

    def check_trapped(x):
        if isinstance(x, Name):
            return x.name in (b'True', b'False', b'Unknown')
        else:
            return x in ('True', 'False', 'Unknown')
    check_trapped.text_for_warning = 'one of {"True", "False", "Unknown"}'
    keywords = {'Title': is_string_like, 'Author': is_string_like, 'Subject': is_string_like, 'Keywords': is_string_like, 'Creator': is_string_like, 'Producer': is_string_like, 'CreationDate': is_date, 'ModDate': is_date, 'Trapped': check_trapped}
    for k in info:
        if k not in keywords:
            _api.warn_external(f'Unknown infodict keyword: {k!r}. Must be one of {set(keywords)!r}.')
        elif not keywords[k](info[k]):
            _api.warn_external(f'Bad value for infodict keyword {k}. Got {info[k]!r} which is not {keywords[k].text_for_warning}.')
    if 'Trapped' in info:
        info['Trapped'] = Name(info['Trapped'])
    return info

def _datetime_to_pdf(d):
    r = d.strftime('D:%Y%m%d%H%M%S')
    z = d.utcoffset()
    if z is not None:
        z = z.seconds
    elif time.daylight:
        z = time.altzone
    else:
        z = time.timezone
    if z == 0:
        r += 'Z'
    elif z < 0:
        r += "+%02d'%02d'" % (-z // 3600, -z % 3600)
    else:
        r += "-%02d'%02d'" % (z // 3600, z % 3600)
    return r

def _calculate_quad_point_coordinates(x, y, width, height, angle=0):
    angle = math.radians(-angle)
    sin_angle = math.sin(angle)
    cos_angle = math.cos(angle)
    a = x + height * sin_angle
    b = y + height * cos_angle
    c = x + width * cos_angle + height * sin_angle
    d = y - width * sin_angle + height * cos_angle
    e = x + width * cos_angle
    f = y - width * sin_angle
    return ((x, y), (e, f), (c, d), (a, b))

def _get_coordinates_of_block(x, y, width, height, angle=0):
    vertices = _calculate_quad_point_coordinates(x, y, width, height, angle)
    pad = 1e-05 if angle % 90 else 0
    min_x = min((v[0] for v in vertices)) - pad
    min_y = min((v[1] for v in vertices)) - pad
    max_x = max((v[0] for v in vertices)) + pad
    max_y = max((v[1] for v in vertices)) + pad
    return (tuple(itertools.chain.from_iterable(vertices)), (min_x, min_y, max_x, max_y))

def _get_link_annotation(gc, x, y, width, height, angle=0):
    (quadpoints, rect) = _get_coordinates_of_block(x, y, width, height, angle)
    link_annotation = {'Type': Name('Annot'), 'Subtype': Name('Link'), 'Rect': rect, 'Border': [0, 0, 0], 'A': {'S': Name('URI'), 'URI': gc.get_url()}}
    if angle % 90:
        link_annotation['QuadPoints'] = quadpoints
    return link_annotation
_str_escapes = str.maketrans({'\\': '\\\\', '(': '\\(', ')': '\\)', '\n': '\\n', '\r': '\\r'})

def pdfRepr(obj):
    if hasattr(obj, 'pdfRepr'):
        return obj.pdfRepr()
    elif isinstance(obj, (float, np.floating)):
        if not np.isfinite(obj):
            raise ValueError('Can only output finite numbers in PDF')
        r = b'%.10f' % obj
        return r.rstrip(b'0').rstrip(b'.')
    elif isinstance(obj, bool):
        return [b'false', b'true'][obj]
    elif isinstance(obj, (int, np.integer)):
        return b'%d' % obj
    elif isinstance(obj, str):
        return pdfRepr(obj.encode('ascii') if obj.isascii() else codecs.BOM_UTF16_BE + obj.encode('UTF-16BE'))
    elif isinstance(obj, bytes):
        return b'(' + obj.decode('latin-1').translate(_str_escapes).encode('latin-1') + b')'
    elif isinstance(obj, dict):
        return _fill([b'<<', *[Name(k).pdfRepr() + b' ' + pdfRepr(v) for (k, v) in obj.items()], b'>>'])
    elif isinstance(obj, (list, tuple)):
        return _fill([b'[', *[pdfRepr(val) for val in obj], b']'])
    elif obj is None:
        return b'null'
    elif isinstance(obj, datetime):
        return pdfRepr(_datetime_to_pdf(obj))
    elif isinstance(obj, BboxBase):
        return _fill([pdfRepr(val) for val in obj.bounds])
    else:
        raise TypeError(f"Don't know a PDF representation for {type(obj)} objects")

def _font_supports_glyph(fonttype, glyph):
    if fonttype == 3:
        return glyph <= 255
    if fonttype == 42:
        return glyph <= 65535
    raise NotImplementedError()

class Reference:

    def __init__(self, id):
        self.id = id

    def __repr__(self):
        return '<Reference %d>' % self.id

    def pdfRepr(self):
        return b'%d 0 R' % self.id

    def write(self, contents, file):
        write = file.write
        write(b'%d 0 obj\n' % self.id)
        write(pdfRepr(contents))
        write(b'\nendobj\n')

@total_ordering
class Name:
    __slots__ = ('name',)
    _hexify = {c: '#%02x' % c for c in {*range(256)} - {*range(ord('!'), ord('~') + 1)}}

    def __init__(self, name):
        if isinstance(name, Name):
            self.name = name.name
        else:
            if isinstance(name, bytes):
                name = name.decode('ascii')
            self.name = name.translate(self._hexify).encode('ascii')

    def __repr__(self):
        return '<Name %s>' % self.name

    def __str__(self):
        return '/' + self.name.decode('ascii')

    def __eq__(self, other):
        return isinstance(other, Name) and self.name == other.name

    def __lt__(self, other):
        return isinstance(other, Name) and self.name < other.name

    def __hash__(self):
        return hash(self.name)

    def pdfRepr(self):
        return b'/' + self.name

class Verbatim:

    def __init__(self, x):
        self._x = x

    def pdfRepr(self):
        return self._x

class Op(Enum):
    close_fill_stroke = b'b'
    fill_stroke = b'B'
    fill = b'f'
    closepath = b'h'
    close_stroke = b's'
    stroke = b'S'
    endpath = b'n'
    begin_text = b'BT'
    end_text = b'ET'
    curveto = b'c'
    rectangle = b're'
    lineto = b'l'
    moveto = b'm'
    concat_matrix = b'cm'
    use_xobject = b'Do'
    setgray_stroke = b'G'
    setgray_nonstroke = b'g'
    setrgb_stroke = b'RG'
    setrgb_nonstroke = b'rg'
    setcolorspace_stroke = b'CS'
    setcolorspace_nonstroke = b'cs'
    setcolor_stroke = b'SCN'
    setcolor_nonstroke = b'scn'
    setdash = b'd'
    setlinejoin = b'j'
    setlinecap = b'J'
    setgstate = b'gs'
    gsave = b'q'
    grestore = b'Q'
    textpos = b'Td'
    selectfont = b'Tf'
    textmatrix = b'Tm'
    show = b'Tj'
    showkern = b'TJ'
    setlinewidth = b'w'
    clip = b'W'
    shading = b'sh'

    def pdfRepr(self):
        return self.value

    @classmethod
    def paint_path(cls, fill, stroke):
        if stroke:
            if fill:
                return cls.fill_stroke
            else:
                return cls.stroke
        elif fill:
            return cls.fill
        else:
            return cls.endpath

class Stream:
    __slots__ = ('id', 'len', 'pdfFile', 'file', 'compressobj', 'extra', 'pos')

    def __init__(self, id, len, file, extra=None, png=None):
        self.id = id
        self.len = len
        self.pdfFile = file
        self.file = file.fh
        self.compressobj = None
        if extra is None:
            self.extra = dict()
        else:
            self.extra = extra.copy()
        if png is not None:
            self.extra.update({'Filter': Name('FlateDecode'), 'DecodeParms': png})
        self.pdfFile.recordXref(self.id)
        if mpl.rcParams['pdf.compression'] and (not png):
            self.compressobj = zlib.compressobj(mpl.rcParams['pdf.compression'])
        if self.len is None:
            self.file = BytesIO()
        else:
            self._writeHeader()
            self.pos = self.file.tell()

    def _writeHeader(self):
        write = self.file.write
        write(b'%d 0 obj\n' % self.id)
        dict = self.extra
        dict['Length'] = self.len
        if mpl.rcParams['pdf.compression']:
            dict['Filter'] = Name('FlateDecode')
        write(pdfRepr(dict))
        write(b'\nstream\n')

    def end(self):
        self._flush()
        if self.len is None:
            contents = self.file.getvalue()
            self.len = len(contents)
            self.file = self.pdfFile.fh
            self._writeHeader()
            self.file.write(contents)
            self.file.write(b'\nendstream\nendobj\n')
        else:
            length = self.file.tell() - self.pos
            self.file.write(b'\nendstream\nendobj\n')
            self.pdfFile.writeObject(self.len, length)

    def write(self, data):
        if self.compressobj is None:
            self.file.write(data)
        else:
            compressed = self.compressobj.compress(data)
            self.file.write(compressed)

    def _flush(self):
        if self.compressobj is not None:
            compressed = self.compressobj.flush()
            self.file.write(compressed)
            self.compressobj = None

def _get_pdf_charprocs(font_path, glyph_ids):
    font = get_font(font_path, hinting_factor=1)
    conv = 1000 / font.units_per_EM
    procs = {}
    for glyph_id in glyph_ids:
        g = font.load_glyph(glyph_id, LOAD_NO_SCALE)
        d1 = (np.array([g.horiAdvance, 0, *g.bbox]) * conv + 0.5).astype(int)
        (v, c) = font.get_path()
        v = (v * 64).astype(int)
        (quads,) = np.nonzero(c == 3)
        quads_on = quads[1::2]
        quads_mid_on = np.array(sorted({*quads_on} & {*quads - 1} & {*quads + 1}), int)
        implicit = quads_mid_on[(v[quads_mid_on] == ((v[quads_mid_on - 1] + v[quads_mid_on + 1]) / 2).astype(int)).all(axis=1)]
        if (font.postscript_name, glyph_id) in [('DejaVuSerif-Italic', 77), ('DejaVuSerif-Italic', 135)]:
            v[:, 0] -= 1
        v = (v * conv + 0.5).astype(int)
        v[implicit] = ((v[implicit - 1] + v[implicit + 1]) / 2).astype(int)
        procs[font.get_glyph_name(glyph_id)] = ' '.join(map(str, d1)).encode('ascii') + b' d1\n' + _path.convert_to_string(Path(v, c), None, None, False, None, -1, [b'm', b'l', b'', b'c', b'h'], True) + b'f'
    return procs

class PdfFile:

    def __init__(self, filename, metadata=None):
        super().__init__()
        self._object_seq = itertools.count(1)
        self.xrefTable = [[0, 65535, 'the zero object']]
        self.passed_in_file_object = False
        self.original_file_like = None
        self.tell_base = 0
        (fh, opened) = cbook.to_filehandle(filename, 'wb', return_opened=True)
        if not opened:
            try:
                self.tell_base = filename.tell()
            except OSError:
                fh = BytesIO()
                self.original_file_like = filename
            else:
                fh = filename
                self.passed_in_file_object = True
        self.fh = fh
        self.currentstream = None
        fh.write(b'%PDF-1.4\n')
        fh.write(b'%\xac\xdc \xab\xba\n')
        self.rootObject = self.reserveObject('root')
        self.pagesObject = self.reserveObject('pages')
        self.pageList = []
        self.fontObject = self.reserveObject('fonts')
        self._extGStateObject = self.reserveObject('extended graphics states')
        self.hatchObject = self.reserveObject('tiling patterns')
        self.gouraudObject = self.reserveObject('Gouraud triangles')
        self.XObjectObject = self.reserveObject('external objects')
        self.resourceObject = self.reserveObject('resources')
        root = {'Type': Name('Catalog'), 'Pages': self.pagesObject}
        self.writeObject(self.rootObject, root)
        self.infoDict = _create_pdf_info_dict('pdf', metadata or {})
        self.fontNames = {}
        self._internal_font_seq = (Name(f'F{i}') for i in itertools.count(1))
        self.dviFontInfo = {}
        self.type1Descriptors = {}
        self._character_tracker = _backend_pdf_ps.CharacterTracker()
        self.alphaStates = {}
        self._alpha_state_seq = (Name(f'A{i}') for i in itertools.count(1))
        self._soft_mask_states = {}
        self._soft_mask_seq = (Name(f'SM{i}') for i in itertools.count(1))
        self._soft_mask_groups = []
        self.hatchPatterns = {}
        self._hatch_pattern_seq = (Name(f'H{i}') for i in itertools.count(1))
        self.gouraudTriangles = []
        self._images = {}
        self._image_seq = (Name(f'I{i}') for i in itertools.count(1))
        self.markers = {}
        self.multi_byte_charprocs = {}
        self.paths = []
        self._annotations = []
        self.pageAnnotations = []
        procsets = [Name(x) for x in 'PDF Text ImageB ImageC ImageI'.split()]
        resources = {'Font': self.fontObject, 'XObject': self.XObjectObject, 'ExtGState': self._extGStateObject, 'Pattern': self.hatchObject, 'Shading': self.gouraudObject, 'ProcSet': procsets}
        self.writeObject(self.resourceObject, resources)

    def newPage(self, width, height):
        self.endStream()
        (self.width, self.height) = (width, height)
        contentObject = self.reserveObject('page contents')
        annotsObject = self.reserveObject('annotations')
        thePage = {'Type': Name('Page'), 'Parent': self.pagesObject, 'Resources': self.resourceObject, 'MediaBox': [0, 0, 72 * width, 72 * height], 'Contents': contentObject, 'Annots': annotsObject}
        pageObject = self.reserveObject('page')
        self.writeObject(pageObject, thePage)
        self.pageList.append(pageObject)
        self._annotations.append((annotsObject, self.pageAnnotations))
        self.beginStream(contentObject.id, self.reserveObject('length of content stream'))
        self.output(Name('DeviceRGB'), Op.setcolorspace_stroke)
        self.output(Name('DeviceRGB'), Op.setcolorspace_nonstroke)
        self.output(GraphicsContextPdf.joinstyles['round'], Op.setlinejoin)
        self.pageAnnotations = []

    def newTextnote(self, text, positionRect=[-100, -100, 0, 0]):
        theNote = {'Type': Name('Annot'), 'Subtype': Name('Text'), 'Contents': text, 'Rect': positionRect}
        self.pageAnnotations.append(theNote)

    def _get_subsetted_psname(self, ps_name, charmap):

        def toStr(n, base):
            if n < base:
                return string.ascii_uppercase[n]
            else:
                return toStr(n // base, base) + string.ascii_uppercase[n % base]
        hashed = hash(frozenset(charmap.keys())) % ((sys.maxsize + 1) * 2)
        prefix = toStr(hashed, 26)
        return prefix[:6] + '+' + ps_name

    def finalize(self):
        self.endStream()
        self._write_annotations()
        self.writeFonts()
        self.writeExtGSTates()
        self._write_soft_mask_groups()
        self.writeHatches()
        self.writeGouraudTriangles()
        xobjects = {name: ob for (image, name, ob) in self._images.values()}
        for tup in self.markers.values():
            xobjects[tup[0]] = tup[1]
        for (name, value) in self.multi_byte_charprocs.items():
            xobjects[name] = value
        for (name, path, trans, ob, join, cap, padding, filled, stroked) in self.paths:
            xobjects[name] = ob
        self.writeObject(self.XObjectObject, xobjects)
        self.writeImages()
        self.writeMarkers()
        self.writePathCollectionTemplates()
        self.writeObject(self.pagesObject, {'Type': Name('Pages'), 'Kids': self.pageList, 'Count': len(self.pageList)})
        self.writeInfoDict()
        self.writeXref()
        self.writeTrailer()

    def close(self):
        self.endStream()
        if self.passed_in_file_object:
            self.fh.flush()
        else:
            if self.original_file_like is not None:
                self.original_file_like.write(self.fh.getvalue())
            self.fh.close()

    def write(self, data):
        if self.currentstream is None:
            self.fh.write(data)
        else:
            self.currentstream.write(data)

    def output(self, *data):
        self.write(_fill([pdfRepr(x) for x in data]))
        self.write(b'\n')

    def beginStream(self, id, len, extra=None, png=None):
        assert self.currentstream is None
        self.currentstream = Stream(id, len, self, extra, png)

    def endStream(self):
        if self.currentstream is not None:
            self.currentstream.end()
            self.currentstream = None

    def outputStream(self, ref, data, *, extra=None):
        self.beginStream(ref.id, None, extra)
        self.currentstream.write(data)
        self.endStream()

    def _write_annotations(self):
        for (annotsObject, annotations) in self._annotations:
            self.writeObject(annotsObject, annotations)

    def fontName(self, fontprop):
        if isinstance(fontprop, str):
            filenames = [fontprop]
        elif mpl.rcParams['pdf.use14corefonts']:
            filenames = _fontManager._find_fonts_by_props(fontprop, fontext='afm', directory=RendererPdf._afm_font_dir)
        else:
            filenames = _fontManager._find_fonts_by_props(fontprop)
        first_Fx = None
        for fname in filenames:
            Fx = self.fontNames.get(fname)
            if not first_Fx:
                first_Fx = Fx
            if Fx is None:
                Fx = next(self._internal_font_seq)
                self.fontNames[fname] = Fx
                _log.debug('Assigning font %s = %r', Fx, fname)
                if not first_Fx:
                    first_Fx = Fx
        return first_Fx

    def dviFontName(self, dvifont):
        dvi_info = self.dviFontInfo.get(dvifont.texname)
        if dvi_info is not None:
            return dvi_info.pdfname
        tex_font_map = dviread.PsfontsMap(dviread.find_tex_file('pdftex.map'))
        psfont = tex_font_map[dvifont.texname]
        if psfont.filename is None:
            raise ValueError('No usable font file found for {} (TeX: {}); the font may lack a Type-1 version'.format(psfont.psname, dvifont.texname))
        pdfname = next(self._internal_font_seq)
        _log.debug('Assigning font %s = %s (dvi)', pdfname, dvifont.texname)
        self.dviFontInfo[dvifont.texname] = types.SimpleNamespace(dvifont=dvifont, pdfname=pdfname, fontfile=psfont.filename, basefont=psfont.psname, encodingfile=psfont.encoding, effects=psfont.effects)
        return pdfname

    def writeFonts(self):
        fonts = {}
        for (dviname, info) in sorted(self.dviFontInfo.items()):
            Fx = info.pdfname
            _log.debug('Embedding Type-1 font %s from dvi.', dviname)
            fonts[Fx] = self._embedTeXFont(info)
        for filename in sorted(self.fontNames):
            Fx = self.fontNames[filename]
            _log.debug('Embedding font %s.', filename)
            if filename.endswith('.afm'):
                _log.debug('Writing AFM font.')
                fonts[Fx] = self._write_afm_font(filename)
            else:
                _log.debug('Writing TrueType font.')
                chars = self._character_tracker.used.get(filename)
                if chars:
                    fonts[Fx] = self.embedTTF(filename, chars)
        self.writeObject(self.fontObject, fonts)

    def _write_afm_font(self, filename):
        with open(filename, 'rb') as fh:
            font = AFM(fh)
        fontname = font.get_fontname()
        fontdict = {'Type': Name('Font'), 'Subtype': Name('Type1'), 'BaseFont': Name(fontname), 'Encoding': Name('WinAnsiEncoding')}
        fontdictObject = self.reserveObject('font dictionary')
        self.writeObject(fontdictObject, fontdict)
        return fontdictObject

    def _embedTeXFont(self, fontinfo):
        _log.debug('Embedding TeX font %s - fontinfo=%s', fontinfo.dvifont.texname, fontinfo.__dict__)
        widthsObject = self.reserveObject('font widths')
        self.writeObject(widthsObject, fontinfo.dvifont.widths)
        fontdictObject = self.reserveObject('font dictionary')
        fontdict = {'Type': Name('Font'), 'Subtype': Name('Type1'), 'FirstChar': 0, 'LastChar': len(fontinfo.dvifont.widths) - 1, 'Widths': widthsObject}
        if fontinfo.encodingfile is not None:
            fontdict['Encoding'] = {'Type': Name('Encoding'), 'Differences': [0, *map(Name, dviread._parse_enc(fontinfo.encodingfile))]}
        if fontinfo.fontfile is None:
            _log.warning('Because of TeX configuration (pdftex.map, see updmap option pdftexDownloadBase14) the font %s is not embedded. This is deprecated as of PDF 1.5 and it may cause the consumer application to show something that was not intended.', fontinfo.basefont)
            fontdict['BaseFont'] = Name(fontinfo.basefont)
            self.writeObject(fontdictObject, fontdict)
            return fontdictObject
        t1font = _type1font.Type1Font(fontinfo.fontfile)
        if fontinfo.effects:
            t1font = t1font.transform(fontinfo.effects)
        fontdict['BaseFont'] = Name(t1font.prop['FontName'])
        effects = (fontinfo.effects.get('slant', 0.0), fontinfo.effects.get('extend', 1.0))
        fontdesc = self.type1Descriptors.get((fontinfo.fontfile, effects))
        if fontdesc is None:
            fontdesc = self.createType1Descriptor(t1font, fontinfo.fontfile)
            self.type1Descriptors[fontinfo.fontfile, effects] = fontdesc
        fontdict['FontDescriptor'] = fontdesc
        self.writeObject(fontdictObject, fontdict)
        return fontdictObject

    def createType1Descriptor(self, t1font, fontfile):
        fontdescObject = self.reserveObject('font descriptor')
        fontfileObject = self.reserveObject('font file')
        italic_angle = t1font.prop['ItalicAngle']
        fixed_pitch = t1font.prop['isFixedPitch']
        flags = 0
        if fixed_pitch:
            flags |= 1 << 0
        if 0:
            flags |= 1 << 1
        if 1:
            flags |= 1 << 2
        else:
            flags |= 1 << 5
        if italic_angle:
            flags |= 1 << 6
        if 0:
            flags |= 1 << 16
        if 0:
            flags |= 1 << 17
        if 0:
            flags |= 1 << 18
        ft2font = get_font(fontfile)
        descriptor = {'Type': Name('FontDescriptor'), 'FontName': Name(t1font.prop['FontName']), 'Flags': flags, 'FontBBox': ft2font.bbox, 'ItalicAngle': italic_angle, 'Ascent': ft2font.ascender, 'Descent': ft2font.descender, 'CapHeight': 1000, 'XHeight': 500, 'FontFile': fontfileObject, 'FontFamily': t1font.prop['FamilyName'], 'StemV': 50}
        self.writeObject(fontdescObject, descriptor)
        self.outputStream(fontfileObject, b''.join(t1font.parts[:2]), extra={'Length1': len(t1font.parts[0]), 'Length2': len(t1font.parts[1]), 'Length3': 0})
        return fontdescObject

    def _get_xobject_glyph_name(self, filename, glyph_name):
        Fx = self.fontName(filename)
        return '-'.join([Fx.name.decode(), os.path.splitext(os.path.basename(filename))[0], glyph_name])
    _identityToUnicodeCMap = b'/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo\n<< /Registry (Adobe)\n   /Ordering (UCS)\n   /Supplement 0\n>> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <ffff>\nendcodespacerange\n%d beginbfrange\n%s\nendbfrange\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend'

    def embedTTF(self, filename, characters):
        font = get_font(filename)
        fonttype = mpl.rcParams['pdf.fonttype']

        def cvt(length, upe=font.units_per_EM, nearest=True):
            value = length / upe * 1000
            if nearest:
                return round(value)
            if value < 0:
                return math.floor(value)
            else:
                return math.ceil(value)

        def embedTTFType3(font, characters, descriptor):
            widthsObject = self.reserveObject('font widths')
            fontdescObject = self.reserveObject('font descriptor')
            fontdictObject = self.reserveObject('font dictionary')
            charprocsObject = self.reserveObject('character procs')
            differencesArray = []
            (firstchar, lastchar) = (0, 255)
            bbox = [cvt(x, nearest=False) for x in font.bbox]
            fontdict = {'Type': Name('Font'), 'BaseFont': ps_name, 'FirstChar': firstchar, 'LastChar': lastchar, 'FontDescriptor': fontdescObject, 'Subtype': Name('Type3'), 'Name': descriptor['FontName'], 'FontBBox': bbox, 'FontMatrix': [0.001, 0, 0, 0.001, 0, 0], 'CharProcs': charprocsObject, 'Encoding': {'Type': Name('Encoding'), 'Differences': differencesArray}, 'Widths': widthsObject}
            from encodings import cp1252

            def get_char_width(charcode):
                s = ord(cp1252.decoding_table[charcode])
                width = font.load_char(s, flags=LOAD_NO_SCALE | LOAD_NO_HINTING).horiAdvance
                return cvt(width)
            with warnings.catch_warnings():
                warnings.filterwarnings('ignore')
                widths = [get_char_width(charcode) for charcode in range(firstchar, lastchar + 1)]
            descriptor['MaxWidth'] = max(widths)
            glyph_ids = []
            differences = []
            multi_byte_chars = set()
            for c in characters:
                ccode = c
                gind = font.get_char_index(ccode)
                glyph_ids.append(gind)
                glyph_name = font.get_glyph_name(gind)
                if ccode <= 255:
                    differences.append((ccode, glyph_name))
                else:
                    multi_byte_chars.add(glyph_name)
            differences.sort()
            last_c = -2
            for (c, name) in differences:
                if c != last_c + 1:
                    differencesArray.append(c)
                differencesArray.append(Name(name))
                last_c = c
            rawcharprocs = _get_pdf_charprocs(filename, glyph_ids)
            charprocs = {}
            for charname in sorted(rawcharprocs):
                stream = rawcharprocs[charname]
                charprocDict = {}
                if charname in multi_byte_chars:
                    charprocDict = {'Type': Name('XObject'), 'Subtype': Name('Form'), 'BBox': bbox}
                    stream = stream[stream.find(b'd1') + 2:]
                charprocObject = self.reserveObject('charProc')
                self.outputStream(charprocObject, stream, extra=charprocDict)
                if charname in multi_byte_chars:
                    name = self._get_xobject_glyph_name(filename, charname)
                    self.multi_byte_charprocs[name] = charprocObject
                else:
                    charprocs[charname] = charprocObject
            self.writeObject(fontdictObject, fontdict)
            self.writeObject(fontdescObject, descriptor)
            self.writeObject(widthsObject, widths)
            self.writeObject(charprocsObject, charprocs)
            return fontdictObject

        def embedTTFType42(font, characters, descriptor):
            fontdescObject = self.reserveObject('font descriptor')
            cidFontDictObject = self.reserveObject('CID font dictionary')
            type0FontDictObject = self.reserveObject('Type 0 font dictionary')
            cidToGidMapObject = self.reserveObject('CIDToGIDMap stream')
            fontfileObject = self.reserveObject('font file stream')
            wObject = self.reserveObject('Type 0 widths')
            toUnicodeMapObject = self.reserveObject('ToUnicode map')
            subset_str = ''.join((chr(c) for c in characters))
            _log.debug('SUBSET %s characters: %s', filename, subset_str)
            fontdata = _backend_pdf_ps.get_glyphs_subset(filename, subset_str)
            _log.debug('SUBSET %s %d -> %d', filename, os.stat(filename).st_size, fontdata.getbuffer().nbytes)
            full_font = font
            font = FT2Font(fontdata)
            cidFontDict = {'Type': Name('Font'), 'Subtype': Name('CIDFontType2'), 'BaseFont': ps_name, 'CIDSystemInfo': {'Registry': 'Adobe', 'Ordering': 'Identity', 'Supplement': 0}, 'FontDescriptor': fontdescObject, 'W': wObject, 'CIDToGIDMap': cidToGidMapObject}
            type0FontDict = {'Type': Name('Font'), 'Subtype': Name('Type0'), 'BaseFont': ps_name, 'Encoding': Name('Identity-H'), 'DescendantFonts': [cidFontDictObject], 'ToUnicode': toUnicodeMapObject}
            descriptor['FontFile2'] = fontfileObject
            self.outputStream(fontfileObject, fontdata.getvalue(), extra={'Length1': fontdata.getbuffer().nbytes})
            cid_to_gid_map = ['\x00'] * 65536
            widths = []
            max_ccode = 0
            for c in characters:
                ccode = c
                gind = font.get_char_index(ccode)
                glyph = font.load_char(ccode, flags=LOAD_NO_SCALE | LOAD_NO_HINTING)
                widths.append((ccode, cvt(glyph.horiAdvance)))
                if ccode < 65536:
                    cid_to_gid_map[ccode] = chr(gind)
                max_ccode = max(ccode, max_ccode)
            widths.sort()
            cid_to_gid_map = cid_to_gid_map[:max_ccode + 1]
            last_ccode = -2
            w = []
            max_width = 0
            unicode_groups = []
            for (ccode, width) in widths:
                if ccode != last_ccode + 1:
                    w.append(ccode)
                    w.append([width])
                    unicode_groups.append([ccode, ccode])
                else:
                    w[-1].append(width)
                    unicode_groups[-1][1] = ccode
                max_width = max(max_width, width)
                last_ccode = ccode
            unicode_bfrange = []
            for (start, end) in unicode_groups:
                if start > 65535:
                    continue
                end = min(65535, end)
                unicode_bfrange.append(b'<%04x> <%04x> [%s]' % (start, end, b' '.join((b'<%04x>' % x for x in range(start, end + 1)))))
            unicode_cmap = self._identityToUnicodeCMap % (len(unicode_groups), b'\n'.join(unicode_bfrange))
            glyph_ids = []
            for ccode in characters:
                if not _font_supports_glyph(fonttype, ccode):
                    gind = full_font.get_char_index(ccode)
                    glyph_ids.append(gind)
            bbox = [cvt(x, nearest=False) for x in full_font.bbox]
            rawcharprocs = _get_pdf_charprocs(filename, glyph_ids)
            for charname in sorted(rawcharprocs):
                stream = rawcharprocs[charname]
                charprocDict = {'Type': Name('XObject'), 'Subtype': Name('Form'), 'BBox': bbox}
                stream = stream[stream.find(b'd1') + 2:]
                charprocObject = self.reserveObject('charProc')
                self.outputStream(charprocObject, stream, extra=charprocDict)
                name = self._get_xobject_glyph_name(filename, charname)
                self.multi_byte_charprocs[name] = charprocObject
            cid_to_gid_map = ''.join(cid_to_gid_map).encode('utf-16be')
            self.outputStream(cidToGidMapObject, cid_to_gid_map)
            self.outputStream(toUnicodeMapObject, unicode_cmap)
            descriptor['MaxWidth'] = max_width
            self.writeObject(cidFontDictObject, cidFontDict)
            self.writeObject(type0FontDictObject, type0FontDict)
            self.writeObject(fontdescObject, descriptor)
            self.writeObject(wObject, w)
            return type0FontDictObject
        ps_name = self._get_subsetted_psname(font.postscript_name, font.get_charmap())
        ps_name = ps_name.encode('ascii', 'replace')
        ps_name = Name(ps_name)
        pclt = font.get_sfnt_table('pclt') or {'capHeight': 0, 'xHeight': 0}
        post = font.get_sfnt_table('post') or {'italicAngle': (0, 0)}
        ff = font.face_flags
        sf = font.style_flags
        flags = 0
        symbolic = False
        if ff & FIXED_WIDTH:
            flags |= 1 << 0
        if 0:
            flags |= 1 << 1
        if symbolic:
            flags |= 1 << 2
        else:
            flags |= 1 << 5
        if sf & ITALIC:
            flags |= 1 << 6
        if 0:
            flags |= 1 << 16
        if 0:
            flags |= 1 << 17
        if 0:
            flags |= 1 << 18
        descriptor = {'Type': Name('FontDescriptor'), 'FontName': ps_name, 'Flags': flags, 'FontBBox': [cvt(x, nearest=False) for x in font.bbox], 'Ascent': cvt(font.ascender, nearest=False), 'Descent': cvt(font.descender, nearest=False), 'CapHeight': cvt(pclt['capHeight'], nearest=False), 'XHeight': cvt(pclt['xHeight']), 'ItalicAngle': post['italicAngle'][1], 'StemV': 0}
        if fonttype == 3:
            return embedTTFType3(font, characters, descriptor)
        elif fonttype == 42:
            return embedTTFType42(font, characters, descriptor)

    def alphaState(self, alpha):
        state = self.alphaStates.get(alpha, None)
        if state is not None:
            return state[0]
        name = next(self._alpha_state_seq)
        self.alphaStates[alpha] = (name, {'Type': Name('ExtGState'), 'CA': alpha[0], 'ca': alpha[1]})
        return name

    def _soft_mask_state(self, smask):
        state = self._soft_mask_states.get(smask, None)
        if state is not None:
            return state[0]
        name = next(self._soft_mask_seq)
        groupOb = self.reserveObject('transparency group for soft mask')
        self._soft_mask_states[smask] = (name, {'Type': Name('ExtGState'), 'AIS': False, 'SMask': {'Type': Name('Mask'), 'S': Name('Luminosity'), 'BC': [1], 'G': groupOb}})
        self._soft_mask_groups.append((groupOb, {'Type': Name('XObject'), 'Subtype': Name('Form'), 'FormType': 1, 'Group': {'S': Name('Transparency'), 'CS': Name('DeviceGray')}, 'Matrix': [1, 0, 0, 1, 0, 0], 'Resources': {'Shading': {'S': smask}}, 'BBox': [0, 0, 1, 1]}, [Name('S'), Op.shading]))
        return name

    def writeExtGSTates(self):
        self.writeObject(self._extGStateObject, dict([*self.alphaStates.values(), *self._soft_mask_states.values()]))

    def _write_soft_mask_groups(self):
        for (ob, attributes, content) in self._soft_mask_groups:
            self.beginStream(ob.id, None, attributes)
            self.output(*content)
            self.endStream()

    def hatchPattern(self, hatch_style):
        if hatch_style is not None:
            (edge, face, hatch) = hatch_style
            if edge is not None:
                edge = tuple(edge)
            if face is not None:
                face = tuple(face)
            hatch_style = (edge, face, hatch)
        pattern = self.hatchPatterns.get(hatch_style, None)
        if pattern is not None:
            return pattern
        name = next(self._hatch_pattern_seq)
        self.hatchPatterns[hatch_style] = name
        return name

    def writeHatches(self):
        hatchDict = dict()
        sidelen = 72.0
        for (hatch_style, name) in self.hatchPatterns.items():
            ob = self.reserveObject('hatch pattern')
            hatchDict[name] = ob
            res = {'Procsets': [Name(x) for x in 'PDF Text ImageB ImageC ImageI'.split()]}
            self.beginStream(ob.id, None, {'Type': Name('Pattern'), 'PatternType': 1, 'PaintType': 1, 'TilingType': 1, 'BBox': [0, 0, sidelen, sidelen], 'XStep': sidelen, 'YStep': sidelen, 'Resources': res, 'Matrix': [1, 0, 0, 1, 0, self.height * 72]})
            (stroke_rgb, fill_rgb, hatch) = hatch_style
            self.output(stroke_rgb[0], stroke_rgb[1], stroke_rgb[2], Op.setrgb_stroke)
            if fill_rgb is not None:
                self.output(fill_rgb[0], fill_rgb[1], fill_rgb[2], Op.setrgb_nonstroke, 0, 0, sidelen, sidelen, Op.rectangle, Op.fill)
            self.output(mpl.rcParams['hatch.linewidth'], Op.setlinewidth)
            self.output(*self.pathOperations(Path.hatch(hatch), Affine2D().scale(sidelen), simplify=False))
            self.output(Op.fill_stroke)
            self.endStream()
        self.writeObject(self.hatchObject, hatchDict)

    def addGouraudTriangles(self, points, colors):
        name = Name('GT%d' % len(self.gouraudTriangles))
        ob = self.reserveObject(f'Gouraud triangle {name}')
        self.gouraudTriangles.append((name, ob, points, colors))
        return (name, ob)

    def writeGouraudTriangles(self):
        gouraudDict = dict()
        for (name, ob, points, colors) in self.gouraudTriangles:
            gouraudDict[name] = ob
            shape = points.shape
            flat_points = points.reshape((shape[0] * shape[1], 2))
            colordim = colors.shape[2]
            assert colordim in (1, 4)
            flat_colors = colors.reshape((shape[0] * shape[1], colordim))
            if colordim == 4:
                colordim = 3
            points_min = np.min(flat_points, axis=0) - (1 << 8)
            points_max = np.max(flat_points, axis=0) + (1 << 8)
            factor = 4294967295 / (points_max - points_min)
            self.beginStream(ob.id, None, {'ShadingType': 4, 'BitsPerCoordinate': 32, 'BitsPerComponent': 8, 'BitsPerFlag': 8, 'ColorSpace': Name('DeviceRGB' if colordim == 3 else 'DeviceGray'), 'AntiAlias': False, 'Decode': [points_min[0], points_max[0], points_min[1], points_max[1]] + [0, 1] * colordim})
            streamarr = np.empty((shape[0] * shape[1],), dtype=[('flags', 'u1'), ('points', '>u4', (2,)), ('colors', 'u1', (colordim,))])
            streamarr['flags'] = 0
            streamarr['points'] = (flat_points - points_min) * factor
            streamarr['colors'] = flat_colors[:, :colordim] * 255.0
            self.write(streamarr.tobytes())
            self.endStream()
        self.writeObject(self.gouraudObject, gouraudDict)

    def imageObject(self, image):
        entry = self._images.get(id(image), None)
        if entry is not None:
            return entry[1]
        name = next(self._image_seq)
        ob = self.reserveObject(f'image {name}')
        self._images[id(image)] = (image, name, ob)
        return name

    def _unpack(self, im):
        im = im[::-1]
        if im.ndim == 2:
            return (im, None)
        else:
            rgb = im[:, :, :3]
            rgb = np.array(rgb, order='C')
            if im.shape[2] == 4:
                alpha = im[:, :, 3][..., None]
                if np.all(alpha == 255):
                    alpha = None
                else:
                    alpha = np.array(alpha, order='C')
            else:
                alpha = None
            return (rgb, alpha)

    def _writePng(self, img):
        buffer = BytesIO()
        img.save(buffer, format='png')
        buffer.seek(8)
        png_data = b''
        bit_depth = palette = None
        while True:
            (length, type) = struct.unpack(b'!L4s', buffer.read(8))
            if type in [b'IHDR', b'PLTE', b'IDAT']:
                data = buffer.read(length)
                if len(data) != length:
                    raise RuntimeError('truncated data')
                if type == b'IHDR':
                    bit_depth = int(data[8])
                elif type == b'PLTE':
                    palette = data
                elif type == b'IDAT':
                    png_data += data
            elif type == b'IEND':
                break
            else:
                buffer.seek(length, 1)
            buffer.seek(4, 1)
        return (png_data, bit_depth, palette)

    def _writeImg(self, data, id, smask=None):
        (height, width, color_channels) = data.shape
        obj = {'Type': Name('XObject'), 'Subtype': Name('Image'), 'Width': width, 'Height': height, 'ColorSpace': Name({1: 'DeviceGray', 3: 'DeviceRGB'}[color_channels]), 'BitsPerComponent': 8}
        if smask:
            obj['SMask'] = smask
        if mpl.rcParams['pdf.compression']:
            if data.shape[-1] == 1:
                data = data.squeeze(axis=-1)
            png = {'Predictor': 10, 'Colors': color_channels, 'Columns': width}
            img = Image.fromarray(data)
            img_colors = img.getcolors(maxcolors=256)
            if color_channels == 3 and img_colors is not None:
                num_colors = len(img_colors)
                palette = np.array([comp for (_, color) in img_colors for comp in color], dtype=np.uint8)
                palette24 = palette[0::3].astype(np.uint32) << 16 | palette[1::3].astype(np.uint32) << 8 | palette[2::3]
                rgb24 = data[:, :, 0].astype(np.uint32) << 16 | data[:, :, 1].astype(np.uint32) << 8 | data[:, :, 2]
                indices = np.argsort(palette24).astype(np.uint8)
                rgb8 = indices[np.searchsorted(palette24, rgb24, sorter=indices)]
                img = Image.fromarray(rgb8, mode='P')
                img.putpalette(palette)
                (png_data, bit_depth, palette) = self._writePng(img)
                if bit_depth is None or palette is None:
                    raise RuntimeError('invalid PNG header')
                palette = palette[:num_colors * 3]
                obj['ColorSpace'] = [Name('Indexed'), Name('DeviceRGB'), num_colors - 1, palette]
                obj['BitsPerComponent'] = bit_depth
                png['Colors'] = 1
                png['BitsPerComponent'] = bit_depth
            else:
                (png_data, _, _) = self._writePng(img)
        else:
            png = None
        self.beginStream(id, self.reserveObject('length of image stream'), obj, png=png)
        if png:
            self.currentstream.write(png_data)
        else:
            self.currentstream.write(data.tobytes())
        self.endStream()

    def writeImages(self):
        for (img, name, ob) in self._images.values():
            (data, adata) = self._unpack(img)
            if adata is not None:
                smaskObject = self.reserveObject('smask')
                self._writeImg(adata, smaskObject.id)
            else:
                smaskObject = None
            self._writeImg(data, ob.id, smaskObject)

    def markerObject(self, path, trans, fill, stroke, lw, joinstyle, capstyle):
        pathops = self.pathOperations(path, trans, simplify=False)
        key = (tuple(pathops), bool(fill), bool(stroke), joinstyle, capstyle)
        result = self.markers.get(key)
        if result is None:
            name = Name('M%d' % len(self.markers))
            ob = self.reserveObject('marker %d' % len(self.markers))
            bbox = path.get_extents(trans)
            self.markers[key] = [name, ob, bbox, lw]
        else:
            if result[-1] < lw:
                result[-1] = lw
            name = result[0]
        return name

    def writeMarkers(self):
        for ((pathops, fill, stroke, joinstyle, capstyle), (name, ob, bbox, lw)) in self.markers.items():
            bbox = bbox.padded(lw * 5)
            self.beginStream(ob.id, None, {'Type': Name('XObject'), 'Subtype': Name('Form'), 'BBox': list(bbox.extents)})
            self.output(GraphicsContextPdf.joinstyles[joinstyle], Op.setlinejoin)
            self.output(GraphicsContextPdf.capstyles[capstyle], Op.setlinecap)
            self.output(*pathops)
            self.output(Op.paint_path(fill, stroke))
            self.endStream()

    def pathCollectionObject(self, gc, path, trans, padding, filled, stroked):
        name = Name('P%d' % len(self.paths))
        ob = self.reserveObject('path %d' % len(self.paths))
        self.paths.append((name, path, trans, ob, gc.get_joinstyle(), gc.get_capstyle(), padding, filled, stroked))
        return name

    def writePathCollectionTemplates(self):
        for (name, path, trans, ob, joinstyle, capstyle, padding, filled, stroked) in self.paths:
            pathops = self.pathOperations(path, trans, simplify=False)
            bbox = path.get_extents(trans)
            if not np.all(np.isfinite(bbox.extents)):
                extents = [0, 0, 0, 0]
            else:
                bbox = bbox.padded(padding)
                extents = list(bbox.extents)
            self.beginStream(ob.id, None, {'Type': Name('XObject'), 'Subtype': Name('Form'), 'BBox': extents})
            self.output(GraphicsContextPdf.joinstyles[joinstyle], Op.setlinejoin)
            self.output(GraphicsContextPdf.capstyles[capstyle], Op.setlinecap)
            self.output(*pathops)
            self.output(Op.paint_path(filled, stroked))
            self.endStream()

    @staticmethod
    def pathOperations(path, transform, clip=None, simplify=None, sketch=None):
        return [Verbatim(_path.convert_to_string(path, transform, clip, simplify, sketch, 6, [Op.moveto.value, Op.lineto.value, b'', Op.curveto.value, Op.closepath.value], True))]

    def writePath(self, path, transform, clip=False, sketch=None):
        if clip:
            clip = (0.0, 0.0, self.width * 72, self.height * 72)
            simplify = path.should_simplify
        else:
            clip = None
            simplify = False
        cmds = self.pathOperations(path, transform, clip, simplify=simplify, sketch=sketch)
        self.output(*cmds)

    def reserveObject(self, name=''):
        id = next(self._object_seq)
        self.xrefTable.append([None, 0, name])
        return Reference(id)

    def recordXref(self, id):
        self.xrefTable[id][0] = self.fh.tell() - self.tell_base

    def writeObject(self, object, contents):
        self.recordXref(object.id)
        object.write(contents, self)

    def writeXref(self):
        self.startxref = self.fh.tell() - self.tell_base
        self.write(b'xref\n0 %d\n' % len(self.xrefTable))
        for (i, (offset, generation, name)) in enumerate(self.xrefTable):
            if offset is None:
                raise AssertionError('No offset for object %d (%s)' % (i, name))
            else:
                key = b'f' if name == 'the zero object' else b'n'
                text = b'%010d %05d %b \n' % (offset, generation, key)
                self.write(text)

    def writeInfoDict(self):
        self.infoObject = self.reserveObject('info')
        self.writeObject(self.infoObject, self.infoDict)

    def writeTrailer(self):
        self.write(b'trailer\n')
        self.write(pdfRepr({'Size': len(self.xrefTable), 'Root': self.rootObject, 'Info': self.infoObject}))
        self.write(b'\nstartxref\n%d\n%%%%EOF\n' % self.startxref)

class RendererPdf(_backend_pdf_ps.RendererPDFPSBase):
    _afm_font_dir = cbook._get_data_path('fonts/pdfcorefonts')
    _use_afm_rc_name = 'pdf.use14corefonts'

    def __init__(self, file, image_dpi, height, width):
        super().__init__(width, height)
        self.file = file
        self.gc = self.new_gc()
        self.image_dpi = image_dpi

    def finalize(self):
        self.file.output(*self.gc.finalize())

    def check_gc(self, gc, fillcolor=None):
        orig_fill = getattr(gc, '_fillcolor', (0.0, 0.0, 0.0))
        gc._fillcolor = fillcolor
        orig_alphas = getattr(gc, '_effective_alphas', (1.0, 1.0))
        if gc.get_rgb() is None:
            gc.set_foreground((0, 0, 0, 0), isRGBA=True)
        if gc._forced_alpha:
            gc._effective_alphas = (gc._alpha, gc._alpha)
        elif fillcolor is None or len(fillcolor) < 4:
            gc._effective_alphas = (gc._rgb[3], 1.0)
        else:
            gc._effective_alphas = (gc._rgb[3], fillcolor[3])
        delta = self.gc.delta(gc)
        if delta:
            self.file.output(*delta)
        gc._fillcolor = orig_fill
        gc._effective_alphas = orig_alphas

    def get_image_magnification(self):
        return self.image_dpi / 72.0

    def draw_image(self, gc, x, y, im, transform=None):
        (h, w) = im.shape[:2]
        if w == 0 or h == 0:
            return
        if transform is None:
            gc.set_alpha(1.0)
        self.check_gc(gc)
        w = 72.0 * w / self.image_dpi
        h = 72.0 * h / self.image_dpi
        imob = self.file.imageObject(im)
        if transform is None:
            self.file.output(Op.gsave, w, 0, 0, h, x, y, Op.concat_matrix, imob, Op.use_xobject, Op.grestore)
        else:
            (tr1, tr2, tr3, tr4, tr5, tr6) = transform.frozen().to_values()
            self.file.output(Op.gsave, 1, 0, 0, 1, x, y, Op.concat_matrix, tr1, tr2, tr3, tr4, tr5, tr6, Op.concat_matrix, imob, Op.use_xobject, Op.grestore)

    def draw_path(self, gc, path, transform, rgbFace=None):
        self.check_gc(gc, rgbFace)
        self.file.writePath(path, transform, rgbFace is None and gc.get_hatch_path() is None, gc.get_sketch_params())
        self.file.output(self.gc.paint())

    def draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
        can_do_optimization = True
        facecolors = np.asarray(facecolors)
        edgecolors = np.asarray(edgecolors)
        if not len(facecolors):
            filled = False
            can_do_optimization = not gc.get_hatch()
        elif np.all(facecolors[:, 3] == facecolors[0, 3]):
            filled = facecolors[0, 3] != 0.0
        else:
            can_do_optimization = False
        if not len(edgecolors):
            stroked = False
        elif np.all(np.asarray(linewidths) == 0.0):
            stroked = False
        elif np.all(edgecolors[:, 3] == edgecolors[0, 3]):
            stroked = edgecolors[0, 3] != 0.0
        else:
            can_do_optimization = False
        len_path = len(paths[0].vertices) if len(paths) > 0 else 0
        uses_per_path = self._iter_collection_uses_per_path(paths, all_transforms, offsets, facecolors, edgecolors)
        should_do_optimization = len_path + uses_per_path + 5 < len_path * uses_per_path
        if not can_do_optimization or not should_do_optimization:
            return RendererBase.draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position)
        padding = np.max(linewidths)
        path_codes = []
        for (i, (path, transform)) in enumerate(self._iter_collection_raw_paths(master_transform, paths, all_transforms)):
            name = self.file.pathCollectionObject(gc, path, transform, padding, filled, stroked)
            path_codes.append(name)
        output = self.file.output
        output(*self.gc.push())
        (lastx, lasty) = (0, 0)
        for (xo, yo, path_id, gc0, rgbFace) in self._iter_collection(gc, path_codes, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
            self.check_gc(gc0, rgbFace)
            (dx, dy) = (xo - lastx, yo - lasty)
            output(1, 0, 0, 1, dx, dy, Op.concat_matrix, path_id, Op.use_xobject)
            (lastx, lasty) = (xo, yo)
        output(*self.gc.pop())

    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
        len_marker_path = len(marker_path)
        uses = len(path)
        if len_marker_path * uses < len_marker_path + uses + 5:
            RendererBase.draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace)
            return
        self.check_gc(gc, rgbFace)
        fill = gc.fill(rgbFace)
        stroke = gc.stroke()
        output = self.file.output
        marker = self.file.markerObject(marker_path, marker_trans, fill, stroke, self.gc._linewidth, gc.get_joinstyle(), gc.get_capstyle())
        output(Op.gsave)
        (lastx, lasty) = (0, 0)
        for (vertices, code) in path.iter_segments(trans, clip=(0, 0, self.file.width * 72, self.file.height * 72), simplify=False):
            if len(vertices):
                (x, y) = vertices[-2:]
                if not (0 <= x <= self.file.width * 72 and 0 <= y <= self.file.height * 72):
                    continue
                (dx, dy) = (x - lastx, y - lasty)
                output(1, 0, 0, 1, dx, dy, Op.concat_matrix, marker, Op.use_xobject)
                (lastx, lasty) = (x, y)
        output(Op.grestore)

    def draw_gouraud_triangles(self, gc, points, colors, trans):
        assert len(points) == len(colors)
        if len(points) == 0:
            return
        assert points.ndim == 3
        assert points.shape[1] == 3
        assert points.shape[2] == 2
        assert colors.ndim == 3
        assert colors.shape[1] == 3
        assert colors.shape[2] in (1, 4)
        shape = points.shape
        points = points.reshape((shape[0] * shape[1], 2))
        tpoints = trans.transform(points)
        tpoints = tpoints.reshape(shape)
        (name, _) = self.file.addGouraudTriangles(tpoints, colors)
        output = self.file.output
        if colors.shape[2] == 1:
            gc.set_alpha(1.0)
            self.check_gc(gc)
            output(name, Op.shading)
            return
        alpha = colors[0, 0, 3]
        if np.allclose(alpha, colors[:, :, 3]):
            gc.set_alpha(alpha)
            self.check_gc(gc)
            output(name, Op.shading)
        else:
            alpha = colors[:, :, 3][:, :, None]
            (_, smask_ob) = self.file.addGouraudTriangles(tpoints, alpha)
            gstate = self.file._soft_mask_state(smask_ob)
            output(Op.gsave, gstate, Op.setgstate, name, Op.shading, Op.grestore)

    def _setup_textpos(self, x, y, angle, oldx=0, oldy=0, oldangle=0):
        if angle == oldangle == 0:
            self.file.output(x - oldx, y - oldy, Op.textpos)
        else:
            angle = math.radians(angle)
            self.file.output(math.cos(angle), math.sin(angle), -math.sin(angle), math.cos(angle), x, y, Op.textmatrix)
            self.file.output(0, 0, Op.textpos)

    def draw_mathtext(self, gc, x, y, s, prop, angle):
        (width, height, descent, glyphs, rects) = self._text2path.mathtext_parser.parse(s, 72, prop)
        if gc.get_url() is not None:
            self.file._annotations[-1][1].append(_get_link_annotation(gc, x, y, width, height, angle))
        fonttype = mpl.rcParams['pdf.fonttype']
        a = math.radians(angle)
        self.file.output(Op.gsave)
        self.file.output(math.cos(a), math.sin(a), -math.sin(a), math.cos(a), x, y, Op.concat_matrix)
        self.check_gc(gc, gc._rgb)
        prev_font = (None, None)
        (oldx, oldy) = (0, 0)
        unsupported_chars = []
        self.file.output(Op.begin_text)
        for (font, fontsize, num, ox, oy) in glyphs:
            self.file._character_tracker.track_glyph(font, num)
            fontname = font.fname
            if not _font_supports_glyph(fonttype, num):
                unsupported_chars.append((font, fontsize, ox, oy, num))
            else:
                self._setup_textpos(ox, oy, 0, oldx, oldy)
                (oldx, oldy) = (ox, oy)
                if (fontname, fontsize) != prev_font:
                    self.file.output(self.file.fontName(fontname), fontsize, Op.selectfont)
                    prev_font = (fontname, fontsize)
                self.file.output(self.encode_string(chr(num), fonttype), Op.show)
        self.file.output(Op.end_text)
        for (font, fontsize, ox, oy, num) in unsupported_chars:
            self._draw_xobject_glyph(font, fontsize, font.get_char_index(num), ox, oy)
        for (ox, oy, width, height) in rects:
            self.file.output(Op.gsave, ox, oy, width, height, Op.rectangle, Op.fill, Op.grestore)
        self.file.output(Op.grestore)

    def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
        texmanager = self.get_texmanager()
        fontsize = prop.get_size_in_points()
        dvifile = texmanager.make_dvi(s, fontsize)
        with dviread.Dvi(dvifile, 72) as dvi:
            (page,) = dvi
        if gc.get_url() is not None:
            self.file._annotations[-1][1].append(_get_link_annotation(gc, x, y, page.width, page.height, angle))
        (oldfont, seq) = (None, [])
        for (x1, y1, dvifont, glyph, width) in page.text:
            if dvifont != oldfont:
                pdfname = self.file.dviFontName(dvifont)
                seq += [['font', pdfname, dvifont.size]]
                oldfont = dvifont
            seq += [['text', x1, y1, [bytes([glyph])], x1 + width]]
        (i, curx, fontsize) = (0, 0, None)
        while i < len(seq) - 1:
            (elt, nxt) = seq[i:i + 2]
            if elt[0] == 'font':
                fontsize = elt[2]
            elif elt[0] == nxt[0] == 'text' and elt[2] == nxt[2]:
                offset = elt[4] - nxt[1]
                if abs(offset) < 0.1:
                    elt[3][-1] += nxt[3][0]
                    elt[4] += nxt[4] - nxt[1]
                else:
                    elt[3] += [offset * 1000.0 / fontsize, nxt[3][0]]
                    elt[4] = nxt[4]
                del seq[i + 1]
                continue
            i += 1
        mytrans = Affine2D().rotate_deg(angle).translate(x, y)
        self.check_gc(gc, gc._rgb)
        self.file.output(Op.begin_text)
        (curx, cury, oldx, oldy) = (0, 0, 0, 0)
        for elt in seq:
            if elt[0] == 'font':
                self.file.output(elt[1], elt[2], Op.selectfont)
            elif elt[0] == 'text':
                (curx, cury) = mytrans.transform((elt[1], elt[2]))
                self._setup_textpos(curx, cury, angle, oldx, oldy)
                (oldx, oldy) = (curx, cury)
                if len(elt[3]) == 1:
                    self.file.output(elt[3][0], Op.show)
                else:
                    self.file.output(elt[3], Op.showkern)
            else:
                assert False
        self.file.output(Op.end_text)
        boxgc = self.new_gc()
        boxgc.copy_properties(gc)
        boxgc.set_linewidth(0)
        pathops = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
        for (x1, y1, h, w) in page.boxes:
            path = Path([[x1, y1], [x1 + w, y1], [x1 + w, y1 + h], [x1, y1 + h], [0, 0]], pathops)
            self.draw_path(boxgc, path, mytrans, gc._rgb)

    def encode_string(self, s, fonttype):
        if fonttype in (1, 3):
            return s.encode('cp1252', 'replace')
        return s.encode('utf-16be', 'replace')

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        self.check_gc(gc, gc._rgb)
        if ismath:
            return self.draw_mathtext(gc, x, y, s, prop, angle)
        fontsize = prop.get_size_in_points()
        if mpl.rcParams['pdf.use14corefonts']:
            font = self._get_font_afm(prop)
            fonttype = 1
        else:
            font = self._get_font_ttf(prop)
            self.file._character_tracker.track(font, s)
            fonttype = mpl.rcParams['pdf.fonttype']
        if gc.get_url() is not None:
            font.set_text(s)
            (width, height) = font.get_width_height()
            self.file._annotations[-1][1].append(_get_link_annotation(gc, x, y, width / 64, height / 64, angle))
        if fonttype not in [3, 42]:
            self.file.output(Op.begin_text, self.file.fontName(prop), fontsize, Op.selectfont)
            self._setup_textpos(x, y, angle)
            self.file.output(self.encode_string(s, fonttype), Op.show, Op.end_text)
        else:
            singlebyte_chunks = []
            multibyte_glyphs = []
            prev_was_multibyte = True
            prev_font = font
            for item in _text_helpers.layout(s, font, kern_mode=KERNING_UNFITTED):
                if _font_supports_glyph(fonttype, ord(item.char)):
                    if prev_was_multibyte or item.ft_object != prev_font:
                        singlebyte_chunks.append((item.ft_object, item.x, []))
                        prev_font = item.ft_object
                    if item.prev_kern:
                        singlebyte_chunks[-1][2].append(item.prev_kern)
                    singlebyte_chunks[-1][2].append(item.char)
                    prev_was_multibyte = False
                else:
                    multibyte_glyphs.append((item.ft_object, item.x, item.glyph_idx))
                    prev_was_multibyte = True
            self.file.output(Op.gsave)
            a = math.radians(angle)
            self.file.output(math.cos(a), math.sin(a), -math.sin(a), math.cos(a), x, y, Op.concat_matrix)
            self.file.output(Op.begin_text)
            prev_start_x = 0
            for (ft_object, start_x, kerns_or_chars) in singlebyte_chunks:
                ft_name = self.file.fontName(ft_object.fname)
                self.file.output(ft_name, fontsize, Op.selectfont)
                self._setup_textpos(start_x, 0, 0, prev_start_x, 0, 0)
                self.file.output([-1000 * next(group) / fontsize if tp == float else self.encode_string(''.join(group), fonttype) for (tp, group) in itertools.groupby(kerns_or_chars, type)], Op.showkern)
                prev_start_x = start_x
            self.file.output(Op.end_text)
            for (ft_object, start_x, glyph_idx) in multibyte_glyphs:
                self._draw_xobject_glyph(ft_object, fontsize, glyph_idx, start_x, 0)
            self.file.output(Op.grestore)

    def _draw_xobject_glyph(self, font, fontsize, glyph_idx, x, y):
        glyph_name = font.get_glyph_name(glyph_idx)
        name = self.file._get_xobject_glyph_name(font.fname, glyph_name)
        self.file.output(Op.gsave, 0.001 * fontsize, 0, 0, 0.001 * fontsize, x, y, Op.concat_matrix, Name(name), Op.use_xobject, Op.grestore)

    def new_gc(self):
        return GraphicsContextPdf(self.file)

class GraphicsContextPdf(GraphicsContextBase):

    def __init__(self, file):
        super().__init__()
        self._fillcolor = (0.0, 0.0, 0.0)
        self._effective_alphas = (1.0, 1.0)
        self.file = file
        self.parent = None

    def __repr__(self):
        d = dict(self.__dict__)
        del d['file']
        del d['parent']
        return repr(d)

    def stroke(self):
        return self._linewidth > 0 and self._alpha > 0 and (len(self._rgb) <= 3 or self._rgb[3] != 0.0)

    def fill(self, *args):
        if len(args):
            _fillcolor = args[0]
        else:
            _fillcolor = self._fillcolor
        return self._hatch or (_fillcolor is not None and (len(_fillcolor) <= 3 or _fillcolor[3] != 0.0))

    def paint(self):
        return Op.paint_path(self.fill(), self.stroke())
    capstyles = {'butt': 0, 'round': 1, 'projecting': 2}
    joinstyles = {'miter': 0, 'round': 1, 'bevel': 2}

    def capstyle_cmd(self, style):
        return [self.capstyles[style], Op.setlinecap]

    def joinstyle_cmd(self, style):
        return [self.joinstyles[style], Op.setlinejoin]

    def linewidth_cmd(self, width):
        return [width, Op.setlinewidth]

    def dash_cmd(self, dashes):
        (offset, dash) = dashes
        if dash is None:
            dash = []
            offset = 0
        return [list(dash), offset, Op.setdash]

    def alpha_cmd(self, alpha, forced, effective_alphas):
        name = self.file.alphaState(effective_alphas)
        return [name, Op.setgstate]

    def hatch_cmd(self, hatch, hatch_color):
        if not hatch:
            if self._fillcolor is not None:
                return self.fillcolor_cmd(self._fillcolor)
            else:
                return [Name('DeviceRGB'), Op.setcolorspace_nonstroke]
        else:
            hatch_style = (hatch_color, self._fillcolor, hatch)
            name = self.file.hatchPattern(hatch_style)
            return [Name('Pattern'), Op.setcolorspace_nonstroke, name, Op.setcolor_nonstroke]

    def rgb_cmd(self, rgb):
        if mpl.rcParams['pdf.inheritcolor']:
            return []
        if rgb[0] == rgb[1] == rgb[2]:
            return [rgb[0], Op.setgray_stroke]
        else:
            return [*rgb[:3], Op.setrgb_stroke]

    def fillcolor_cmd(self, rgb):
        if rgb is None or mpl.rcParams['pdf.inheritcolor']:
            return []
        elif rgb[0] == rgb[1] == rgb[2]:
            return [rgb[0], Op.setgray_nonstroke]
        else:
            return [*rgb[:3], Op.setrgb_nonstroke]

    def push(self):
        parent = GraphicsContextPdf(self.file)
        parent.copy_properties(self)
        parent.parent = self.parent
        self.parent = parent
        return [Op.gsave]

    def pop(self):
        assert self.parent is not None
        self.copy_properties(self.parent)
        self.parent = self.parent.parent
        return [Op.grestore]

    def clip_cmd(self, cliprect, clippath):
        cmds = []
        while (self._cliprect, self._clippath) != (cliprect, clippath) and self.parent is not None:
            cmds.extend(self.pop())
        if (self._cliprect, self._clippath) != (cliprect, clippath) or self.parent is None:
            cmds.extend(self.push())
            if self._cliprect != cliprect:
                cmds.extend([cliprect, Op.rectangle, Op.clip, Op.endpath])
            if self._clippath != clippath:
                (path, affine) = clippath.get_transformed_path_and_affine()
                cmds.extend(PdfFile.pathOperations(path, affine, simplify=False) + [Op.clip, Op.endpath])
        return cmds
    commands = ((('_cliprect', '_clippath'), clip_cmd), (('_alpha', '_forced_alpha', '_effective_alphas'), alpha_cmd), (('_capstyle',), capstyle_cmd), (('_fillcolor',), fillcolor_cmd), (('_joinstyle',), joinstyle_cmd), (('_linewidth',), linewidth_cmd), (('_dashes',), dash_cmd), (('_rgb',), rgb_cmd), (('_hatch', '_hatch_color'), hatch_cmd))

    def delta(self, other):
        cmds = []
        fill_performed = False
        for (params, cmd) in self.commands:
            different = False
            for p in params:
                ours = getattr(self, p)
                theirs = getattr(other, p)
                try:
                    if ours is None or theirs is None:
                        different = ours is not theirs
                    else:
                        different = bool(ours != theirs)
                except ValueError:
                    ours = np.asarray(ours)
                    theirs = np.asarray(theirs)
                    different = ours.shape != theirs.shape or np.any(ours != theirs)
                if different:
                    break
            if params == ('_hatch', '_hatch_color') and fill_performed:
                different = True
            if different:
                if params == ('_fillcolor',):
                    fill_performed = True
                theirs = [getattr(other, p) for p in params]
                cmds.extend(cmd(self, *theirs))
                for p in params:
                    setattr(self, p, getattr(other, p))
        return cmds

    def copy_properties(self, other):
        super().copy_properties(other)
        fillcolor = getattr(other, '_fillcolor', self._fillcolor)
        effective_alphas = getattr(other, '_effective_alphas', self._effective_alphas)
        self._fillcolor = fillcolor
        self._effective_alphas = effective_alphas

    def finalize(self):
        cmds = []
        while self.parent is not None:
            cmds.extend(self.pop())
        return cmds

class PdfPages:
    _UNSET = object()

    def __init__(self, filename, keep_empty=_UNSET, metadata=None):
        self._filename = filename
        self._metadata = metadata
        self._file = None
        if keep_empty and keep_empty is not self._UNSET:
            _api.warn_deprecated('3.8', message='Keeping empty pdf files is deprecated since %(since)s and support will be removed %(removal)s.')
        self._keep_empty = keep_empty
    keep_empty = _api.deprecate_privatize_attribute('3.8')

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

    def _ensure_file(self):
        if self._file is None:
            self._file = PdfFile(self._filename, metadata=self._metadata)
        return self._file

    def close(self):
        if self._file is not None:
            self._file.finalize()
            self._file.close()
            self._file = None
        elif self._keep_empty:
            _api.warn_deprecated('3.8', message='Keeping empty pdf files is deprecated since %(since)s and support will be removed %(removal)s.')
            PdfFile(self._filename, metadata=self._metadata).close()

    def infodict(self):
        return self._ensure_file().infoDict

    def savefig(self, figure=None, **kwargs):
        if not isinstance(figure, Figure):
            if figure is None:
                manager = Gcf.get_active()
            else:
                manager = Gcf.get_fig_manager(figure)
            if manager is None:
                raise ValueError(f'No figure {figure}')
            figure = manager.canvas.figure
        figure.savefig(self, format='pdf', backend='pdf', **kwargs)

    def get_pagecount(self):
        return len(self._ensure_file().pageList)

    def attach_note(self, text, positionRect=[-100, -100, 0, 0]):
        self._ensure_file().newTextnote(text, positionRect)

class FigureCanvasPdf(FigureCanvasBase):
    fixed_dpi = 72
    filetypes = {'pdf': 'Portable Document Format'}

    def get_default_filetype(self):
        return 'pdf'

    def print_pdf(self, filename, *, bbox_inches_restore=None, metadata=None):
        dpi = self.figure.dpi
        self.figure.dpi = 72
        (width, height) = self.figure.get_size_inches()
        if isinstance(filename, PdfPages):
            file = filename._ensure_file()
        else:
            file = PdfFile(filename, metadata=metadata)
        try:
            file.newPage(width, height)
            renderer = MixedModeRenderer(self.figure, width, height, dpi, RendererPdf(file, dpi, height, width), bbox_inches_restore=bbox_inches_restore)
            self.figure.draw(renderer)
            renderer.finalize()
            if not isinstance(filename, PdfPages):
                file.finalize()
        finally:
            if isinstance(filename, PdfPages):
                file.endStream()
            else:
                file.close()

    def draw(self):
        self.figure.draw_without_rendering()
        return super().draw()
FigureManagerPdf = FigureManagerBase

@_Backend.export
class _BackendPdf(_Backend):
    FigureCanvas = FigureCanvasPdf

# File: matplotlib-main/lib/matplotlib/backends/backend_pgf.py
import codecs
import datetime
import functools
from io import BytesIO
import logging
import math
import os
import pathlib
import shutil
import subprocess
from tempfile import TemporaryDirectory
import weakref
from PIL import Image
import matplotlib as mpl
from matplotlib import _api, cbook, font_manager as fm
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, RendererBase
from matplotlib.backends.backend_mixed import MixedModeRenderer
from matplotlib.backends.backend_pdf import _create_pdf_info_dict, _datetime_to_pdf
from matplotlib.path import Path
from matplotlib.figure import Figure
from matplotlib.font_manager import FontProperties
from matplotlib._pylab_helpers import Gcf
_log = logging.getLogger(__name__)
_DOCUMENTCLASS = '\\documentclass{article}'

def _get_preamble():
    font_size_pt = FontProperties(size=mpl.rcParams['font.size']).get_size_in_points()
    return '\n'.join(['\\def\\mathdefault#1{#1}', '\\everymath=\\expandafter{\\the\\everymath\\displaystyle}', '\\IfFileExists{scrextend.sty}{', '  \\usepackage[fontsize=%fpt]{scrextend}' % font_size_pt, '}{', '  \\renewcommand{\\normalsize}{\\fontsize{%f}{%f}\\selectfont}' % (font_size_pt, 1.2 * font_size_pt), '  \\normalsize', '}', mpl.rcParams['pgf.preamble'], *(['\\ifdefined\\pdftexversion\\else  % non-pdftex case.', '  \\usepackage{fontspec}'] + ['  \\%s{%s}[Path=\\detokenize{%s/}]' % (command, path.name, path.parent.as_posix()) for (command, path) in zip(['setmainfont', 'setsansfont', 'setmonofont'], [pathlib.Path(fm.findfont(family)) for family in ['serif', 'sans\\-serif', 'monospace']])] + ['\\fi'] if mpl.rcParams['pgf.rcfonts'] else []), mpl.texmanager._usepackage_if_not_loaded('underscore', option='strings')])
latex_pt_to_in = 1.0 / 72.27
latex_in_to_pt = 1.0 / latex_pt_to_in
mpl_pt_to_in = 1.0 / 72.0
mpl_in_to_pt = 1.0 / mpl_pt_to_in

def _tex_escape(text):
    return text.replace('−', '\\ensuremath{-}')

def _writeln(fh, line):
    fh.write(line)
    fh.write('%\n')

def _escape_and_apply_props(s, prop):
    commands = []
    families = {'serif': '\\rmfamily', 'sans': '\\sffamily', 'sans-serif': '\\sffamily', 'monospace': '\\ttfamily'}
    family = prop.get_family()[0]
    if family in families:
        commands.append(families[family])
    elif not mpl.rcParams['pgf.rcfonts']:
        commands.append('\\fontfamily{\\familydefault}')
    elif any((font.name == family for font in fm.fontManager.ttflist)):
        commands.append('\\ifdefined\\pdftexversion\\else\\setmainfont{%s}\\rmfamily\\fi' % family)
    else:
        _log.warning('Ignoring unknown font: %s', family)
    size = prop.get_size_in_points()
    commands.append('\\fontsize{%f}{%f}' % (size, size * 1.2))
    styles = {'normal': '', 'italic': '\\itshape', 'oblique': '\\slshape'}
    commands.append(styles[prop.get_style()])
    boldstyles = ['semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black']
    if prop.get_weight() in boldstyles:
        commands.append('\\bfseries')
    commands.append('\\selectfont')
    return '{' + ''.join(commands) + '\\catcode`\\^=\\active\\def^{\\ifmmode\\sp\\else\\^{}\\fi}' + '\\catcode`\\%=\\active\\def%{\\%}' + _tex_escape(s) + '}'

def _metadata_to_str(key, value):
    if isinstance(value, datetime.datetime):
        value = _datetime_to_pdf(value)
    elif key == 'Trapped':
        value = value.name.decode('ascii')
    else:
        value = str(value)
    return f'{key}={{{value}}}'

def make_pdf_to_png_converter():
    try:
        mpl._get_executable_info('pdftocairo')
    except mpl.ExecutableNotFoundError:
        pass
    else:
        return lambda pdffile, pngfile, dpi: subprocess.check_output(['pdftocairo', '-singlefile', '-transp', '-png', '-r', '%d' % dpi, pdffile, os.path.splitext(pngfile)[0]], stderr=subprocess.STDOUT)
    try:
        gs_info = mpl._get_executable_info('gs')
    except mpl.ExecutableNotFoundError:
        pass
    else:
        return lambda pdffile, pngfile, dpi: subprocess.check_output([gs_info.executable, '-dQUIET', '-dSAFER', '-dBATCH', '-dNOPAUSE', '-dNOPROMPT', '-dUseCIEColor', '-dTextAlphaBits=4', '-dGraphicsAlphaBits=4', '-dDOINTERPOLATE', '-sDEVICE=pngalpha', '-sOutputFile=%s' % pngfile, '-r%d' % dpi, pdffile], stderr=subprocess.STDOUT)
    raise RuntimeError('No suitable pdf to png renderer found.')

class LatexError(Exception):

    def __init__(self, message, latex_output=''):
        super().__init__(message)
        self.latex_output = latex_output

    def __str__(self):
        (s,) = self.args
        if self.latex_output:
            s += '\n' + self.latex_output
        return s

class LatexManager:

    @staticmethod
    def _build_latex_header():
        latex_header = [_DOCUMENTCLASS, f"% !TeX program = {mpl.rcParams['pgf.texsystem']}", '\\usepackage{graphicx}', _get_preamble(), '\\begin{document}', '\\typeout{pgf_backend_query_start}']
        return '\n'.join(latex_header)

    @classmethod
    def _get_cached_or_new(cls):
        return cls._get_cached_or_new_impl(cls._build_latex_header())

    @classmethod
    @functools.lru_cache(1)
    def _get_cached_or_new_impl(cls, header):
        return cls()

    def _stdin_writeln(self, s):
        if self.latex is None:
            self._setup_latex_process()
        self.latex.stdin.write(s)
        self.latex.stdin.write('\n')
        self.latex.stdin.flush()

    def _expect(self, s):
        s = list(s)
        chars = []
        while True:
            c = self.latex.stdout.read(1)
            chars.append(c)
            if chars[-len(s):] == s:
                break
            if not c:
                self.latex.kill()
                self.latex = None
                raise LatexError('LaTeX process halted', ''.join(chars))
        return ''.join(chars)

    def _expect_prompt(self):
        return self._expect('\n*')

    def __init__(self):
        self._tmpdir = TemporaryDirectory()
        self.tmpdir = self._tmpdir.name
        self._finalize_tmpdir = weakref.finalize(self, self._tmpdir.cleanup)
        self._setup_latex_process(expect_reply=False)
        (stdout, stderr) = self.latex.communicate('\n\\makeatletter\\@@end\n')
        if self.latex.returncode != 0:
            raise LatexError(f'LaTeX errored (probably missing font or error in preamble) while processing the following input:\n{self._build_latex_header()}', stdout)
        self.latex = None
        self._get_box_metrics = functools.lru_cache(self._get_box_metrics)

    def _setup_latex_process(self, *, expect_reply=True):
        try:
            self.latex = subprocess.Popen([mpl.rcParams['pgf.texsystem'], '-halt-on-error'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, encoding='utf-8', cwd=self.tmpdir)
        except FileNotFoundError as err:
            raise RuntimeError(f"{mpl.rcParams['pgf.texsystem']!r} not found; install it or change rcParams['pgf.texsystem'] to an available TeX implementation") from err
        except OSError as err:
            raise RuntimeError(f"Error starting {mpl.rcParams['pgf.texsystem']!r}") from err

        def finalize_latex(latex):
            latex.kill()
            try:
                latex.communicate()
            except RuntimeError:
                latex.wait()
        self._finalize_latex = weakref.finalize(self, finalize_latex, self.latex)
        self._stdin_writeln(self._build_latex_header())
        if expect_reply:
            self._expect('*pgf_backend_query_start')
            self._expect_prompt()

    def get_width_height_descent(self, text, prop):
        return self._get_box_metrics(_escape_and_apply_props(text, prop))

    def _get_box_metrics(self, tex):
        self._stdin_writeln('{\\catcode`\\^=\\active\\catcode`\\%%=\\active\\sbox0{%s}\\typeout{\\the\\wd0,\\the\\ht0,\\the\\dp0}}' % tex)
        try:
            answer = self._expect_prompt()
        except LatexError as err:
            raise ValueError('Error measuring {}\nLaTeX Output:\n{}'.format(tex, err.latex_output)) from err
        try:
            (width, height, offset) = answer.splitlines()[-3].split(',')
        except Exception as err:
            raise ValueError('Error measuring {}\nLaTeX Output:\n{}'.format(tex, answer)) from err
        (w, h, o) = (float(width[:-2]), float(height[:-2]), float(offset[:-2]))
        return (w, h + o, o)

@functools.lru_cache(1)
def _get_image_inclusion_command():
    man = LatexManager._get_cached_or_new()
    man._stdin_writeln('\\includegraphics[interpolate=true]{%s}' % cbook._get_data_path('images/matplotlib.png').as_posix())
    try:
        man._expect_prompt()
        return '\\includegraphics'
    except LatexError:
        LatexManager._get_cached_or_new_impl.cache_clear()
        return '\\pgfimage'

class RendererPgf(RendererBase):

    def __init__(self, figure, fh):
        super().__init__()
        self.dpi = figure.dpi
        self.fh = fh
        self.figure = figure
        self.image_counter = 0

    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
        _writeln(self.fh, '\\begin{pgfscope}')
        f = 1.0 / self.dpi
        self._print_pgf_clip(gc)
        self._print_pgf_path_styles(gc, rgbFace)
        (bl, tr) = marker_path.get_extents(marker_trans).get_points()
        coords = (bl[0] * f, bl[1] * f, tr[0] * f, tr[1] * f)
        _writeln(self.fh, '\\pgfsys@defobject{currentmarker}{\\pgfqpoint{%fin}{%fin}}{\\pgfqpoint{%fin}{%fin}}{' % coords)
        self._print_pgf_path(None, marker_path, marker_trans)
        self._pgf_path_draw(stroke=gc.get_linewidth() != 0.0, fill=rgbFace is not None)
        _writeln(self.fh, '}')
        maxcoord = 16383 / 72.27 * self.dpi
        clip = (-maxcoord, -maxcoord, maxcoord, maxcoord)
        for (point, code) in path.iter_segments(trans, simplify=False, clip=clip):
            (x, y) = (point[0] * f, point[1] * f)
            _writeln(self.fh, '\\begin{pgfscope}')
            _writeln(self.fh, '\\pgfsys@transformshift{%fin}{%fin}' % (x, y))
            _writeln(self.fh, '\\pgfsys@useobject{currentmarker}{}')
            _writeln(self.fh, '\\end{pgfscope}')
        _writeln(self.fh, '\\end{pgfscope}')

    def draw_path(self, gc, path, transform, rgbFace=None):
        _writeln(self.fh, '\\begin{pgfscope}')
        self._print_pgf_clip(gc)
        self._print_pgf_path_styles(gc, rgbFace)
        self._print_pgf_path(gc, path, transform, rgbFace)
        self._pgf_path_draw(stroke=gc.get_linewidth() != 0.0, fill=rgbFace is not None)
        _writeln(self.fh, '\\end{pgfscope}')
        if gc.get_hatch():
            _writeln(self.fh, '\\begin{pgfscope}')
            self._print_pgf_path_styles(gc, rgbFace)
            self._print_pgf_clip(gc)
            self._print_pgf_path(gc, path, transform, rgbFace)
            _writeln(self.fh, '\\pgfusepath{clip}')
            _writeln(self.fh, '\\pgfsys@defobject{currentpattern}{\\pgfqpoint{0in}{0in}}{\\pgfqpoint{1in}{1in}}{')
            _writeln(self.fh, '\\begin{pgfscope}')
            _writeln(self.fh, '\\pgfpathrectangle{\\pgfqpoint{0in}{0in}}{\\pgfqpoint{1in}{1in}}')
            _writeln(self.fh, '\\pgfusepath{clip}')
            scale = mpl.transforms.Affine2D().scale(self.dpi)
            self._print_pgf_path(None, gc.get_hatch_path(), scale)
            self._pgf_path_draw(stroke=True)
            _writeln(self.fh, '\\end{pgfscope}')
            _writeln(self.fh, '}')
            f = 1.0 / self.dpi
            ((xmin, ymin), (xmax, ymax)) = path.get_extents(transform).get_points()
            (xmin, xmax) = (f * xmin, f * xmax)
            (ymin, ymax) = (f * ymin, f * ymax)
            (repx, repy) = (math.ceil(xmax - xmin), math.ceil(ymax - ymin))
            _writeln(self.fh, '\\pgfsys@transformshift{%fin}{%fin}' % (xmin, ymin))
            for iy in range(repy):
                for ix in range(repx):
                    _writeln(self.fh, '\\pgfsys@useobject{currentpattern}{}')
                    _writeln(self.fh, '\\pgfsys@transformshift{1in}{0in}')
                _writeln(self.fh, '\\pgfsys@transformshift{-%din}{0in}' % repx)
                _writeln(self.fh, '\\pgfsys@transformshift{0in}{1in}')
            _writeln(self.fh, '\\end{pgfscope}')

    def _print_pgf_clip(self, gc):
        f = 1.0 / self.dpi
        bbox = gc.get_clip_rectangle()
        if bbox:
            (p1, p2) = bbox.get_points()
            (w, h) = p2 - p1
            coords = (p1[0] * f, p1[1] * f, w * f, h * f)
            _writeln(self.fh, '\\pgfpathrectangle{\\pgfqpoint{%fin}{%fin}}{\\pgfqpoint{%fin}{%fin}}' % coords)
            _writeln(self.fh, '\\pgfusepath{clip}')
        (clippath, clippath_trans) = gc.get_clip_path()
        if clippath is not None:
            self._print_pgf_path(gc, clippath, clippath_trans)
            _writeln(self.fh, '\\pgfusepath{clip}')

    def _print_pgf_path_styles(self, gc, rgbFace):
        capstyles = {'butt': '\\pgfsetbuttcap', 'round': '\\pgfsetroundcap', 'projecting': '\\pgfsetrectcap'}
        _writeln(self.fh, capstyles[gc.get_capstyle()])
        joinstyles = {'miter': '\\pgfsetmiterjoin', 'round': '\\pgfsetroundjoin', 'bevel': '\\pgfsetbeveljoin'}
        _writeln(self.fh, joinstyles[gc.get_joinstyle()])
        has_fill = rgbFace is not None
        if gc.get_forced_alpha():
            fillopacity = strokeopacity = gc.get_alpha()
        else:
            strokeopacity = gc.get_rgb()[3]
            fillopacity = rgbFace[3] if has_fill and len(rgbFace) > 3 else 1.0
        if has_fill:
            _writeln(self.fh, '\\definecolor{currentfill}{rgb}{%f,%f,%f}' % tuple(rgbFace[:3]))
            _writeln(self.fh, '\\pgfsetfillcolor{currentfill}')
        if has_fill and fillopacity != 1.0:
            _writeln(self.fh, '\\pgfsetfillopacity{%f}' % fillopacity)
        lw = gc.get_linewidth() * mpl_pt_to_in * latex_in_to_pt
        stroke_rgba = gc.get_rgb()
        _writeln(self.fh, '\\pgfsetlinewidth{%fpt}' % lw)
        _writeln(self.fh, '\\definecolor{currentstroke}{rgb}{%f,%f,%f}' % stroke_rgba[:3])
        _writeln(self.fh, '\\pgfsetstrokecolor{currentstroke}')
        if strokeopacity != 1.0:
            _writeln(self.fh, '\\pgfsetstrokeopacity{%f}' % strokeopacity)
        (dash_offset, dash_list) = gc.get_dashes()
        if dash_list is None:
            _writeln(self.fh, '\\pgfsetdash{}{0pt}')
        else:
            _writeln(self.fh, '\\pgfsetdash{%s}{%fpt}' % (''.join(('{%fpt}' % dash for dash in dash_list)), dash_offset))

    def _print_pgf_path(self, gc, path, transform, rgbFace=None):
        f = 1.0 / self.dpi
        bbox = gc.get_clip_rectangle() if gc else None
        maxcoord = 16383 / 72.27 * self.dpi
        if bbox and rgbFace is None:
            (p1, p2) = bbox.get_points()
            clip = (max(p1[0], -maxcoord), max(p1[1], -maxcoord), min(p2[0], maxcoord), min(p2[1], maxcoord))
        else:
            clip = (-maxcoord, -maxcoord, maxcoord, maxcoord)
        for (points, code) in path.iter_segments(transform, clip=clip):
            if code == Path.MOVETO:
                (x, y) = tuple(points)
                _writeln(self.fh, '\\pgfpathmoveto{\\pgfqpoint{%fin}{%fin}}' % (f * x, f * y))
            elif code == Path.CLOSEPOLY:
                _writeln(self.fh, '\\pgfpathclose')
            elif code == Path.LINETO:
                (x, y) = tuple(points)
                _writeln(self.fh, '\\pgfpathlineto{\\pgfqpoint{%fin}{%fin}}' % (f * x, f * y))
            elif code == Path.CURVE3:
                (cx, cy, px, py) = tuple(points)
                coords = (cx * f, cy * f, px * f, py * f)
                _writeln(self.fh, '\\pgfpathquadraticcurveto{\\pgfqpoint{%fin}{%fin}}{\\pgfqpoint{%fin}{%fin}}' % coords)
            elif code == Path.CURVE4:
                (c1x, c1y, c2x, c2y, px, py) = tuple(points)
                coords = (c1x * f, c1y * f, c2x * f, c2y * f, px * f, py * f)
                _writeln(self.fh, '\\pgfpathcurveto{\\pgfqpoint{%fin}{%fin}}{\\pgfqpoint{%fin}{%fin}}{\\pgfqpoint{%fin}{%fin}}' % coords)
        sketch_params = gc.get_sketch_params() if gc else None
        if sketch_params is not None:
            (scale, length, randomness) = sketch_params
            if scale is not None:
                length *= 0.5
                scale *= 2
                _writeln(self.fh, '\\usepgfmodule{decorations}')
                _writeln(self.fh, '\\usepgflibrary{decorations.pathmorphing}')
                _writeln(self.fh, f'\\pgfkeys{{/pgf/decoration/.cd, segment length = {length * f:f}in, amplitude = {scale * f:f}in}}')
                _writeln(self.fh, f'\\pgfmathsetseed{{{int(randomness)}}}')
                _writeln(self.fh, '\\pgfdecoratecurrentpath{random steps}')

    def _pgf_path_draw(self, stroke=True, fill=False):
        actions = []
        if stroke:
            actions.append('stroke')
        if fill:
            actions.append('fill')
        _writeln(self.fh, '\\pgfusepath{%s}' % ','.join(actions))

    def option_scale_image(self):
        return True

    def option_image_nocomposite(self):
        return not mpl.rcParams['image.composite_image']

    def draw_image(self, gc, x, y, im, transform=None):
        (h, w) = im.shape[:2]
        if w == 0 or h == 0:
            return
        if not os.path.exists(getattr(self.fh, 'name', '')):
            raise ValueError('streamed pgf-code does not support raster graphics, consider using the pgf-to-pdf option')
        path = pathlib.Path(self.fh.name)
        fname_img = '%s-img%d.png' % (path.stem, self.image_counter)
        Image.fromarray(im[::-1]).save(path.parent / fname_img)
        self.image_counter += 1
        _writeln(self.fh, '\\begin{pgfscope}')
        self._print_pgf_clip(gc)
        f = 1.0 / self.dpi
        if transform is None:
            _writeln(self.fh, '\\pgfsys@transformshift{%fin}{%fin}' % (x * f, y * f))
            (w, h) = (w * f, h * f)
        else:
            (tr1, tr2, tr3, tr4, tr5, tr6) = transform.frozen().to_values()
            _writeln(self.fh, '\\pgfsys@transformcm{%f}{%f}{%f}{%f}{%fin}{%fin}' % (tr1 * f, tr2 * f, tr3 * f, tr4 * f, (tr5 + x) * f, (tr6 + y) * f))
            w = h = 1
        interp = str(transform is None).lower()
        _writeln(self.fh, '\\pgftext[left,bottom]{%s[interpolate=%s,width=%fin,height=%fin]{%s}}' % (_get_image_inclusion_command(), interp, w, h, fname_img))
        _writeln(self.fh, '\\end{pgfscope}')

    def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
        self.draw_text(gc, x, y, s, prop, angle, ismath='TeX', mtext=mtext)

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        s = _escape_and_apply_props(s, prop)
        _writeln(self.fh, '\\begin{pgfscope}')
        self._print_pgf_clip(gc)
        alpha = gc.get_alpha()
        if alpha != 1.0:
            _writeln(self.fh, '\\pgfsetfillopacity{%f}' % alpha)
            _writeln(self.fh, '\\pgfsetstrokeopacity{%f}' % alpha)
        rgb = tuple(gc.get_rgb())[:3]
        _writeln(self.fh, '\\definecolor{textcolor}{rgb}{%f,%f,%f}' % rgb)
        _writeln(self.fh, '\\pgfsetstrokecolor{textcolor}')
        _writeln(self.fh, '\\pgfsetfillcolor{textcolor}')
        s = '\\color{textcolor}' + s
        dpi = self.figure.dpi
        text_args = []
        if mtext and ((angle == 0 or mtext.get_rotation_mode() == 'anchor') and mtext.get_verticalalignment() != 'center_baseline'):
            pos = mtext.get_unitless_position()
            (x, y) = mtext.get_transform().transform(pos)
            halign = {'left': 'left', 'right': 'right', 'center': ''}
            valign = {'top': 'top', 'bottom': 'bottom', 'baseline': 'base', 'center': ''}
            text_args.extend([f'x={x / dpi:f}in', f'y={y / dpi:f}in', halign[mtext.get_horizontalalignment()], valign[mtext.get_verticalalignment()]])
        else:
            text_args.append(f'x={x / dpi:f}in, y={y / dpi:f}in, left, base')
        if angle != 0:
            text_args.append('rotate=%f' % angle)
        _writeln(self.fh, '\\pgftext[%s]{%s}' % (','.join(text_args), s))
        _writeln(self.fh, '\\end{pgfscope}')

    def get_text_width_height_descent(self, s, prop, ismath):
        (w, h, d) = LatexManager._get_cached_or_new().get_width_height_descent(s, prop)
        f = mpl_pt_to_in * self.dpi
        return (w * f, h * f, d * f)

    def flipy(self):
        return False

    def get_canvas_width_height(self):
        return (self.figure.get_figwidth() * self.dpi, self.figure.get_figheight() * self.dpi)

    def points_to_pixels(self, points):
        return points * mpl_pt_to_in * self.dpi

class FigureCanvasPgf(FigureCanvasBase):
    filetypes = {'pgf': 'LaTeX PGF picture', 'pdf': 'LaTeX compiled PGF picture', 'png': 'Portable Network Graphics'}

    def get_default_filetype(self):
        return 'pdf'

    def _print_pgf_to_fh(self, fh, *, bbox_inches_restore=None):
        header_text = '%% Creator: Matplotlib, PGF backend\n%%\n%% To include the figure in your LaTeX document, write\n%%   \\input{<filename>.pgf}\n%%\n%% Make sure the required packages are loaded in your preamble\n%%   \\usepackage{pgf}\n%%\n%% Also ensure that all the required font packages are loaded; for instance,\n%% the lmodern package is sometimes necessary when using math font.\n%%   \\usepackage{lmodern}\n%%\n%% Figures using additional raster images can only be included by \\input if\n%% they are in the same directory as the main LaTeX file. For loading figures\n%% from other directories you can use the `import` package\n%%   \\usepackage{import}\n%%\n%% and then include the figures with\n%%   \\import{<path to file>}{<filename>.pgf}\n%%\n'
        header_info_preamble = ['%% Matplotlib used the following preamble']
        for line in _get_preamble().splitlines():
            header_info_preamble.append('%%   ' + line)
        header_info_preamble.append('%%')
        header_info_preamble = '\n'.join(header_info_preamble)
        (w, h) = (self.figure.get_figwidth(), self.figure.get_figheight())
        dpi = self.figure.dpi
        fh.write(header_text)
        fh.write(header_info_preamble)
        fh.write('\n')
        _writeln(fh, '\\begingroup')
        _writeln(fh, '\\makeatletter')
        _writeln(fh, '\\begin{pgfpicture}')
        _writeln(fh, '\\pgfpathrectangle{\\pgfpointorigin}{\\pgfqpoint{%fin}{%fin}}' % (w, h))
        _writeln(fh, '\\pgfusepath{use as bounding box, clip}')
        renderer = MixedModeRenderer(self.figure, w, h, dpi, RendererPgf(self.figure, fh), bbox_inches_restore=bbox_inches_restore)
        self.figure.draw(renderer)
        _writeln(fh, '\\end{pgfpicture}')
        _writeln(fh, '\\makeatother')
        _writeln(fh, '\\endgroup')

    def print_pgf(self, fname_or_fh, **kwargs):
        with cbook.open_file_cm(fname_or_fh, 'w', encoding='utf-8') as file:
            if not cbook.file_requires_unicode(file):
                file = codecs.getwriter('utf-8')(file)
            self._print_pgf_to_fh(file, **kwargs)

    def print_pdf(self, fname_or_fh, *, metadata=None, **kwargs):
        (w, h) = self.figure.get_size_inches()
        info_dict = _create_pdf_info_dict('pgf', metadata or {})
        pdfinfo = ','.join((_metadata_to_str(k, v) for (k, v) in info_dict.items()))
        with TemporaryDirectory() as tmpdir:
            tmppath = pathlib.Path(tmpdir)
            self.print_pgf(tmppath / 'figure.pgf', **kwargs)
            (tmppath / 'figure.tex').write_text('\n'.join([_DOCUMENTCLASS, '\\usepackage[pdfinfo={%s}]{hyperref}' % pdfinfo, '\\usepackage[papersize={%fin,%fin}, margin=0in]{geometry}' % (w, h), '\\usepackage{pgf}', _get_preamble(), '\\begin{document}', '\\centering', '\\input{figure.pgf}', '\\end{document}']), encoding='utf-8')
            texcommand = mpl.rcParams['pgf.texsystem']
            cbook._check_and_log_subprocess([texcommand, '-interaction=nonstopmode', '-halt-on-error', 'figure.tex'], _log, cwd=tmpdir)
            with (tmppath / 'figure.pdf').open('rb') as orig, cbook.open_file_cm(fname_or_fh, 'wb') as dest:
                shutil.copyfileobj(orig, dest)

    def print_png(self, fname_or_fh, **kwargs):
        converter = make_pdf_to_png_converter()
        with TemporaryDirectory() as tmpdir:
            tmppath = pathlib.Path(tmpdir)
            pdf_path = tmppath / 'figure.pdf'
            png_path = tmppath / 'figure.png'
            self.print_pdf(pdf_path, **kwargs)
            converter(pdf_path, png_path, dpi=self.figure.dpi)
            with png_path.open('rb') as orig, cbook.open_file_cm(fname_or_fh, 'wb') as dest:
                shutil.copyfileobj(orig, dest)

    def get_renderer(self):
        return RendererPgf(self.figure, None)

    def draw(self):
        self.figure.draw_without_rendering()
        return super().draw()
FigureManagerPgf = FigureManagerBase

@_Backend.export
class _BackendPgf(_Backend):
    FigureCanvas = FigureCanvasPgf

class PdfPages:
    _UNSET = object()

    def __init__(self, filename, *, keep_empty=_UNSET, metadata=None):
        self._output_name = filename
        self._n_figures = 0
        if keep_empty and keep_empty is not self._UNSET:
            _api.warn_deprecated('3.8', message='Keeping empty pdf files is deprecated since %(since)s and support will be removed %(removal)s.')
        self._keep_empty = keep_empty
        self._metadata = (metadata or {}).copy()
        self._info_dict = _create_pdf_info_dict('pgf', self._metadata)
        self._file = BytesIO()
    keep_empty = _api.deprecate_privatize_attribute('3.8')

    def _write_header(self, width_inches, height_inches):
        pdfinfo = ','.join((_metadata_to_str(k, v) for (k, v) in self._info_dict.items()))
        latex_header = '\n'.join([_DOCUMENTCLASS, '\\usepackage[pdfinfo={%s}]{hyperref}' % pdfinfo, '\\usepackage[papersize={%fin,%fin}, margin=0in]{geometry}' % (width_inches, height_inches), '\\usepackage{pgf}', _get_preamble(), '\\setlength{\\parindent}{0pt}', '\\begin{document}%'])
        self._file.write(latex_header.encode('utf-8'))

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

    def close(self):
        self._file.write(b'\\end{document}\\n')
        if self._n_figures > 0:
            self._run_latex()
        elif self._keep_empty:
            _api.warn_deprecated('3.8', message='Keeping empty pdf files is deprecated since %(since)s and support will be removed %(removal)s.')
            open(self._output_name, 'wb').close()
        self._file.close()

    def _run_latex(self):
        texcommand = mpl.rcParams['pgf.texsystem']
        with TemporaryDirectory() as tmpdir:
            tex_source = pathlib.Path(tmpdir, 'pdf_pages.tex')
            tex_source.write_bytes(self._file.getvalue())
            cbook._check_and_log_subprocess([texcommand, '-interaction=nonstopmode', '-halt-on-error', tex_source], _log, cwd=tmpdir)
            shutil.move(tex_source.with_suffix('.pdf'), self._output_name)

    def savefig(self, figure=None, **kwargs):
        if not isinstance(figure, Figure):
            if figure is None:
                manager = Gcf.get_active()
            else:
                manager = Gcf.get_fig_manager(figure)
            if manager is None:
                raise ValueError(f'No figure {figure}')
            figure = manager.canvas.figure
        (width, height) = figure.get_size_inches()
        if self._n_figures == 0:
            self._write_header(width, height)
        else:
            self._file.write(b'\\newpage\\ifdefined\\pdfpagewidth\\pdfpagewidth\\else\\pagewidth\\fi=%fin\\ifdefined\\pdfpageheight\\pdfpageheight\\else\\pageheight\\fi=%fin%%\n' % (width, height))
        figure.savefig(self._file, format='pgf', backend='pgf', **kwargs)
        self._n_figures += 1

    def get_pagecount(self):
        return self._n_figures

# File: matplotlib-main/lib/matplotlib/backends/backend_ps.py
""""""
import codecs
import datetime
from enum import Enum
import functools
from io import StringIO
import itertools
import logging
import math
import os
import pathlib
import shutil
from tempfile import TemporaryDirectory
import time
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, _path, _text_helpers
from matplotlib._afm import AFM
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, RendererBase
from matplotlib.cbook import is_writable_file_like, file_requires_unicode
from matplotlib.font_manager import get_font
from matplotlib.ft2font import LOAD_NO_SCALE, FT2Font
from matplotlib._ttconv import convert_ttf_to_ps
from matplotlib._mathtext_data import uni2type1
from matplotlib.path import Path
from matplotlib.texmanager import TexManager
from matplotlib.transforms import Affine2D
from matplotlib.backends.backend_mixed import MixedModeRenderer
from . import _backend_pdf_ps
_log = logging.getLogger(__name__)
debugPS = False

@_api.caching_module_getattr
class __getattr__:
    psDefs = _api.deprecated('3.8', obj_type='')(property(lambda self: _psDefs))
papersize = {'letter': (8.5, 11), 'legal': (8.5, 14), 'ledger': (11, 17), 'a0': (33.11, 46.81), 'a1': (23.39, 33.11), 'a2': (16.54, 23.39), 'a3': (11.69, 16.54), 'a4': (8.27, 11.69), 'a5': (5.83, 8.27), 'a6': (4.13, 5.83), 'a7': (2.91, 4.13), 'a8': (2.05, 2.91), 'a9': (1.46, 2.05), 'a10': (1.02, 1.46), 'b0': (40.55, 57.32), 'b1': (28.66, 40.55), 'b2': (20.27, 28.66), 'b3': (14.33, 20.27), 'b4': (10.11, 14.33), 'b5': (7.16, 10.11), 'b6': (5.04, 7.16), 'b7': (3.58, 5.04), 'b8': (2.51, 3.58), 'b9': (1.76, 2.51), 'b10': (1.26, 1.76)}

def _get_papertype(w, h):
    for (key, (pw, ph)) in sorted(papersize.items(), reverse=True):
        if key.startswith('l'):
            continue
        if w < pw and h < ph:
            return key
    return 'a0'

def _nums_to_str(*args, sep=' '):
    return sep.join((f'{arg:1.3f}'.rstrip('0').rstrip('.') for arg in args))

def _move_path_to_path_or_stream(src, dst):
    if is_writable_file_like(dst):
        fh = open(src, encoding='latin-1') if file_requires_unicode(dst) else open(src, 'rb')
        with fh:
            shutil.copyfileobj(fh, dst)
    else:
        shutil.move(src, dst, copy_function=shutil.copyfile)

def _font_to_ps_type3(font_path, chars):
    font = get_font(font_path, hinting_factor=1)
    glyph_ids = [font.get_char_index(c) for c in chars]
    preamble = '%!PS-Adobe-3.0 Resource-Font\n%%Creator: Converted from TrueType to Type 3 by Matplotlib.\n10 dict begin\n/FontName /{font_name} def\n/PaintType 0 def\n/FontMatrix [{inv_units_per_em} 0 0 {inv_units_per_em} 0 0] def\n/FontBBox [{bbox}] def\n/FontType 3 def\n/Encoding [{encoding}] def\n/CharStrings {num_glyphs} dict dup begin\n/.notdef 0 def\n'.format(font_name=font.postscript_name, inv_units_per_em=1 / font.units_per_EM, bbox=' '.join(map(str, font.bbox)), encoding=' '.join((f'/{font.get_glyph_name(glyph_id)}' for glyph_id in glyph_ids)), num_glyphs=len(glyph_ids) + 1)
    postamble = '\nend readonly def\n\n/BuildGlyph {\n exch begin\n CharStrings exch\n 2 copy known not {pop /.notdef} if\n true 3 1 roll get exec\n end\n} _d\n\n/BuildChar {\n 1 index /Encoding get exch get\n 1 index /BuildGlyph get exec\n} _d\n\nFontName currentdict end definefont pop\n'
    entries = []
    for glyph_id in glyph_ids:
        g = font.load_glyph(glyph_id, LOAD_NO_SCALE)
        (v, c) = font.get_path()
        entries.append('/%(name)s{%(bbox)s sc\n' % {'name': font.get_glyph_name(glyph_id), 'bbox': ' '.join(map(str, [g.horiAdvance, 0, *g.bbox]))} + _path.convert_to_string(Path(v * 64, c), None, None, False, None, 0, [b'm', b'l', b'', b'c', b''], True).decode('ascii') + 'ce} _d')
    return preamble + '\n'.join(entries) + postamble

def _font_to_ps_type42(font_path, chars, fh):
    subset_str = ''.join((chr(c) for c in chars))
    _log.debug('SUBSET %s characters: %s', font_path, subset_str)
    try:
        fontdata = _backend_pdf_ps.get_glyphs_subset(font_path, subset_str)
        _log.debug('SUBSET %s %d -> %d', font_path, os.stat(font_path).st_size, fontdata.getbuffer().nbytes)
        font = FT2Font(fontdata)
        glyph_ids = [font.get_char_index(c) for c in chars]
        with TemporaryDirectory() as tmpdir:
            tmpfile = os.path.join(tmpdir, 'tmp.ttf')
            with open(tmpfile, 'wb') as tmp:
                tmp.write(fontdata.getvalue())
            convert_ttf_to_ps(os.fsencode(tmpfile), fh, 42, glyph_ids)
    except RuntimeError:
        _log.warning('The PostScript backend does not currently support the selected font.')
        raise

def _log_if_debug_on(meth):

    @functools.wraps(meth)
    def wrapper(self, *args, **kwargs):
        if debugPS:
            self._pswriter.write(f'% {meth.__name__}\n')
        return meth(self, *args, **kwargs)
    return wrapper

class RendererPS(_backend_pdf_ps.RendererPDFPSBase):
    _afm_font_dir = cbook._get_data_path('fonts/afm')
    _use_afm_rc_name = 'ps.useafm'

    def __init__(self, width, height, pswriter, imagedpi=72):
        super().__init__(width, height)
        self._pswriter = pswriter
        if mpl.rcParams['text.usetex']:
            self.textcnt = 0
            self.psfrag = []
        self.imagedpi = imagedpi
        self.color = None
        self.linewidth = None
        self.linejoin = None
        self.linecap = None
        self.linedash = None
        self.fontname = None
        self.fontsize = None
        self._hatches = {}
        self.image_magnification = imagedpi / 72
        self._clip_paths = {}
        self._path_collection_id = 0
        self._character_tracker = _backend_pdf_ps.CharacterTracker()
        self._logwarn_once = functools.cache(_log.warning)

    def _is_transparent(self, rgb_or_rgba):
        if rgb_or_rgba is None:
            return True
        elif len(rgb_or_rgba) == 4:
            if rgb_or_rgba[3] == 0:
                return True
            if rgb_or_rgba[3] != 1:
                self._logwarn_once('The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.')
            return False
        else:
            return False

    def set_color(self, r, g, b, store=True):
        if (r, g, b) != self.color:
            self._pswriter.write(f'{_nums_to_str(r)} setgray\n' if r == g == b else f'{_nums_to_str(r, g, b)} setrgbcolor\n')
            if store:
                self.color = (r, g, b)

    def set_linewidth(self, linewidth, store=True):
        linewidth = float(linewidth)
        if linewidth != self.linewidth:
            self._pswriter.write(f'{_nums_to_str(linewidth)} setlinewidth\n')
            if store:
                self.linewidth = linewidth

    @staticmethod
    def _linejoin_cmd(linejoin):
        linejoin = {'miter': 0, 'round': 1, 'bevel': 2, 0: 0, 1: 1, 2: 2}[linejoin]
        return f'{linejoin:d} setlinejoin\n'

    def set_linejoin(self, linejoin, store=True):
        if linejoin != self.linejoin:
            self._pswriter.write(self._linejoin_cmd(linejoin))
            if store:
                self.linejoin = linejoin

    @staticmethod
    def _linecap_cmd(linecap):
        linecap = {'butt': 0, 'round': 1, 'projecting': 2, 0: 0, 1: 1, 2: 2}[linecap]
        return f'{linecap:d} setlinecap\n'

    def set_linecap(self, linecap, store=True):
        if linecap != self.linecap:
            self._pswriter.write(self._linecap_cmd(linecap))
            if store:
                self.linecap = linecap

    def set_linedash(self, offset, seq, store=True):
        if self.linedash is not None:
            (oldo, oldseq) = self.linedash
            if np.array_equal(seq, oldseq) and oldo == offset:
                return
        self._pswriter.write(f'[{_nums_to_str(*seq)}] {_nums_to_str(offset)} setdash\n' if seq is not None and len(seq) else '[] 0 setdash\n')
        if store:
            self.linedash = (offset, seq)

    def set_font(self, fontname, fontsize, store=True):
        if (fontname, fontsize) != (self.fontname, self.fontsize):
            self._pswriter.write(f'/{fontname} {fontsize:1.3f} selectfont\n')
            if store:
                self.fontname = fontname
                self.fontsize = fontsize

    def create_hatch(self, hatch):
        sidelen = 72
        if hatch in self._hatches:
            return self._hatches[hatch]
        name = 'H%d' % len(self._hatches)
        linewidth = mpl.rcParams['hatch.linewidth']
        pageheight = self.height * 72
        self._pswriter.write(f'  << /PatternType 1\n     /PaintType 2\n     /TilingType 2\n     /BBox[0 0 {sidelen:d} {sidelen:d}]\n     /XStep {sidelen:d}\n     /YStep {sidelen:d}\n\n     /PaintProc {{\n        pop\n        {linewidth:g} setlinewidth\n{self._convert_path(Path.hatch(hatch), Affine2D().scale(sidelen), simplify=False)}\n        gsave\n        fill\n        grestore\n        stroke\n     }} bind\n   >>\n   matrix\n   0 {pageheight:g} translate\n   makepattern\n   /{name} exch def\n')
        self._hatches[hatch] = name
        return name

    def get_image_magnification(self):
        return self.image_magnification

    def _convert_path(self, path, transform, clip=False, simplify=None):
        if clip:
            clip = (0.0, 0.0, self.width * 72.0, self.height * 72.0)
        else:
            clip = None
        return _path.convert_to_string(path, transform, clip, simplify, None, 6, [b'm', b'l', b'', b'c', b'cl'], True).decode('ascii')

    def _get_clip_cmd(self, gc):
        clip = []
        rect = gc.get_clip_rectangle()
        if rect is not None:
            clip.append(f'{_nums_to_str(*rect.p0, *rect.size)} rectclip\n')
        (path, trf) = gc.get_clip_path()
        if path is not None:
            key = (path, id(trf))
            custom_clip_cmd = self._clip_paths.get(key)
            if custom_clip_cmd is None:
                custom_clip_cmd = 'c%d' % len(self._clip_paths)
                self._pswriter.write(f'/{custom_clip_cmd} {{\n{self._convert_path(path, trf, simplify=False)}\nclip\nnewpath\n}} bind def\n')
                self._clip_paths[key] = custom_clip_cmd
            clip.append(f'{custom_clip_cmd}\n')
        return ''.join(clip)

    @_log_if_debug_on
    def draw_image(self, gc, x, y, im, transform=None):
        (h, w) = im.shape[:2]
        imagecmd = 'false 3 colorimage'
        data = im[::-1, :, :3]
        hexdata = data.tobytes().hex('\n', -64)
        if transform is None:
            matrix = '1 0 0 1 0 0'
            xscale = w / self.image_magnification
            yscale = h / self.image_magnification
        else:
            matrix = ' '.join(map(str, transform.frozen().to_values()))
            xscale = 1.0
            yscale = 1.0
        self._pswriter.write(f'gsave\n{self._get_clip_cmd(gc)}\n{x:g} {y:g} translate\n[{matrix}] concat\n{xscale:g} {yscale:g} scale\n/DataString {w:d} string def\n{w:d} {h:d} 8 [ {w:d} 0 0 -{h:d} 0 {h:d} ]\n{{\ncurrentfile DataString readhexstring pop\n}} bind {imagecmd}\n{hexdata}\ngrestore\n')

    @_log_if_debug_on
    def draw_path(self, gc, path, transform, rgbFace=None):
        clip = rgbFace is None and gc.get_hatch_path() is None
        simplify = path.should_simplify and clip
        ps = self._convert_path(path, transform, clip=clip, simplify=simplify)
        self._draw_ps(ps, gc, rgbFace)

    @_log_if_debug_on
    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
        ps_color = None if self._is_transparent(rgbFace) else f'{_nums_to_str(rgbFace[0])} setgray' if rgbFace[0] == rgbFace[1] == rgbFace[2] else f'{_nums_to_str(*rgbFace[:3])} setrgbcolor'
        ps_cmd = ['/o {', 'gsave', 'newpath', 'translate']
        lw = gc.get_linewidth()
        alpha = gc.get_alpha() if gc.get_forced_alpha() or len(gc.get_rgb()) == 3 else gc.get_rgb()[3]
        stroke = lw > 0 and alpha > 0
        if stroke:
            ps_cmd.append('%.1f setlinewidth' % lw)
            ps_cmd.append(self._linejoin_cmd(gc.get_joinstyle()))
            ps_cmd.append(self._linecap_cmd(gc.get_capstyle()))
        ps_cmd.append(self._convert_path(marker_path, marker_trans, simplify=False))
        if rgbFace:
            if stroke:
                ps_cmd.append('gsave')
            if ps_color:
                ps_cmd.extend([ps_color, 'fill'])
            if stroke:
                ps_cmd.append('grestore')
        if stroke:
            ps_cmd.append('stroke')
        ps_cmd.extend(['grestore', '} bind def'])
        for (vertices, code) in path.iter_segments(trans, clip=(0, 0, self.width * 72, self.height * 72), simplify=False):
            if len(vertices):
                (x, y) = vertices[-2:]
                ps_cmd.append(f'{x:g} {y:g} o')
        ps = '\n'.join(ps_cmd)
        self._draw_ps(ps, gc, rgbFace, fill=False, stroke=False)

    @_log_if_debug_on
    def draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
        len_path = len(paths[0].vertices) if len(paths) > 0 else 0
        uses_per_path = self._iter_collection_uses_per_path(paths, all_transforms, offsets, facecolors, edgecolors)
        should_do_optimization = len_path + 3 * uses_per_path + 3 < (len_path + 2) * uses_per_path
        if not should_do_optimization:
            return RendererBase.draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position)
        path_codes = []
        for (i, (path, transform)) in enumerate(self._iter_collection_raw_paths(master_transform, paths, all_transforms)):
            name = 'p%d_%d' % (self._path_collection_id, i)
            path_bytes = self._convert_path(path, transform, simplify=False)
            self._pswriter.write(f'/{name} {{\nnewpath\ntranslate\n{path_bytes}\n}} bind def\n')
            path_codes.append(name)
        for (xo, yo, path_id, gc0, rgbFace) in self._iter_collection(gc, path_codes, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
            ps = f'{xo:g} {yo:g} {path_id}'
            self._draw_ps(ps, gc0, rgbFace)
        self._path_collection_id += 1

    @_log_if_debug_on
    def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
        if self._is_transparent(gc.get_rgb()):
            return
        if not hasattr(self, 'psfrag'):
            self._logwarn_once("The PS backend determines usetex status solely based on rcParams['text.usetex'] and does not support having usetex=True only for some elements; this element will thus be rendered as if usetex=False.")
            self.draw_text(gc, x, y, s, prop, angle, False, mtext)
            return
        (w, h, bl) = self.get_text_width_height_descent(s, prop, ismath='TeX')
        fontsize = prop.get_size_in_points()
        thetext = 'psmarker%d' % self.textcnt
        color = _nums_to_str(*gc.get_rgb()[:3], sep=',')
        fontcmd = {'sans-serif': '{\\sffamily %s}', 'monospace': '{\\ttfamily %s}'}.get(mpl.rcParams['font.family'][0], '{\\rmfamily %s}')
        s = fontcmd % s
        tex = '\\color[rgb]{%s} %s' % (color, s)
        rangle = np.radians(angle + 90)
        pos = _nums_to_str(x - bl * np.cos(rangle), y - bl * np.sin(rangle))
        self.psfrag.append('\\psfrag{%s}[bl][bl][1][%f]{\\fontsize{%f}{%f}%s}' % (thetext, angle, fontsize, fontsize * 1.25, tex))
        self._pswriter.write(f'gsave\n{pos} moveto\n({thetext})\nshow\ngrestore\n')
        self.textcnt += 1

    @_log_if_debug_on
    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        if self._is_transparent(gc.get_rgb()):
            return
        if ismath == 'TeX':
            return self.draw_tex(gc, x, y, s, prop, angle)
        if ismath:
            return self.draw_mathtext(gc, x, y, s, prop, angle)
        stream = []
        if mpl.rcParams['ps.useafm']:
            font = self._get_font_afm(prop)
            ps_name = font.postscript_name.encode('ascii', 'replace').decode('ascii')
            scale = 0.001 * prop.get_size_in_points()
            thisx = 0
            last_name = None
            for c in s:
                name = uni2type1.get(ord(c), f'uni{ord(c):04X}')
                try:
                    width = font.get_width_from_char_name(name)
                except KeyError:
                    name = 'question'
                    width = font.get_width_char('?')
                kern = font.get_kern_dist_from_name(last_name, name)
                last_name = name
                thisx += kern * scale
                stream.append((ps_name, thisx, name))
                thisx += width * scale
        else:
            font = self._get_font_ttf(prop)
            self._character_tracker.track(font, s)
            for item in _text_helpers.layout(s, font):
                ps_name = item.ft_object.postscript_name.encode('ascii', 'replace').decode('ascii')
                glyph_name = item.ft_object.get_glyph_name(item.glyph_idx)
                stream.append((ps_name, item.x, glyph_name))
        self.set_color(*gc.get_rgb())
        for (ps_name, group) in itertools.groupby(stream, lambda entry: entry[0]):
            self.set_font(ps_name, prop.get_size_in_points(), False)
            thetext = '\n'.join((f'{x:g} 0 m /{name:s} glyphshow' for (_, x, name) in group))
            self._pswriter.write(f'gsave\n{self._get_clip_cmd(gc)}\n{x:g} {y:g} translate\n{angle:g} rotate\n{thetext}\ngrestore\n')

    @_log_if_debug_on
    def draw_mathtext(self, gc, x, y, s, prop, angle):
        (width, height, descent, glyphs, rects) = self._text2path.mathtext_parser.parse(s, 72, prop)
        self.set_color(*gc.get_rgb())
        self._pswriter.write(f'gsave\n{x:g} {y:g} translate\n{angle:g} rotate\n')
        lastfont = None
        for (font, fontsize, num, ox, oy) in glyphs:
            self._character_tracker.track_glyph(font, num)
            if (font.postscript_name, fontsize) != lastfont:
                lastfont = (font.postscript_name, fontsize)
                self._pswriter.write(f'/{font.postscript_name} {fontsize} selectfont\n')
            glyph_name = font.get_name_char(chr(num)) if isinstance(font, AFM) else font.get_glyph_name(font.get_char_index(num))
            self._pswriter.write(f'{ox:g} {oy:g} moveto\n/{glyph_name} glyphshow\n')
        for (ox, oy, w, h) in rects:
            self._pswriter.write(f'{ox} {oy} {w} {h} rectfill\n')
        self._pswriter.write('grestore\n')

    @_log_if_debug_on
    def draw_gouraud_triangles(self, gc, points, colors, trans):
        assert len(points) == len(colors)
        if len(points) == 0:
            return
        assert points.ndim == 3
        assert points.shape[1] == 3
        assert points.shape[2] == 2
        assert colors.ndim == 3
        assert colors.shape[1] == 3
        assert colors.shape[2] == 4
        shape = points.shape
        flat_points = points.reshape((shape[0] * shape[1], 2))
        flat_points = trans.transform(flat_points)
        flat_colors = colors.reshape((shape[0] * shape[1], 4))
        points_min = np.min(flat_points, axis=0) - (1 << 12)
        points_max = np.max(flat_points, axis=0) + (1 << 12)
        factor = np.ceil((2 ** 32 - 1) / (points_max - points_min))
        (xmin, ymin) = points_min
        (xmax, ymax) = points_max
        data = np.empty(shape[0] * shape[1], dtype=[('flags', 'u1'), ('points', '2>u4'), ('colors', '3u1')])
        data['flags'] = 0
        data['points'] = (flat_points - points_min) * factor
        data['colors'] = flat_colors[:, :3] * 255.0
        hexdata = data.tobytes().hex('\n', -64)
        self._pswriter.write(f'gsave\n<< /ShadingType 4\n   /ColorSpace [/DeviceRGB]\n   /BitsPerCoordinate 32\n   /BitsPerComponent 8\n   /BitsPerFlag 8\n   /AntiAlias true\n   /Decode [ {xmin:g} {xmax:g} {ymin:g} {ymax:g} 0 1 0 1 0 1 ]\n   /DataSource <\n{hexdata}\n>\n>>\nshfill\ngrestore\n')

    def _draw_ps(self, ps, gc, rgbFace, *, fill=True, stroke=True):
        write = self._pswriter.write
        mightstroke = gc.get_linewidth() > 0 and (not self._is_transparent(gc.get_rgb()))
        if not mightstroke:
            stroke = False
        if self._is_transparent(rgbFace):
            fill = False
        hatch = gc.get_hatch()
        if mightstroke:
            self.set_linewidth(gc.get_linewidth())
            self.set_linejoin(gc.get_joinstyle())
            self.set_linecap(gc.get_capstyle())
            self.set_linedash(*gc.get_dashes())
        if mightstroke or hatch:
            self.set_color(*gc.get_rgb()[:3])
        write('gsave\n')
        write(self._get_clip_cmd(gc))
        write(ps.strip())
        write('\n')
        if fill:
            if stroke or hatch:
                write('gsave\n')
            self.set_color(*rgbFace[:3], store=False)
            write('fill\n')
            if stroke or hatch:
                write('grestore\n')
        if hatch:
            hatch_name = self.create_hatch(hatch)
            write('gsave\n')
            write(_nums_to_str(*gc.get_hatch_color()[:3]))
            write(f' {hatch_name} setpattern fill grestore\n')
        if stroke:
            write('stroke\n')
        write('grestore\n')

class _Orientation(Enum):
    (portrait, landscape) = range(2)

    def swap_if_landscape(self, shape):
        return shape[::-1] if self.name == 'landscape' else shape

class FigureCanvasPS(FigureCanvasBase):
    fixed_dpi = 72
    filetypes = {'ps': 'Postscript', 'eps': 'Encapsulated Postscript'}

    def get_default_filetype(self):
        return 'ps'

    def _print_ps(self, fmt, outfile, *, metadata=None, papertype=None, orientation='portrait', bbox_inches_restore=None, **kwargs):
        dpi = self.figure.dpi
        self.figure.dpi = 72
        dsc_comments = {}
        if isinstance(outfile, (str, os.PathLike)):
            filename = pathlib.Path(outfile).name
            dsc_comments['Title'] = filename.encode('ascii', 'replace').decode('ascii')
        dsc_comments['Creator'] = (metadata or {}).get('Creator', f'Matplotlib v{mpl.__version__}, https://matplotlib.org/')
        source_date_epoch = os.getenv('SOURCE_DATE_EPOCH')
        dsc_comments['CreationDate'] = datetime.datetime.fromtimestamp(int(source_date_epoch), datetime.timezone.utc).strftime('%a %b %d %H:%M:%S %Y') if source_date_epoch else time.ctime()
        dsc_comments = '\n'.join((f'%%{k}: {v}' for (k, v) in dsc_comments.items()))
        if papertype is None:
            papertype = mpl.rcParams['ps.papersize']
        papertype = papertype.lower()
        _api.check_in_list(['figure', 'auto', *papersize], papertype=papertype)
        orientation = _api.check_getitem(_Orientation, orientation=orientation.lower())
        printer = self._print_figure_tex if mpl.rcParams['text.usetex'] else self._print_figure
        printer(fmt, outfile, dpi=dpi, dsc_comments=dsc_comments, orientation=orientation, papertype=papertype, bbox_inches_restore=bbox_inches_restore, **kwargs)

    def _print_figure(self, fmt, outfile, *, dpi, dsc_comments, orientation, papertype, bbox_inches_restore=None):
        is_eps = fmt == 'eps'
        if not (isinstance(outfile, (str, os.PathLike)) or is_writable_file_like(outfile)):
            raise ValueError('outfile must be a path or a file-like object')
        (width, height) = self.figure.get_size_inches()
        if papertype == 'auto':
            papertype = _get_papertype(*orientation.swap_if_landscape((width, height)))
        if is_eps or papertype == 'figure':
            (paper_width, paper_height) = (width, height)
        else:
            (paper_width, paper_height) = orientation.swap_if_landscape(papersize[papertype])
        xo = 72 * 0.5 * (paper_width - width)
        yo = 72 * 0.5 * (paper_height - height)
        llx = xo
        lly = yo
        urx = llx + self.figure.bbox.width
        ury = lly + self.figure.bbox.height
        rotation = 0
        if orientation is _Orientation.landscape:
            (llx, lly, urx, ury) = (lly, llx, ury, urx)
            (xo, yo) = (72 * paper_height - yo, xo)
            rotation = 90
        bbox = (llx, lly, urx, ury)
        self._pswriter = StringIO()
        ps_renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)
        renderer = MixedModeRenderer(self.figure, width, height, dpi, ps_renderer, bbox_inches_restore=bbox_inches_restore)
        self.figure.draw(renderer)

        def print_figure_impl(fh):
            if is_eps:
                print('%!PS-Adobe-3.0 EPSF-3.0', file=fh)
            else:
                print('%!PS-Adobe-3.0', file=fh)
                if papertype != 'figure':
                    print(f'%%DocumentPaperSizes: {papertype}', file=fh)
                print('%%Pages: 1', file=fh)
            print(f'%%LanguageLevel: 3\n{dsc_comments}\n%%Orientation: {orientation.name}\n{_get_bbox_header(bbox)}\n%%EndComments\n', end='', file=fh)
            Ndict = len(_psDefs)
            print('%%BeginProlog', file=fh)
            if not mpl.rcParams['ps.useafm']:
                Ndict += len(ps_renderer._character_tracker.used)
            print('/mpldict %d dict def' % Ndict, file=fh)
            print('mpldict begin', file=fh)
            print('\n'.join(_psDefs), file=fh)
            if not mpl.rcParams['ps.useafm']:
                for (font_path, chars) in ps_renderer._character_tracker.used.items():
                    if not chars:
                        continue
                    fonttype = mpl.rcParams['ps.fonttype']
                    if len(chars) > 255:
                        fonttype = 42
                    fh.flush()
                    if fonttype == 3:
                        fh.write(_font_to_ps_type3(font_path, chars))
                    else:
                        _font_to_ps_type42(font_path, chars, fh)
            print('end', file=fh)
            print('%%EndProlog', file=fh)
            if not is_eps:
                print('%%Page: 1 1', file=fh)
            print('mpldict begin', file=fh)
            print('%s translate' % _nums_to_str(xo, yo), file=fh)
            if rotation:
                print('%d rotate' % rotation, file=fh)
            print(f'0 0 {_nums_to_str(width * 72, height * 72)} rectclip', file=fh)
            print(self._pswriter.getvalue(), file=fh)
            print('end', file=fh)
            print('showpage', file=fh)
            if not is_eps:
                print('%%EOF', file=fh)
            fh.flush()
        if mpl.rcParams['ps.usedistiller']:
            with TemporaryDirectory() as tmpdir:
                tmpfile = os.path.join(tmpdir, 'tmp.ps')
                with open(tmpfile, 'w', encoding='latin-1') as fh:
                    print_figure_impl(fh)
                if mpl.rcParams['ps.usedistiller'] == 'ghostscript':
                    _try_distill(gs_distill, tmpfile, is_eps, ptype=papertype, bbox=bbox)
                elif mpl.rcParams['ps.usedistiller'] == 'xpdf':
                    _try_distill(xpdf_distill, tmpfile, is_eps, ptype=papertype, bbox=bbox)
                _move_path_to_path_or_stream(tmpfile, outfile)
        else:
            with cbook.open_file_cm(outfile, 'w', encoding='latin-1') as file:
                if not file_requires_unicode(file):
                    file = codecs.getwriter('latin-1')(file)
                print_figure_impl(file)

    def _print_figure_tex(self, fmt, outfile, *, dpi, dsc_comments, orientation, papertype, bbox_inches_restore=None):
        is_eps = fmt == 'eps'
        (width, height) = self.figure.get_size_inches()
        xo = 0
        yo = 0
        llx = xo
        lly = yo
        urx = llx + self.figure.bbox.width
        ury = lly + self.figure.bbox.height
        bbox = (llx, lly, urx, ury)
        self._pswriter = StringIO()
        ps_renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)
        renderer = MixedModeRenderer(self.figure, width, height, dpi, ps_renderer, bbox_inches_restore=bbox_inches_restore)
        self.figure.draw(renderer)
        with TemporaryDirectory() as tmpdir:
            tmppath = pathlib.Path(tmpdir, 'tmp.ps')
            tmppath.write_text(f"%!PS-Adobe-3.0 EPSF-3.0\n%%LanguageLevel: 3\n{dsc_comments}\n{_get_bbox_header(bbox)}\n%%EndComments\n%%BeginProlog\n/mpldict {len(_psDefs)} dict def\nmpldict begin\n{''.join(_psDefs)}\nend\n%%EndProlog\nmpldict begin\n{_nums_to_str(xo, yo)} translate\n0 0 {_nums_to_str(width * 72, height * 72)} rectclip\n{self._pswriter.getvalue()}\nend\nshowpage\n", encoding='latin-1')
            if orientation is _Orientation.landscape:
                (width, height) = (height, width)
                bbox = (lly, llx, ury, urx)
            if is_eps or papertype == 'figure':
                (paper_width, paper_height) = orientation.swap_if_landscape(self.figure.get_size_inches())
            else:
                if papertype == 'auto':
                    papertype = _get_papertype(width, height)
                (paper_width, paper_height) = papersize[papertype]
            psfrag_rotated = _convert_psfrags(tmppath, ps_renderer.psfrag, paper_width, paper_height, orientation.name)
            if mpl.rcParams['ps.usedistiller'] == 'ghostscript' or mpl.rcParams['text.usetex']:
                _try_distill(gs_distill, tmppath, is_eps, ptype=papertype, bbox=bbox, rotated=psfrag_rotated)
            elif mpl.rcParams['ps.usedistiller'] == 'xpdf':
                _try_distill(xpdf_distill, tmppath, is_eps, ptype=papertype, bbox=bbox, rotated=psfrag_rotated)
            _move_path_to_path_or_stream(tmppath, outfile)
    print_ps = functools.partialmethod(_print_ps, 'ps')
    print_eps = functools.partialmethod(_print_ps, 'eps')

    def draw(self):
        self.figure.draw_without_rendering()
        return super().draw()

def _convert_psfrags(tmppath, psfrags, paper_width, paper_height, orientation):
    with mpl.rc_context({'text.latex.preamble': mpl.rcParams['text.latex.preamble'] + mpl.texmanager._usepackage_if_not_loaded('color') + mpl.texmanager._usepackage_if_not_loaded('graphicx') + mpl.texmanager._usepackage_if_not_loaded('psfrag') + '\\geometry{papersize={%(width)sin,%(height)sin},margin=0in}' % {'width': paper_width, 'height': paper_height}}):
        dvifile = TexManager().make_dvi('\n\\begin{figure}\n  \\centering\\leavevmode\n  %(psfrags)s\n  \\includegraphics*[angle=%(angle)s]{%(epsfile)s}\n\\end{figure}' % {'psfrags': '\n'.join(psfrags), 'angle': 90 if orientation == 'landscape' else 0, 'epsfile': tmppath.resolve().as_posix()}, fontsize=10)
    with TemporaryDirectory() as tmpdir:
        psfile = os.path.join(tmpdir, 'tmp.ps')
        cbook._check_and_log_subprocess(['dvips', '-q', '-R0', '-o', psfile, dvifile], _log)
        shutil.move(psfile, tmppath)
    with open(tmppath) as fh:
        psfrag_rotated = 'Landscape' in fh.read(1000)
    return psfrag_rotated

def _try_distill(func, tmppath, *args, **kwargs):
    try:
        func(str(tmppath), *args, **kwargs)
    except mpl.ExecutableNotFoundError as exc:
        _log.warning('%s.  Distillation step skipped.', exc)

def gs_distill(tmpfile, eps=False, ptype='letter', bbox=None, rotated=False):
    if eps:
        paper_option = ['-dEPSCrop']
    elif ptype == 'figure':
        paper_option = [f'-dDEVICEWIDTHPOINTS={bbox[2]}', f'-dDEVICEHEIGHTPOINTS={bbox[3]}']
    else:
        paper_option = [f'-sPAPERSIZE={ptype}']
    psfile = tmpfile + '.ps'
    dpi = mpl.rcParams['ps.distiller.res']
    cbook._check_and_log_subprocess([mpl._get_executable_info('gs').executable, '-dBATCH', '-dNOPAUSE', '-r%d' % dpi, '-sDEVICE=ps2write', *paper_option, f'-sOutputFile={psfile}', tmpfile], _log)
    os.remove(tmpfile)
    shutil.move(psfile, tmpfile)
    if eps:
        pstoeps(tmpfile, bbox, rotated=rotated)

def xpdf_distill(tmpfile, eps=False, ptype='letter', bbox=None, rotated=False):
    mpl._get_executable_info('gs')
    mpl._get_executable_info('pdftops')
    if eps:
        paper_option = ['-dEPSCrop']
    elif ptype == 'figure':
        paper_option = [f'-dDEVICEWIDTHPOINTS#{bbox[2]}', f'-dDEVICEHEIGHTPOINTS#{bbox[3]}']
    else:
        paper_option = [f'-sPAPERSIZE#{ptype}']
    with TemporaryDirectory() as tmpdir:
        tmppdf = pathlib.Path(tmpdir, 'tmp.pdf')
        tmpps = pathlib.Path(tmpdir, 'tmp.ps')
        cbook._check_and_log_subprocess(['ps2pdf', '-dAutoFilterColorImages#false', '-dAutoFilterGrayImages#false', '-sAutoRotatePages#None', '-sGrayImageFilter#FlateEncode', '-sColorImageFilter#FlateEncode', *paper_option, tmpfile, tmppdf], _log)
        cbook._check_and_log_subprocess(['pdftops', '-paper', 'match', '-level3', tmppdf, tmpps], _log)
        shutil.move(tmpps, tmpfile)
    if eps:
        pstoeps(tmpfile)

@_api.deprecated('3.9')
def get_bbox_header(lbrt, rotated=False):
    return (_get_bbox_header(lbrt), _get_rotate_command(lbrt) if rotated else '')

def _get_bbox_header(lbrt):
    (l, b, r, t) = lbrt
    return f'%%BoundingBox: {int(l)} {int(b)} {math.ceil(r)} {math.ceil(t)}\n%%HiResBoundingBox: {l:.6f} {b:.6f} {r:.6f} {t:.6f}'

def _get_rotate_command(lbrt):
    (l, b, r, t) = lbrt
    return f'{l + r:.2f} {0:.2f} translate\n90 rotate'

def pstoeps(tmpfile, bbox=None, rotated=False):
    epsfile = tmpfile + '.eps'
    with open(epsfile, 'wb') as epsh, open(tmpfile, 'rb') as tmph:
        write = epsh.write
        for line in tmph:
            if line.startswith(b'%!PS'):
                write(b'%!PS-Adobe-3.0 EPSF-3.0\n')
                if bbox:
                    write(_get_bbox_header(bbox).encode('ascii') + b'\n')
            elif line.startswith(b'%%EndComments'):
                write(line)
                write(b'%%BeginProlog\nsave\ncountdictstack\nmark\nnewpath\n/showpage {} def\n/setpagedevice {pop} def\n%%EndProlog\n%%Page 1 1\n')
                if rotated:
                    write(_get_rotate_command(bbox).encode('ascii') + b'\n')
                break
            elif bbox and line.startswith((b'%%Bound', b'%%HiResBound', b'%%DocumentMedia', b'%%Pages')):
                pass
            else:
                write(line)
        for line in tmph:
            if line.startswith(b'%%EOF'):
                write(b'cleartomark\ncountdictstack\nexch sub { end } repeat\nrestore\nshowpage\n%%EOF\n')
            elif line.startswith(b'%%PageBoundingBox'):
                pass
            else:
                write(line)
    os.remove(tmpfile)
    shutil.move(epsfile, tmpfile)
FigureManagerPS = FigureManagerBase
_psDefs = ['/_d { bind def } bind def', '/m { moveto } _d', '/l { lineto } _d', '/r { rlineto } _d', '/c { curveto } _d', '/cl { closepath } _d', '/ce { closepath eofill } _d', '/sc { setcachedevice } _d']

@_Backend.export
class _BackendPS(_Backend):
    backend_version = 'Level II'
    FigureCanvas = FigureCanvasPS

# File: matplotlib-main/lib/matplotlib/backends/backend_qt.py
import functools
import os
import sys
import traceback
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2, TimerBase, cursors, ToolContainerBase, MouseButton, CloseEvent, KeyEvent, LocationEvent, MouseEvent, ResizeEvent, _allow_interrupt
import matplotlib.backends.qt_editor.figureoptions as figureoptions
from . import qt_compat
from .qt_compat import QtCore, QtGui, QtWidgets, __version__, QT_API, _to_int, _isdeleted
SPECIAL_KEYS = {_to_int(getattr(QtCore.Qt.Key, k)): v for (k, v) in [('Key_Escape', 'escape'), ('Key_Tab', 'tab'), ('Key_Backspace', 'backspace'), ('Key_Return', 'enter'), ('Key_Enter', 'enter'), ('Key_Insert', 'insert'), ('Key_Delete', 'delete'), ('Key_Pause', 'pause'), ('Key_SysReq', 'sysreq'), ('Key_Clear', 'clear'), ('Key_Home', 'home'), ('Key_End', 'end'), ('Key_Left', 'left'), ('Key_Up', 'up'), ('Key_Right', 'right'), ('Key_Down', 'down'), ('Key_PageUp', 'pageup'), ('Key_PageDown', 'pagedown'), ('Key_Shift', 'shift'), ('Key_Control', 'control' if sys.platform != 'darwin' else 'cmd'), ('Key_Meta', 'meta' if sys.platform != 'darwin' else 'control'), ('Key_Alt', 'alt'), ('Key_CapsLock', 'caps_lock'), ('Key_F1', 'f1'), ('Key_F2', 'f2'), ('Key_F3', 'f3'), ('Key_F4', 'f4'), ('Key_F5', 'f5'), ('Key_F6', 'f6'), ('Key_F7', 'f7'), ('Key_F8', 'f8'), ('Key_F9', 'f9'), ('Key_F10', 'f10'), ('Key_F10', 'f11'), ('Key_F12', 'f12'), ('Key_Super_L', 'super'), ('Key_Super_R', 'super')]}
_MODIFIER_KEYS = [(_to_int(getattr(QtCore.Qt.KeyboardModifier, mod)), _to_int(getattr(QtCore.Qt.Key, key))) for (mod, key) in [('ControlModifier', 'Key_Control'), ('AltModifier', 'Key_Alt'), ('ShiftModifier', 'Key_Shift'), ('MetaModifier', 'Key_Meta')]]
cursord = {k: getattr(QtCore.Qt.CursorShape, v) for (k, v) in [(cursors.MOVE, 'SizeAllCursor'), (cursors.HAND, 'PointingHandCursor'), (cursors.POINTER, 'ArrowCursor'), (cursors.SELECT_REGION, 'CrossCursor'), (cursors.WAIT, 'WaitCursor'), (cursors.RESIZE_HORIZONTAL, 'SizeHorCursor'), (cursors.RESIZE_VERTICAL, 'SizeVerCursor')]}

@functools.lru_cache(1)
def _create_qApp():
    app = QtWidgets.QApplication.instance()
    if app is None:
        if not mpl._c_internal_utils.display_is_valid():
            raise RuntimeError('Invalid DISPLAY variable')
        if QT_API in {'PyQt6', 'PySide6'}:
            other_bindings = ('PyQt5', 'PySide2')
            qt_version = 6
        elif QT_API in {'PyQt5', 'PySide2'}:
            other_bindings = ('PyQt6', 'PySide6')
            qt_version = 5
        else:
            raise RuntimeError('Should never be here')
        for binding in other_bindings:
            mod = sys.modules.get(f'{binding}.QtWidgets')
            if mod is not None and mod.QApplication.instance() is not None:
                other_core = sys.modules.get(f'{binding}.QtCore')
                _api.warn_external(f'Matplotlib is using {QT_API} which wraps {QtCore.qVersion()} however an instantiated QApplication from {binding} which wraps {other_core.qVersion()} exists.  Mixing Qt major versions may not work as expected.')
                break
        if qt_version == 5:
            try:
                QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
            except AttributeError:
                pass
        try:
            QtWidgets.QApplication.setHighDpiScaleFactorRoundingPolicy(QtCore.Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
        except AttributeError:
            pass
        app = QtWidgets.QApplication(['matplotlib'])
        if sys.platform == 'darwin':
            image = str(cbook._get_data_path('images/matplotlib.svg'))
            icon = QtGui.QIcon(image)
            app.setWindowIcon(icon)
        app.setQuitOnLastWindowClosed(True)
        cbook._setup_new_guiapp()
        if qt_version == 5:
            app.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps)
    return app

def _allow_interrupt_qt(qapp_or_eventloop):

    def prepare_notifier(rsock):
        sn = QtCore.QSocketNotifier(rsock.fileno(), QtCore.QSocketNotifier.Type.Read)

        @sn.activated.connect
        def _may_clear_sock():
            try:
                rsock.recv(1)
            except BlockingIOError:
                pass
        return sn

    def handle_sigint():
        if hasattr(qapp_or_eventloop, 'closeAllWindows'):
            qapp_or_eventloop.closeAllWindows()
        qapp_or_eventloop.quit()
    return _allow_interrupt(prepare_notifier, handle_sigint)

class TimerQT(TimerBase):

    def __init__(self, *args, **kwargs):
        self._timer = QtCore.QTimer()
        self._timer.timeout.connect(self._on_timer)
        super().__init__(*args, **kwargs)

    def __del__(self):
        if not _isdeleted(self._timer):
            self._timer_stop()

    def _timer_set_single_shot(self):
        self._timer.setSingleShot(self._single)

    def _timer_set_interval(self):
        self._timer.setInterval(self._interval)

    def _timer_start(self):
        self._timer.start()

    def _timer_stop(self):
        self._timer.stop()

class FigureCanvasQT(FigureCanvasBase, QtWidgets.QWidget):
    required_interactive_framework = 'qt'
    _timer_cls = TimerQT
    manager_class = _api.classproperty(lambda cls: FigureManagerQT)
    buttond = {getattr(QtCore.Qt.MouseButton, k): v for (k, v) in [('LeftButton', MouseButton.LEFT), ('RightButton', MouseButton.RIGHT), ('MiddleButton', MouseButton.MIDDLE), ('XButton1', MouseButton.BACK), ('XButton2', MouseButton.FORWARD)]}

    def __init__(self, figure=None):
        _create_qApp()
        super().__init__(figure=figure)
        self._draw_pending = False
        self._is_drawing = False
        self._draw_rect_callback = lambda painter: None
        self._in_resize_event = False
        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_OpaquePaintEvent)
        self.setMouseTracking(True)
        self.resize(*self.get_width_height())
        palette = QtGui.QPalette(QtGui.QColor('white'))
        self.setPalette(palette)

    def _update_pixel_ratio(self):
        if self._set_device_pixel_ratio(self.devicePixelRatioF() or 1):
            event = QtGui.QResizeEvent(self.size(), self.size())
            self.resizeEvent(event)

    def _update_screen(self, screen):
        self._update_pixel_ratio()
        if screen is not None:
            screen.physicalDotsPerInchChanged.connect(self._update_pixel_ratio)
            screen.logicalDotsPerInchChanged.connect(self._update_pixel_ratio)

    def showEvent(self, event):
        window = self.window().windowHandle()
        window.screenChanged.connect(self._update_screen)
        self._update_screen(window.screen())

    def set_cursor(self, cursor):
        self.setCursor(_api.check_getitem(cursord, cursor=cursor))

    def mouseEventCoords(self, pos=None):
        if pos is None:
            pos = self.mapFromGlobal(QtGui.QCursor.pos())
        elif hasattr(pos, 'position'):
            pos = pos.position()
        elif hasattr(pos, 'pos'):
            pos = pos.pos()
        x = pos.x()
        y = self.figure.bbox.height / self.device_pixel_ratio - pos.y()
        return (x * self.device_pixel_ratio, y * self.device_pixel_ratio)

    def enterEvent(self, event):
        mods = QtWidgets.QApplication.instance().queryKeyboardModifiers()
        if self.figure is None:
            return
        LocationEvent('figure_enter_event', self, *self.mouseEventCoords(event), modifiers=self._mpl_modifiers(mods), guiEvent=event)._process()

    def leaveEvent(self, event):
        QtWidgets.QApplication.restoreOverrideCursor()
        if self.figure is None:
            return
        LocationEvent('figure_leave_event', self, *self.mouseEventCoords(), modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def mousePressEvent(self, event):
        button = self.buttond.get(event.button())
        if button is not None and self.figure is not None:
            MouseEvent('button_press_event', self, *self.mouseEventCoords(event), button, modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def mouseDoubleClickEvent(self, event):
        button = self.buttond.get(event.button())
        if button is not None and self.figure is not None:
            MouseEvent('button_press_event', self, *self.mouseEventCoords(event), button, dblclick=True, modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def mouseMoveEvent(self, event):
        if self.figure is None:
            return
        MouseEvent('motion_notify_event', self, *self.mouseEventCoords(event), modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def mouseReleaseEvent(self, event):
        button = self.buttond.get(event.button())
        if button is not None and self.figure is not None:
            MouseEvent('button_release_event', self, *self.mouseEventCoords(event), button, modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def wheelEvent(self, event):
        if event.pixelDelta().isNull() or QtWidgets.QApplication.instance().platformName() == 'xcb':
            steps = event.angleDelta().y() / 120
        else:
            steps = event.pixelDelta().y()
        if steps and self.figure is not None:
            MouseEvent('scroll_event', self, *self.mouseEventCoords(event), step=steps, modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def keyPressEvent(self, event):
        key = self._get_key(event)
        if key is not None and self.figure is not None:
            KeyEvent('key_press_event', self, key, *self.mouseEventCoords(), guiEvent=event)._process()

    def keyReleaseEvent(self, event):
        key = self._get_key(event)
        if key is not None and self.figure is not None:
            KeyEvent('key_release_event', self, key, *self.mouseEventCoords(), guiEvent=event)._process()

    def resizeEvent(self, event):
        if self._in_resize_event:
            return
        if self.figure is None:
            return
        self._in_resize_event = True
        try:
            w = event.size().width() * self.device_pixel_ratio
            h = event.size().height() * self.device_pixel_ratio
            dpival = self.figure.dpi
            winch = w / dpival
            hinch = h / dpival
            self.figure.set_size_inches(winch, hinch, forward=False)
            QtWidgets.QWidget.resizeEvent(self, event)
            ResizeEvent('resize_event', self)._process()
            self.draw_idle()
        finally:
            self._in_resize_event = False

    def sizeHint(self):
        (w, h) = self.get_width_height()
        return QtCore.QSize(w, h)

    def minimumSizeHint(self):
        return QtCore.QSize(10, 10)

    @staticmethod
    def _mpl_modifiers(modifiers=None, *, exclude=None):
        if modifiers is None:
            modifiers = QtWidgets.QApplication.instance().keyboardModifiers()
        modifiers = _to_int(modifiers)
        return [SPECIAL_KEYS[key].replace('control', 'ctrl') for (mask, key) in _MODIFIER_KEYS if exclude != key and modifiers & mask]

    def _get_key(self, event):
        event_key = event.key()
        mods = self._mpl_modifiers(exclude=event_key)
        try:
            key = SPECIAL_KEYS[event_key]
        except KeyError:
            if event_key > sys.maxunicode:
                return None
            key = chr(event_key)
            if 'shift' in mods:
                mods.remove('shift')
            else:
                key = key.lower()
        return '+'.join(mods + [key])

    def flush_events(self):
        QtWidgets.QApplication.instance().processEvents()

    def start_event_loop(self, timeout=0):
        if hasattr(self, '_event_loop') and self._event_loop.isRunning():
            raise RuntimeError('Event loop already running')
        self._event_loop = event_loop = QtCore.QEventLoop()
        if timeout > 0:
            _ = QtCore.QTimer.singleShot(int(timeout * 1000), event_loop.quit)
        with _allow_interrupt_qt(event_loop):
            qt_compat._exec(event_loop)

    def stop_event_loop(self, event=None):
        if hasattr(self, '_event_loop'):
            self._event_loop.quit()

    def draw(self):
        if self._is_drawing:
            return
        with cbook._setattr_cm(self, _is_drawing=True):
            super().draw()
        self.update()

    def draw_idle(self):
        if not (getattr(self, '_draw_pending', False) or getattr(self, '_is_drawing', False)):
            self._draw_pending = True
            QtCore.QTimer.singleShot(0, self._draw_idle)

    def blit(self, bbox=None):
        if bbox is None and self.figure:
            bbox = self.figure.bbox
        (l, b, w, h) = (int(pt / self.device_pixel_ratio) for pt in bbox.bounds)
        t = b + h
        self.repaint(l, self.rect().height() - t, w, h)

    def _draw_idle(self):
        with self._idle_draw_cntx():
            if not self._draw_pending:
                return
            self._draw_pending = False
            if self.height() <= 0 or self.width() <= 0:
                return
            try:
                self.draw()
            except Exception:
                traceback.print_exc()

    def drawRectangle(self, rect):
        if rect is not None:
            (x0, y0, w, h) = (int(pt / self.device_pixel_ratio) for pt in rect)
            x1 = x0 + w
            y1 = y0 + h

            def _draw_rect_callback(painter):
                pen = QtGui.QPen(QtGui.QColor('black'), 1 / self.device_pixel_ratio)
                pen.setDashPattern([3, 3])
                for (color, offset) in [(QtGui.QColor('black'), 0), (QtGui.QColor('white'), 3)]:
                    pen.setDashOffset(offset)
                    pen.setColor(color)
                    painter.setPen(pen)
                    painter.drawLine(x0, y0, x0, y1)
                    painter.drawLine(x0, y0, x1, y0)
                    painter.drawLine(x0, y1, x1, y1)
                    painter.drawLine(x1, y0, x1, y1)
        else:

            def _draw_rect_callback(painter):
                return
        self._draw_rect_callback = _draw_rect_callback
        self.update()

class MainWindow(QtWidgets.QMainWindow):
    closing = QtCore.Signal()

    def closeEvent(self, event):
        self.closing.emit()
        super().closeEvent(event)

class FigureManagerQT(FigureManagerBase):

    def __init__(self, canvas, num):
        self.window = MainWindow()
        super().__init__(canvas, num)
        self.window.closing.connect(self._widgetclosed)
        if sys.platform != 'darwin':
            image = str(cbook._get_data_path('images/matplotlib.svg'))
            icon = QtGui.QIcon(image)
            self.window.setWindowIcon(icon)
        self.window._destroying = False
        if self.toolbar:
            self.window.addToolBar(self.toolbar)
            tbs_height = self.toolbar.sizeHint().height()
        else:
            tbs_height = 0
        cs = canvas.sizeHint()
        cs_height = cs.height()
        height = cs_height + tbs_height
        self.window.resize(cs.width(), height)
        self.window.setCentralWidget(self.canvas)
        if mpl.is_interactive():
            self.window.show()
            self.canvas.draw_idle()
        self.canvas.setFocusPolicy(QtCore.Qt.FocusPolicy.StrongFocus)
        self.canvas.setFocus()
        self.window.raise_()

    def full_screen_toggle(self):
        if self.window.isFullScreen():
            self.window.showNormal()
        else:
            self.window.showFullScreen()

    def _widgetclosed(self):
        CloseEvent('close_event', self.canvas)._process()
        if self.window._destroying:
            return
        self.window._destroying = True
        try:
            Gcf.destroy(self)
        except AttributeError:
            pass

    def resize(self, width, height):
        width = int(width / self.canvas.device_pixel_ratio)
        height = int(height / self.canvas.device_pixel_ratio)
        extra_width = self.window.width() - self.canvas.width()
        extra_height = self.window.height() - self.canvas.height()
        self.canvas.resize(width, height)
        self.window.resize(width + extra_width, height + extra_height)

    @classmethod
    def start_main_loop(cls):
        qapp = QtWidgets.QApplication.instance()
        if qapp:
            with _allow_interrupt_qt(qapp):
                qt_compat._exec(qapp)

    def show(self):
        self.window._destroying = False
        self.window.show()
        if mpl.rcParams['figure.raise_window']:
            self.window.activateWindow()
            self.window.raise_()

    def destroy(self, *args):
        if QtWidgets.QApplication.instance() is None:
            return
        if self.window._destroying:
            return
        self.window._destroying = True
        if self.toolbar:
            self.toolbar.destroy()
        self.window.close()

    def get_window_title(self):
        return self.window.windowTitle()

    def set_window_title(self, title):
        self.window.setWindowTitle(title)

class NavigationToolbar2QT(NavigationToolbar2, QtWidgets.QToolBar):
    _message = QtCore.Signal(str)
    message = _api.deprecate_privatize_attribute('3.8')
    toolitems = [*NavigationToolbar2.toolitems]
    toolitems.insert([name for (name, *_) in toolitems].index('Subplots') + 1, ('Customize', 'Edit axis, curve and image parameters', 'qt4_editor_options', 'edit_parameters'))

    def __init__(self, canvas, parent=None, coordinates=True):
        QtWidgets.QToolBar.__init__(self, parent)
        self.setAllowedAreas(QtCore.Qt.ToolBarArea(_to_int(QtCore.Qt.ToolBarArea.TopToolBarArea) | _to_int(QtCore.Qt.ToolBarArea.BottomToolBarArea)))
        self.coordinates = coordinates
        self._actions = {}
        self._subplot_dialog = None
        for (text, tooltip_text, image_file, callback) in self.toolitems:
            if text is None:
                self.addSeparator()
            else:
                slot = getattr(self, callback)
                slot = functools.wraps(slot)(functools.partial(slot))
                slot = QtCore.Slot()(slot)
                a = self.addAction(self._icon(image_file + '.png'), text, slot)
                self._actions[callback] = a
                if callback in ['zoom', 'pan']:
                    a.setCheckable(True)
                if tooltip_text is not None:
                    a.setToolTip(tooltip_text)
        if self.coordinates:
            self.locLabel = QtWidgets.QLabel('', self)
            self.locLabel.setAlignment(QtCore.Qt.AlignmentFlag(_to_int(QtCore.Qt.AlignmentFlag.AlignRight) | _to_int(QtCore.Qt.AlignmentFlag.AlignVCenter)))
            self.locLabel.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Ignored))
            labelAction = self.addWidget(self.locLabel)
            labelAction.setVisible(True)
        NavigationToolbar2.__init__(self, canvas)

    def _icon(self, name):
        path_regular = cbook._get_data_path('images', name)
        path_large = path_regular.with_name(path_regular.name.replace('.png', '_large.png'))
        filename = str(path_large if path_large.exists() else path_regular)
        pm = QtGui.QPixmap(filename)
        pm.setDevicePixelRatio(self.devicePixelRatioF() or 1)
        if self.palette().color(self.backgroundRole()).value() < 128:
            icon_color = self.palette().color(self.foregroundRole())
            mask = pm.createMaskFromColor(QtGui.QColor('black'), QtCore.Qt.MaskMode.MaskOutColor)
            pm.fill(icon_color)
            pm.setMask(mask)
        return QtGui.QIcon(pm)

    def edit_parameters(self):
        axes = self.canvas.figure.get_axes()
        if not axes:
            QtWidgets.QMessageBox.warning(self.canvas.parent(), 'Error', 'There are no Axes to edit.')
            return
        elif len(axes) == 1:
            (ax,) = axes
        else:
            titles = [ax.get_label() or ax.get_title() or ax.get_title('left') or ax.get_title('right') or ' - '.join(filter(None, [ax.get_xlabel(), ax.get_ylabel()])) or f'<anonymous {type(ax).__name__}>' for ax in axes]
            duplicate_titles = [title for title in titles if titles.count(title) > 1]
            for (i, ax) in enumerate(axes):
                if titles[i] in duplicate_titles:
                    titles[i] += f' (id: {id(ax):#x})'
            (item, ok) = QtWidgets.QInputDialog.getItem(self.canvas.parent(), 'Customize', 'Select Axes:', titles, 0, False)
            if not ok:
                return
            ax = axes[titles.index(item)]
        figureoptions.figure_edit(ax, self)

    def _update_buttons_checked(self):
        if 'pan' in self._actions:
            self._actions['pan'].setChecked(self.mode.name == 'PAN')
        if 'zoom' in self._actions:
            self._actions['zoom'].setChecked(self.mode.name == 'ZOOM')

    def pan(self, *args):
        super().pan(*args)
        self._update_buttons_checked()

    def zoom(self, *args):
        super().zoom(*args)
        self._update_buttons_checked()

    def set_message(self, s):
        self._message.emit(s)
        if self.coordinates:
            self.locLabel.setText(s)

    def draw_rubberband(self, event, x0, y0, x1, y1):
        height = self.canvas.figure.bbox.height
        y1 = height - y1
        y0 = height - y0
        rect = [int(val) for val in (x0, y0, x1 - x0, y1 - y0)]
        self.canvas.drawRectangle(rect)

    def remove_rubberband(self):
        self.canvas.drawRectangle(None)

    def configure_subplots(self):
        if self._subplot_dialog is None:
            self._subplot_dialog = SubplotToolQt(self.canvas.figure, self.canvas.parent())
            self.canvas.mpl_connect('close_event', lambda e: self._subplot_dialog.reject())
        self._subplot_dialog.update_from_current_subplotpars()
        self._subplot_dialog.setModal(True)
        self._subplot_dialog.show()
        return self._subplot_dialog

    def save_figure(self, *args):
        filetypes = self.canvas.get_supported_filetypes_grouped()
        sorted_filetypes = sorted(filetypes.items())
        default_filetype = self.canvas.get_default_filetype()
        startpath = os.path.expanduser(mpl.rcParams['savefig.directory'])
        start = os.path.join(startpath, self.canvas.get_default_filename())
        filters = []
        selectedFilter = None
        for (name, exts) in sorted_filetypes:
            exts_list = ' '.join(['*.%s' % ext for ext in exts])
            filter = f'{name} ({exts_list})'
            if default_filetype in exts:
                selectedFilter = filter
            filters.append(filter)
        filters = ';;'.join(filters)
        (fname, filter) = QtWidgets.QFileDialog.getSaveFileName(self.canvas.parent(), 'Choose a filename to save to', start, filters, selectedFilter)
        if fname:
            if startpath != '':
                mpl.rcParams['savefig.directory'] = os.path.dirname(fname)
            try:
                self.canvas.figure.savefig(fname)
            except Exception as e:
                QtWidgets.QMessageBox.critical(self, 'Error saving file', str(e), QtWidgets.QMessageBox.StandardButton.Ok, QtWidgets.QMessageBox.StandardButton.NoButton)

    def set_history_buttons(self):
        can_backward = self._nav_stack._pos > 0
        can_forward = self._nav_stack._pos < len(self._nav_stack) - 1
        if 'back' in self._actions:
            self._actions['back'].setEnabled(can_backward)
        if 'forward' in self._actions:
            self._actions['forward'].setEnabled(can_forward)

class SubplotToolQt(QtWidgets.QDialog):

    def __init__(self, targetfig, parent):
        super().__init__()
        self.setWindowIcon(QtGui.QIcon(str(cbook._get_data_path('images/matplotlib.png'))))
        self.setObjectName('SubplotTool')
        self._spinboxes = {}
        main_layout = QtWidgets.QHBoxLayout()
        self.setLayout(main_layout)
        for (group, spinboxes, buttons) in [('Borders', ['top', 'bottom', 'left', 'right'], [('Export values', self._export_values)]), ('Spacings', ['hspace', 'wspace'], [('Tight layout', self._tight_layout), ('Reset', self._reset), ('Close', self.close)])]:
            layout = QtWidgets.QVBoxLayout()
            main_layout.addLayout(layout)
            box = QtWidgets.QGroupBox(group)
            layout.addWidget(box)
            inner = QtWidgets.QFormLayout(box)
            for name in spinboxes:
                self._spinboxes[name] = spinbox = QtWidgets.QDoubleSpinBox()
                spinbox.setRange(0, 1)
                spinbox.setDecimals(3)
                spinbox.setSingleStep(0.005)
                spinbox.setKeyboardTracking(False)
                spinbox.valueChanged.connect(self._on_value_changed)
                inner.addRow(name, spinbox)
            layout.addStretch(1)
            for (name, method) in buttons:
                button = QtWidgets.QPushButton(name)
                button.setAutoDefault(False)
                button.clicked.connect(method)
                layout.addWidget(button)
                if name == 'Close':
                    button.setFocus()
        self._figure = targetfig
        self._defaults = {}
        self._export_values_dialog = None
        self.update_from_current_subplotpars()

    def update_from_current_subplotpars(self):
        self._defaults = {spinbox: getattr(self._figure.subplotpars, name) for (name, spinbox) in self._spinboxes.items()}
        self._reset()

    def _export_values(self):
        self._export_values_dialog = QtWidgets.QDialog()
        layout = QtWidgets.QVBoxLayout()
        self._export_values_dialog.setLayout(layout)
        text = QtWidgets.QPlainTextEdit()
        text.setReadOnly(True)
        layout.addWidget(text)
        text.setPlainText(',\n'.join((f'{attr}={spinbox.value():.3}' for (attr, spinbox) in self._spinboxes.items())))
        size = text.maximumSize()
        size.setHeight(QtGui.QFontMetrics(text.document().defaultFont()).size(0, text.toPlainText()).height() + 20)
        text.setMaximumSize(size)
        self._export_values_dialog.show()

    def _on_value_changed(self):
        spinboxes = self._spinboxes
        for (lower, higher) in [('bottom', 'top'), ('left', 'right')]:
            spinboxes[higher].setMinimum(spinboxes[lower].value() + 0.001)
            spinboxes[lower].setMaximum(spinboxes[higher].value() - 0.001)
        self._figure.subplots_adjust(**{attr: spinbox.value() for (attr, spinbox) in spinboxes.items()})
        self._figure.canvas.draw_idle()

    def _tight_layout(self):
        self._figure.tight_layout()
        for (attr, spinbox) in self._spinboxes.items():
            spinbox.blockSignals(True)
            spinbox.setValue(getattr(self._figure.subplotpars, attr))
            spinbox.blockSignals(False)
        self._figure.canvas.draw_idle()

    def _reset(self):
        for (spinbox, value) in self._defaults.items():
            spinbox.setRange(0, 1)
            spinbox.blockSignals(True)
            spinbox.setValue(value)
            spinbox.blockSignals(False)
        self._on_value_changed()

class ToolbarQt(ToolContainerBase, QtWidgets.QToolBar):

    def __init__(self, toolmanager, parent=None):
        ToolContainerBase.__init__(self, toolmanager)
        QtWidgets.QToolBar.__init__(self, parent)
        self.setAllowedAreas(QtCore.Qt.ToolBarArea(_to_int(QtCore.Qt.ToolBarArea.TopToolBarArea) | _to_int(QtCore.Qt.ToolBarArea.BottomToolBarArea)))
        message_label = QtWidgets.QLabel('')
        message_label.setAlignment(QtCore.Qt.AlignmentFlag(_to_int(QtCore.Qt.AlignmentFlag.AlignRight) | _to_int(QtCore.Qt.AlignmentFlag.AlignVCenter)))
        message_label.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Ignored))
        self._message_action = self.addWidget(message_label)
        self._toolitems = {}
        self._groups = {}

    def add_toolitem(self, name, group, position, image_file, description, toggle):
        button = QtWidgets.QToolButton(self)
        if image_file:
            button.setIcon(NavigationToolbar2QT._icon(self, image_file))
        button.setText(name)
        if description:
            button.setToolTip(description)

        def handler():
            self.trigger_tool(name)
        if toggle:
            button.setCheckable(True)
            button.toggled.connect(handler)
        else:
            button.clicked.connect(handler)
        self._toolitems.setdefault(name, [])
        self._add_to_group(group, name, button, position)
        self._toolitems[name].append((button, handler))

    def _add_to_group(self, group, name, button, position):
        gr = self._groups.get(group, [])
        if not gr:
            sep = self.insertSeparator(self._message_action)
            gr.append(sep)
        before = gr[position]
        widget = self.insertWidget(before, button)
        gr.insert(position, widget)
        self._groups[group] = gr

    def toggle_toolitem(self, name, toggled):
        if name not in self._toolitems:
            return
        for (button, handler) in self._toolitems[name]:
            button.toggled.disconnect(handler)
            button.setChecked(toggled)
            button.toggled.connect(handler)

    def remove_toolitem(self, name):
        for (button, handler) in self._toolitems.pop(name, []):
            button.setParent(None)

    def set_message(self, s):
        self.widgetForAction(self._message_action).setText(s)

@backend_tools._register_tool_class(FigureCanvasQT)
class ConfigureSubplotsQt(backend_tools.ConfigureSubplotsBase):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._subplot_dialog = None

    def trigger(self, *args):
        NavigationToolbar2QT.configure_subplots(self)

@backend_tools._register_tool_class(FigureCanvasQT)
class SaveFigureQt(backend_tools.SaveFigureBase):

    def trigger(self, *args):
        NavigationToolbar2QT.save_figure(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(FigureCanvasQT)
class RubberbandQt(backend_tools.RubberbandBase):

    def draw_rubberband(self, x0, y0, x1, y1):
        NavigationToolbar2QT.draw_rubberband(self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)

    def remove_rubberband(self):
        NavigationToolbar2QT.remove_rubberband(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(FigureCanvasQT)
class HelpQt(backend_tools.ToolHelpBase):

    def trigger(self, *args):
        QtWidgets.QMessageBox.information(None, 'Help', self._get_help_html())

@backend_tools._register_tool_class(FigureCanvasQT)
class ToolCopyToClipboardQT(backend_tools.ToolCopyToClipboardBase):

    def trigger(self, *args, **kwargs):
        pixmap = self.canvas.grab()
        QtWidgets.QApplication.instance().clipboard().setPixmap(pixmap)
FigureManagerQT._toolbar2_class = NavigationToolbar2QT
FigureManagerQT._toolmanager_toolbar_class = ToolbarQt

@_Backend.export
class _BackendQT(_Backend):
    backend_version = __version__
    FigureCanvas = FigureCanvasQT
    FigureManager = FigureManagerQT
    mainloop = FigureManagerQT.start_main_loop

# File: matplotlib-main/lib/matplotlib/backends/backend_qt5.py
from .. import backends
backends._QT_FORCE_QT5_BINDING = True
from .backend_qt import SPECIAL_KEYS, cursord, _create_qApp, _BackendQT, TimerQT, MainWindow, FigureCanvasQT, FigureManagerQT, ToolbarQt, NavigationToolbar2QT, SubplotToolQt, SaveFigureQt, ConfigureSubplotsQt, RubberbandQt, HelpQt, ToolCopyToClipboardQT, FigureCanvasBase, FigureManagerBase, MouseButton, NavigationToolbar2, TimerBase, ToolContainerBase, figureoptions, Gcf
from . import backend_qt as _backend_qt

@_BackendQT.export
class _BackendQT5(_BackendQT):
    pass

def __getattr__(name):
    if name == 'qApp':
        return _backend_qt.qApp
    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')

# File: matplotlib-main/lib/matplotlib/backends/backend_qt5agg.py
""""""
from .. import backends
backends._QT_FORCE_QT5_BINDING = True
from .backend_qtagg import _BackendQTAgg, FigureCanvasQTAgg, FigureManagerQT, NavigationToolbar2QT, FigureCanvasAgg, FigureCanvasQT

@_BackendQTAgg.export
class _BackendQT5Agg(_BackendQTAgg):
    pass

# File: matplotlib-main/lib/matplotlib/backends/backend_qtagg.py
""""""
import ctypes
from matplotlib.transforms import Bbox
from .qt_compat import QT_API, QtCore, QtGui
from .backend_agg import FigureCanvasAgg
from .backend_qt import _BackendQT, FigureCanvasQT
from .backend_qt import FigureManagerQT, NavigationToolbar2QT

class FigureCanvasQTAgg(FigureCanvasAgg, FigureCanvasQT):

    def paintEvent(self, event):
        self._draw_idle()
        if not hasattr(self, 'renderer'):
            return
        painter = QtGui.QPainter(self)
        try:
            rect = event.rect()
            width = rect.width() * self.device_pixel_ratio
            height = rect.height() * self.device_pixel_ratio
            (left, top) = self.mouseEventCoords(rect.topLeft())
            bottom = top - height
            right = left + width
            bbox = Bbox([[left, bottom], [right, top]])
            buf = memoryview(self.copy_from_bbox(bbox))
            if QT_API == 'PyQt6':
                from PyQt6 import sip
                ptr = int(sip.voidptr(buf))
            else:
                ptr = buf
            painter.eraseRect(rect)
            qimage = QtGui.QImage(ptr, buf.shape[1], buf.shape[0], QtGui.QImage.Format.Format_RGBA8888)
            qimage.setDevicePixelRatio(self.device_pixel_ratio)
            origin = QtCore.QPoint(rect.left(), rect.top())
            painter.drawImage(origin, qimage)
            if QT_API == 'PySide2' and QtCore.__version_info__ < (5, 12):
                ctypes.c_long.from_address(id(buf)).value = 1
            self._draw_rect_callback(painter)
        finally:
            painter.end()

    def print_figure(self, *args, **kwargs):
        super().print_figure(*args, **kwargs)
        self._draw_pending = True

@_BackendQT.export
class _BackendQTAgg(_BackendQT):
    FigureCanvas = FigureCanvasQTAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_qtcairo.py
import ctypes
from .backend_cairo import cairo, FigureCanvasCairo
from .backend_qt import _BackendQT, FigureCanvasQT
from .qt_compat import QT_API, QtCore, QtGui

class FigureCanvasQTCairo(FigureCanvasCairo, FigureCanvasQT):

    def draw(self):
        if hasattr(self._renderer.gc, 'ctx'):
            self._renderer.dpi = self.figure.dpi
            self.figure.draw(self._renderer)
        super().draw()

    def paintEvent(self, event):
        width = int(self.device_pixel_ratio * self.width())
        height = int(self.device_pixel_ratio * self.height())
        if (width, height) != self._renderer.get_canvas_width_height():
            surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
            self._renderer.set_context(cairo.Context(surface))
            self._renderer.dpi = self.figure.dpi
            self.figure.draw(self._renderer)
        buf = self._renderer.gc.ctx.get_target().get_data()
        if QT_API == 'PyQt6':
            from PyQt6 import sip
            ptr = int(sip.voidptr(buf))
        else:
            ptr = buf
        qimage = QtGui.QImage(ptr, width, height, QtGui.QImage.Format.Format_ARGB32_Premultiplied)
        if QT_API == 'PySide2' and QtCore.__version_info__ < (5, 12):
            ctypes.c_long.from_address(id(buf)).value = 1
        qimage.setDevicePixelRatio(self.device_pixel_ratio)
        painter = QtGui.QPainter(self)
        painter.eraseRect(event.rect())
        painter.drawImage(0, 0, qimage)
        self._draw_rect_callback(painter)
        painter.end()

@_BackendQT.export
class _BackendQTCairo(_BackendQT):
    FigureCanvas = FigureCanvasQTCairo

# File: matplotlib-main/lib/matplotlib/backends/backend_svg.py
import base64
import codecs
import datetime
import gzip
import hashlib
from io import BytesIO
import itertools
import logging
import os
import re
import uuid
import numpy as np
from PIL import Image
import matplotlib as mpl
from matplotlib import cbook, font_manager as fm
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, RendererBase
from matplotlib.backends.backend_mixed import MixedModeRenderer
from matplotlib.colors import rgb2hex
from matplotlib.dates import UTC
from matplotlib.path import Path
from matplotlib import _path
from matplotlib.transforms import Affine2D, Affine2DBase
_log = logging.getLogger(__name__)

def _escape_cdata(s):
    s = s.replace('&', '&amp;')
    s = s.replace('<', '&lt;')
    s = s.replace('>', '&gt;')
    return s
_escape_xml_comment = re.compile('-(?=-)')

def _escape_comment(s):
    s = _escape_cdata(s)
    return _escape_xml_comment.sub('- ', s)

def _escape_attrib(s):
    s = s.replace('&', '&amp;')
    s = s.replace("'", '&apos;')
    s = s.replace('"', '&quot;')
    s = s.replace('<', '&lt;')
    s = s.replace('>', '&gt;')
    return s

def _quote_escape_attrib(s):
    return '"' + _escape_cdata(s) + '"' if '"' not in s else "'" + _escape_cdata(s) + "'" if "'" not in s else '"' + _escape_attrib(s) + '"'

def _short_float_fmt(x):
    return f'{x:f}'.rstrip('0').rstrip('.')

class XMLWriter:

    def __init__(self, file):
        self.__write = file.write
        if hasattr(file, 'flush'):
            self.flush = file.flush
        self.__open = 0
        self.__tags = []
        self.__data = []
        self.__indentation = ' ' * 64

    def __flush(self, indent=True):
        if self.__open:
            if indent:
                self.__write('>\n')
            else:
                self.__write('>')
            self.__open = 0
        if self.__data:
            data = ''.join(self.__data)
            self.__write(_escape_cdata(data))
            self.__data = []

    def start(self, tag, attrib={}, **extra):
        self.__flush()
        tag = _escape_cdata(tag)
        self.__data = []
        self.__tags.append(tag)
        self.__write(self.__indentation[:len(self.__tags) - 1])
        self.__write(f'<{tag}')
        for (k, v) in {**attrib, **extra}.items():
            if v:
                k = _escape_cdata(k)
                v = _quote_escape_attrib(v)
                self.__write(f' {k}={v}')
        self.__open = 1
        return len(self.__tags) - 1

    def comment(self, comment):
        self.__flush()
        self.__write(self.__indentation[:len(self.__tags)])
        self.__write(f'<!-- {_escape_comment(comment)} -->\n')

    def data(self, text):
        self.__data.append(text)

    def end(self, tag=None, indent=True):
        if tag:
            assert self.__tags, f'unbalanced end({tag})'
            assert _escape_cdata(tag) == self.__tags[-1], f'expected end({self.__tags[-1]}), got {tag}'
        else:
            assert self.__tags, 'unbalanced end()'
        tag = self.__tags.pop()
        if self.__data:
            self.__flush(indent)
        elif self.__open:
            self.__open = 0
            self.__write('/>\n')
            return
        if indent:
            self.__write(self.__indentation[:len(self.__tags)])
        self.__write(f'</{tag}>\n')

    def close(self, id):
        while len(self.__tags) > id:
            self.end()

    def element(self, tag, text=None, attrib={}, **extra):
        self.start(tag, attrib, **extra)
        if text:
            self.data(text)
        self.end(indent=False)

    def flush(self):
        pass

def _generate_transform(transform_list):
    parts = []
    for (type, value) in transform_list:
        if type == 'scale' and (value == (1,) or value == (1, 1)) or (type == 'translate' and value == (0, 0)) or (type == 'rotate' and value == (0,)):
            continue
        if type == 'matrix' and isinstance(value, Affine2DBase):
            value = value.to_values()
        parts.append('{}({})'.format(type, ' '.join((_short_float_fmt(x) for x in value))))
    return ' '.join(parts)

def _generate_css(attrib):
    return '; '.join((f'{k}: {v}' for (k, v) in attrib.items()))
_capstyle_d = {'projecting': 'square', 'butt': 'butt', 'round': 'round'}

def _check_is_str(info, key):
    if not isinstance(info, str):
        raise TypeError(f'Invalid type for {key} metadata. Expected str, not {type(info)}.')

def _check_is_iterable_of_str(infos, key):
    if np.iterable(infos):
        for info in infos:
            if not isinstance(info, str):
                raise TypeError(f'Invalid type for {key} metadata. Expected iterable of str, not {type(info)}.')
    else:
        raise TypeError(f'Invalid type for {key} metadata. Expected str or iterable of str, not {type(infos)}.')

class RendererSVG(RendererBase):

    def __init__(self, width, height, svgwriter, basename=None, image_dpi=72, *, metadata=None):
        self.width = width
        self.height = height
        self.writer = XMLWriter(svgwriter)
        self.image_dpi = image_dpi
        if basename is None:
            basename = getattr(svgwriter, 'name', '')
            if not isinstance(basename, str):
                basename = ''
        self.basename = basename
        self._groupd = {}
        self._image_counter = itertools.count()
        self._clip_path_ids = {}
        self._clipd = {}
        self._markers = {}
        self._path_collection_id = 0
        self._hatchd = {}
        self._has_gouraud = False
        self._n_gradients = 0
        super().__init__()
        self._glyph_map = dict()
        str_height = _short_float_fmt(height)
        str_width = _short_float_fmt(width)
        svgwriter.write(svgProlog)
        self._start_id = self.writer.start('svg', width=f'{str_width}pt', height=f'{str_height}pt', viewBox=f'0 0 {str_width} {str_height}', xmlns='http://www.w3.org/2000/svg', version='1.1', id=mpl.rcParams['svg.id'], attrib={'xmlns:xlink': 'http://www.w3.org/1999/xlink'})
        self._write_metadata(metadata)
        self._write_default_style()

    def _get_clippath_id(self, clippath):
        if clippath not in self._clip_path_ids:
            self._clip_path_ids[clippath] = len(self._clip_path_ids)
        return self._clip_path_ids[clippath]

    def finalize(self):
        self._write_clips()
        self._write_hatches()
        self.writer.close(self._start_id)
        self.writer.flush()

    def _write_metadata(self, metadata):
        if metadata is None:
            metadata = {}
        metadata = {'Format': 'image/svg+xml', 'Type': 'http://purl.org/dc/dcmitype/StillImage', 'Creator': f'Matplotlib v{mpl.__version__}, https://matplotlib.org/', **metadata}
        writer = self.writer
        if 'Title' in metadata:
            title = metadata['Title']
            _check_is_str(title, 'Title')
            writer.element('title', text=title)
        date = metadata.get('Date', None)
        if date is not None:
            if isinstance(date, str):
                dates = [date]
            elif isinstance(date, (datetime.datetime, datetime.date)):
                dates = [date.isoformat()]
            elif np.iterable(date):
                dates = []
                for d in date:
                    if isinstance(d, str):
                        dates.append(d)
                    elif isinstance(d, (datetime.datetime, datetime.date)):
                        dates.append(d.isoformat())
                    else:
                        raise TypeError(f'Invalid type for Date metadata. Expected iterable of str, date, or datetime, not {type(d)}.')
            else:
                raise TypeError(f'Invalid type for Date metadata. Expected str, date, datetime, or iterable of the same, not {type(date)}.')
            metadata['Date'] = '/'.join(dates)
        elif 'Date' not in metadata:
            date = os.getenv('SOURCE_DATE_EPOCH')
            if date:
                date = datetime.datetime.fromtimestamp(int(date), datetime.timezone.utc)
                metadata['Date'] = date.replace(tzinfo=UTC).isoformat()
            else:
                metadata['Date'] = datetime.datetime.today().isoformat()
        mid = None

        def ensure_metadata(mid):
            if mid is not None:
                return mid
            mid = writer.start('metadata')
            writer.start('rdf:RDF', attrib={'xmlns:dc': 'http://purl.org/dc/elements/1.1/', 'xmlns:cc': 'http://creativecommons.org/ns#', 'xmlns:rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'})
            writer.start('cc:Work')
            return mid
        uri = metadata.pop('Type', None)
        if uri is not None:
            mid = ensure_metadata(mid)
            writer.element('dc:type', attrib={'rdf:resource': uri})
        for key in ['Title', 'Coverage', 'Date', 'Description', 'Format', 'Identifier', 'Language', 'Relation', 'Source']:
            info = metadata.pop(key, None)
            if info is not None:
                mid = ensure_metadata(mid)
                _check_is_str(info, key)
                writer.element(f'dc:{key.lower()}', text=info)
        for key in ['Creator', 'Contributor', 'Publisher', 'Rights']:
            agents = metadata.pop(key, None)
            if agents is None:
                continue
            if isinstance(agents, str):
                agents = [agents]
            _check_is_iterable_of_str(agents, key)
            mid = ensure_metadata(mid)
            writer.start(f'dc:{key.lower()}')
            for agent in agents:
                writer.start('cc:Agent')
                writer.element('dc:title', text=agent)
                writer.end('cc:Agent')
            writer.end(f'dc:{key.lower()}')
        keywords = metadata.pop('Keywords', None)
        if keywords is not None:
            if isinstance(keywords, str):
                keywords = [keywords]
            _check_is_iterable_of_str(keywords, 'Keywords')
            mid = ensure_metadata(mid)
            writer.start('dc:subject')
            writer.start('rdf:Bag')
            for keyword in keywords:
                writer.element('rdf:li', text=keyword)
            writer.end('rdf:Bag')
            writer.end('dc:subject')
        if mid is not None:
            writer.close(mid)
        if metadata:
            raise ValueError('Unknown metadata key(s) passed to SVG writer: ' + ','.join(metadata))

    def _write_default_style(self):
        writer = self.writer
        default_style = _generate_css({'stroke-linejoin': 'round', 'stroke-linecap': 'butt'})
        writer.start('defs')
        writer.element('style', type='text/css', text='*{%s}' % default_style)
        writer.end('defs')

    def _make_id(self, type, content):
        salt = mpl.rcParams['svg.hashsalt']
        if salt is None:
            salt = str(uuid.uuid4())
        m = hashlib.sha256()
        m.update(salt.encode('utf8'))
        m.update(str(content).encode('utf8'))
        return f'{type}{m.hexdigest()[:10]}'

    def _make_flip_transform(self, transform):
        return transform + Affine2D().scale(1, -1).translate(0, self.height)

    def _get_hatch(self, gc, rgbFace):
        if rgbFace is not None:
            rgbFace = tuple(rgbFace)
        edge = gc.get_hatch_color()
        if edge is not None:
            edge = tuple(edge)
        dictkey = (gc.get_hatch(), rgbFace, edge)
        oid = self._hatchd.get(dictkey)
        if oid is None:
            oid = self._make_id('h', dictkey)
            self._hatchd[dictkey] = ((gc.get_hatch_path(), rgbFace, edge), oid)
        else:
            (_, oid) = oid
        return oid

    def _write_hatches(self):
        if not len(self._hatchd):
            return
        HATCH_SIZE = 72
        writer = self.writer
        writer.start('defs')
        for ((path, face, stroke), oid) in self._hatchd.values():
            writer.start('pattern', id=oid, patternUnits='userSpaceOnUse', x='0', y='0', width=str(HATCH_SIZE), height=str(HATCH_SIZE))
            path_data = self._convert_path(path, Affine2D().scale(HATCH_SIZE).scale(1.0, -1.0).translate(0, HATCH_SIZE), simplify=False)
            if face is None:
                fill = 'none'
            else:
                fill = rgb2hex(face)
            writer.element('rect', x='0', y='0', width=str(HATCH_SIZE + 1), height=str(HATCH_SIZE + 1), fill=fill)
            hatch_style = {'fill': rgb2hex(stroke), 'stroke': rgb2hex(stroke), 'stroke-width': str(mpl.rcParams['hatch.linewidth']), 'stroke-linecap': 'butt', 'stroke-linejoin': 'miter'}
            if stroke[3] < 1:
                hatch_style['stroke-opacity'] = str(stroke[3])
            writer.element('path', d=path_data, style=_generate_css(hatch_style))
            writer.end('pattern')
        writer.end('defs')

    def _get_style_dict(self, gc, rgbFace):
        attrib = {}
        forced_alpha = gc.get_forced_alpha()
        if gc.get_hatch() is not None:
            attrib['fill'] = f'url(#{self._get_hatch(gc, rgbFace)})'
            if rgbFace is not None and len(rgbFace) == 4 and (rgbFace[3] != 1.0) and (not forced_alpha):
                attrib['fill-opacity'] = _short_float_fmt(rgbFace[3])
        elif rgbFace is None:
            attrib['fill'] = 'none'
        else:
            if tuple(rgbFace[:3]) != (0, 0, 0):
                attrib['fill'] = rgb2hex(rgbFace)
            if len(rgbFace) == 4 and rgbFace[3] != 1.0 and (not forced_alpha):
                attrib['fill-opacity'] = _short_float_fmt(rgbFace[3])
        if forced_alpha and gc.get_alpha() != 1.0:
            attrib['opacity'] = _short_float_fmt(gc.get_alpha())
        (offset, seq) = gc.get_dashes()
        if seq is not None:
            attrib['stroke-dasharray'] = ','.join((_short_float_fmt(val) for val in seq))
            attrib['stroke-dashoffset'] = _short_float_fmt(float(offset))
        linewidth = gc.get_linewidth()
        if linewidth:
            rgb = gc.get_rgb()
            attrib['stroke'] = rgb2hex(rgb)
            if not forced_alpha and rgb[3] != 1.0:
                attrib['stroke-opacity'] = _short_float_fmt(rgb[3])
            if linewidth != 1.0:
                attrib['stroke-width'] = _short_float_fmt(linewidth)
            if gc.get_joinstyle() != 'round':
                attrib['stroke-linejoin'] = gc.get_joinstyle()
            if gc.get_capstyle() != 'butt':
                attrib['stroke-linecap'] = _capstyle_d[gc.get_capstyle()]
        return attrib

    def _get_style(self, gc, rgbFace):
        return _generate_css(self._get_style_dict(gc, rgbFace))

    def _get_clip_attrs(self, gc):
        cliprect = gc.get_clip_rectangle()
        (clippath, clippath_trans) = gc.get_clip_path()
        if clippath is not None:
            clippath_trans = self._make_flip_transform(clippath_trans)
            dictkey = (self._get_clippath_id(clippath), str(clippath_trans))
        elif cliprect is not None:
            (x, y, w, h) = cliprect.bounds
            y = self.height - (y + h)
            dictkey = (x, y, w, h)
        else:
            return {}
        clip = self._clipd.get(dictkey)
        if clip is None:
            oid = self._make_id('p', dictkey)
            if clippath is not None:
                self._clipd[dictkey] = ((clippath, clippath_trans), oid)
            else:
                self._clipd[dictkey] = (dictkey, oid)
        else:
            (_, oid) = clip
        return {'clip-path': f'url(#{oid})'}

    def _write_clips(self):
        if not len(self._clipd):
            return
        writer = self.writer
        writer.start('defs')
        for (clip, oid) in self._clipd.values():
            writer.start('clipPath', id=oid)
            if len(clip) == 2:
                (clippath, clippath_trans) = clip
                path_data = self._convert_path(clippath, clippath_trans, simplify=False)
                writer.element('path', d=path_data)
            else:
                (x, y, w, h) = clip
                writer.element('rect', x=_short_float_fmt(x), y=_short_float_fmt(y), width=_short_float_fmt(w), height=_short_float_fmt(h))
            writer.end('clipPath')
        writer.end('defs')

    def open_group(self, s, gid=None):
        if gid:
            self.writer.start('g', id=gid)
        else:
            self._groupd[s] = self._groupd.get(s, 0) + 1
            self.writer.start('g', id=f'{s}_{self._groupd[s]:d}')

    def close_group(self, s):
        self.writer.end('g')

    def option_image_nocomposite(self):
        return not mpl.rcParams['image.composite_image']

    def _convert_path(self, path, transform=None, clip=None, simplify=None, sketch=None):
        if clip:
            clip = (0.0, 0.0, self.width, self.height)
        else:
            clip = None
        return _path.convert_to_string(path, transform, clip, simplify, sketch, 6, [b'M', b'L', b'Q', b'C', b'z'], False).decode('ascii')

    def draw_path(self, gc, path, transform, rgbFace=None):
        trans_and_flip = self._make_flip_transform(transform)
        clip = rgbFace is None and gc.get_hatch_path() is None
        simplify = path.should_simplify and clip
        path_data = self._convert_path(path, trans_and_flip, clip=clip, simplify=simplify, sketch=gc.get_sketch_params())
        if gc.get_url() is not None:
            self.writer.start('a', {'xlink:href': gc.get_url()})
        self.writer.element('path', d=path_data, **self._get_clip_attrs(gc), style=self._get_style(gc, rgbFace))
        if gc.get_url() is not None:
            self.writer.end('a')

    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
        if not len(path.vertices):
            return
        writer = self.writer
        path_data = self._convert_path(marker_path, marker_trans + Affine2D().scale(1.0, -1.0), simplify=False)
        style = self._get_style_dict(gc, rgbFace)
        dictkey = (path_data, _generate_css(style))
        oid = self._markers.get(dictkey)
        style = _generate_css({k: v for (k, v) in style.items() if k.startswith('stroke')})
        if oid is None:
            oid = self._make_id('m', dictkey)
            writer.start('defs')
            writer.element('path', id=oid, d=path_data, style=style)
            writer.end('defs')
            self._markers[dictkey] = oid
        writer.start('g', **self._get_clip_attrs(gc))
        if gc.get_url() is not None:
            self.writer.start('a', {'xlink:href': gc.get_url()})
        trans_and_flip = self._make_flip_transform(trans)
        attrib = {'xlink:href': f'#{oid}'}
        clip = (0, 0, self.width * 72, self.height * 72)
        for (vertices, code) in path.iter_segments(trans_and_flip, clip=clip, simplify=False):
            if len(vertices):
                (x, y) = vertices[-2:]
                attrib['x'] = _short_float_fmt(x)
                attrib['y'] = _short_float_fmt(y)
                attrib['style'] = self._get_style(gc, rgbFace)
                writer.element('use', attrib=attrib)
        if gc.get_url() is not None:
            self.writer.end('a')
        writer.end('g')

    def draw_path_collection(self, gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
        len_path = len(paths[0].vertices) if len(paths) > 0 else 0
        uses_per_path = self._iter_collection_uses_per_path(paths, all_transforms, offsets, facecolors, edgecolors)
        should_do_optimization = len_path + 9 * uses_per_path + 3 < (len_path + 5) * uses_per_path
        if not should_do_optimization:
            return super().draw_path_collection(gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position)
        writer = self.writer
        path_codes = []
        writer.start('defs')
        for (i, (path, transform)) in enumerate(self._iter_collection_raw_paths(master_transform, paths, all_transforms)):
            transform = Affine2D(transform.get_matrix()).scale(1.0, -1.0)
            d = self._convert_path(path, transform, simplify=False)
            oid = 'C{:x}_{:x}_{}'.format(self._path_collection_id, i, self._make_id('', d))
            writer.element('path', id=oid, d=d)
            path_codes.append(oid)
        writer.end('defs')
        for (xo, yo, path_id, gc0, rgbFace) in self._iter_collection(gc, path_codes, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position):
            url = gc0.get_url()
            if url is not None:
                writer.start('a', attrib={'xlink:href': url})
            clip_attrs = self._get_clip_attrs(gc0)
            if clip_attrs:
                writer.start('g', **clip_attrs)
            attrib = {'xlink:href': f'#{path_id}', 'x': _short_float_fmt(xo), 'y': _short_float_fmt(self.height - yo), 'style': self._get_style(gc0, rgbFace)}
            writer.element('use', attrib=attrib)
            if clip_attrs:
                writer.end('g')
            if url is not None:
                writer.end('a')
        self._path_collection_id += 1

    def _draw_gouraud_triangle(self, transformed_points, colors):
        avg_color = np.average(colors, axis=0)
        if avg_color[-1] == 0:
            return
        writer = self.writer
        writer.start('defs')
        for i in range(3):
            (x1, y1) = transformed_points[i]
            (x2, y2) = transformed_points[(i + 1) % 3]
            (x3, y3) = transformed_points[(i + 2) % 3]
            rgba_color = colors[i]
            if x2 == x3:
                xb = x2
                yb = y1
            elif y2 == y3:
                xb = x1
                yb = y2
            else:
                m1 = (y2 - y3) / (x2 - x3)
                b1 = y2 - m1 * x2
                m2 = -(1.0 / m1)
                b2 = y1 - m2 * x1
                xb = (-b1 + b2) / (m1 - m2)
                yb = m2 * xb + b2
            writer.start('linearGradient', id=f'GR{self._n_gradients:x}_{i:d}', gradientUnits='userSpaceOnUse', x1=_short_float_fmt(x1), y1=_short_float_fmt(y1), x2=_short_float_fmt(xb), y2=_short_float_fmt(yb))
            writer.element('stop', offset='1', style=_generate_css({'stop-color': rgb2hex(avg_color), 'stop-opacity': _short_float_fmt(rgba_color[-1])}))
            writer.element('stop', offset='0', style=_generate_css({'stop-color': rgb2hex(rgba_color), 'stop-opacity': '0'}))
            writer.end('linearGradient')
        writer.end('defs')
        dpath = f'M {_short_float_fmt(x1)},{_short_float_fmt(y1)} L {_short_float_fmt(x2)},{_short_float_fmt(y2)} {_short_float_fmt(x3)},{_short_float_fmt(y3)} Z'
        writer.element('path', attrib={'d': dpath, 'fill': rgb2hex(avg_color), 'fill-opacity': '1', 'shape-rendering': 'crispEdges'})
        writer.start('g', attrib={'stroke': 'none', 'stroke-width': '0', 'shape-rendering': 'crispEdges', 'filter': 'url(#colorMat)'})
        writer.element('path', attrib={'d': dpath, 'fill': f'url(#GR{self._n_gradients:x}_0)', 'shape-rendering': 'crispEdges'})
        writer.element('path', attrib={'d': dpath, 'fill': f'url(#GR{self._n_gradients:x}_1)', 'filter': 'url(#colorAdd)', 'shape-rendering': 'crispEdges'})
        writer.element('path', attrib={'d': dpath, 'fill': f'url(#GR{self._n_gradients:x}_2)', 'filter': 'url(#colorAdd)', 'shape-rendering': 'crispEdges'})
        writer.end('g')
        self._n_gradients += 1

    def draw_gouraud_triangles(self, gc, triangles_array, colors_array, transform):
        writer = self.writer
        writer.start('g', **self._get_clip_attrs(gc))
        transform = transform.frozen()
        trans_and_flip = self._make_flip_transform(transform)
        if not self._has_gouraud:
            self._has_gouraud = True
            writer.start('filter', id='colorAdd')
            writer.element('feComposite', attrib={'in': 'SourceGraphic'}, in2='BackgroundImage', operator='arithmetic', k2='1', k3='1')
            writer.end('filter')
            writer.start('filter', id='colorMat')
            writer.element('feColorMatrix', attrib={'type': 'matrix'}, values='1 0 0 0 0 \n0 1 0 0 0 \n0 0 1 0 0 \n1 1 1 1 0 \n0 0 0 0 1 ')
            writer.end('filter')
        for (points, colors) in zip(triangles_array, colors_array):
            self._draw_gouraud_triangle(trans_and_flip.transform(points), colors)
        writer.end('g')

    def option_scale_image(self):
        return True

    def get_image_magnification(self):
        return self.image_dpi / 72.0

    def draw_image(self, gc, x, y, im, transform=None):
        (h, w) = im.shape[:2]
        if w == 0 or h == 0:
            return
        clip_attrs = self._get_clip_attrs(gc)
        if clip_attrs:
            self.writer.start('g', **clip_attrs)
        url = gc.get_url()
        if url is not None:
            self.writer.start('a', attrib={'xlink:href': url})
        attrib = {}
        oid = gc.get_gid()
        if mpl.rcParams['svg.image_inline']:
            buf = BytesIO()
            Image.fromarray(im).save(buf, format='png')
            oid = oid or self._make_id('image', buf.getvalue())
            attrib['xlink:href'] = 'data:image/png;base64,\n' + base64.b64encode(buf.getvalue()).decode('ascii')
        else:
            if self.basename is None:
                raise ValueError('Cannot save image data to filesystem when writing SVG to an in-memory buffer')
            filename = f'{self.basename}.image{next(self._image_counter)}.png'
            _log.info('Writing image file for inclusion: %s', filename)
            Image.fromarray(im).save(filename)
            oid = oid or 'Im_' + self._make_id('image', filename)
            attrib['xlink:href'] = filename
        attrib['id'] = oid
        if transform is None:
            w = 72.0 * w / self.image_dpi
            h = 72.0 * h / self.image_dpi
            self.writer.element('image', transform=_generate_transform([('scale', (1, -1)), ('translate', (0, -h))]), x=_short_float_fmt(x), y=_short_float_fmt(-(self.height - y - h)), width=_short_float_fmt(w), height=_short_float_fmt(h), attrib=attrib)
        else:
            alpha = gc.get_alpha()
            if alpha != 1.0:
                attrib['opacity'] = _short_float_fmt(alpha)
            flipped = Affine2D().scale(1.0 / w, 1.0 / h) + transform + Affine2D().translate(x, y).scale(1.0, -1.0).translate(0.0, self.height)
            attrib['transform'] = _generate_transform([('matrix', flipped.frozen())])
            attrib['style'] = 'image-rendering:crisp-edges;image-rendering:pixelated'
            self.writer.element('image', width=_short_float_fmt(w), height=_short_float_fmt(h), attrib=attrib)
        if url is not None:
            self.writer.end('a')
        if clip_attrs:
            self.writer.end('g')

    def _update_glyph_map_defs(self, glyph_map_new):
        writer = self.writer
        if glyph_map_new:
            writer.start('defs')
            for (char_id, (vertices, codes)) in glyph_map_new.items():
                char_id = self._adjust_char_id(char_id)
                path_data = self._convert_path(Path(vertices * 64, codes), simplify=False)
                writer.element('path', id=char_id, d=path_data, transform=_generate_transform([('scale', (1 / 64,))]))
            writer.end('defs')
            self._glyph_map.update(glyph_map_new)

    def _adjust_char_id(self, char_id):
        return char_id.replace('%20', '_')

    def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath, mtext=None):
        writer = self.writer
        writer.comment(s)
        glyph_map = self._glyph_map
        text2path = self._text2path
        color = rgb2hex(gc.get_rgb())
        fontsize = prop.get_size_in_points()
        style = {}
        if color != '#000000':
            style['fill'] = color
        alpha = gc.get_alpha() if gc.get_forced_alpha() else gc.get_rgb()[3]
        if alpha != 1:
            style['opacity'] = _short_float_fmt(alpha)
        font_scale = fontsize / text2path.FONT_SCALE
        attrib = {'style': _generate_css(style), 'transform': _generate_transform([('translate', (x, y)), ('rotate', (-angle,)), ('scale', (font_scale, -font_scale))])}
        writer.start('g', attrib=attrib)
        if not ismath:
            font = text2path._get_font(prop)
            _glyphs = text2path.get_glyphs_with_font(font, s, glyph_map=glyph_map, return_new_glyphs_only=True)
            (glyph_info, glyph_map_new, rects) = _glyphs
            self._update_glyph_map_defs(glyph_map_new)
            for (glyph_id, xposition, yposition, scale) in glyph_info:
                writer.element('use', transform=_generate_transform([('translate', (xposition, yposition)), ('scale', (scale,))]), attrib={'xlink:href': f'#{glyph_id}'})
        else:
            if ismath == 'TeX':
                _glyphs = text2path.get_glyphs_tex(prop, s, glyph_map=glyph_map, return_new_glyphs_only=True)
            else:
                _glyphs = text2path.get_glyphs_mathtext(prop, s, glyph_map=glyph_map, return_new_glyphs_only=True)
            (glyph_info, glyph_map_new, rects) = _glyphs
            self._update_glyph_map_defs(glyph_map_new)
            for (char_id, xposition, yposition, scale) in glyph_info:
                char_id = self._adjust_char_id(char_id)
                writer.element('use', transform=_generate_transform([('translate', (xposition, yposition)), ('scale', (scale,))]), attrib={'xlink:href': f'#{char_id}'})
            for (verts, codes) in rects:
                path = Path(verts, codes)
                path_data = self._convert_path(path, simplify=False)
                writer.element('path', d=path_data)
        writer.end('g')

    def _draw_text_as_text(self, gc, x, y, s, prop, angle, ismath, mtext=None):
        writer = self.writer
        color = rgb2hex(gc.get_rgb())
        font_style = {}
        color_style = {}
        if color != '#000000':
            color_style['fill'] = color
        alpha = gc.get_alpha() if gc.get_forced_alpha() else gc.get_rgb()[3]
        if alpha != 1:
            color_style['opacity'] = _short_float_fmt(alpha)
        if not ismath:
            attrib = {}
            if prop.get_style() != 'normal':
                font_style['font-style'] = prop.get_style()
            if prop.get_variant() != 'normal':
                font_style['font-variant'] = prop.get_variant()
            weight = fm.weight_dict[prop.get_weight()]
            if weight != 400:
                font_style['font-weight'] = f'{weight}'

            def _normalize_sans(name):
                return 'sans-serif' if name in ['sans', 'sans serif'] else name

            def _expand_family_entry(fn):
                fn = _normalize_sans(fn)
                if fn in fm.font_family_aliases:
                    for name in fm.FontManager._expand_aliases(fn):
                        yield _normalize_sans(name)
                yield fn

            def _get_all_quoted_names(prop):
                return [name if name in fm.font_family_aliases else repr(name) for entry in prop.get_family() for name in _expand_family_entry(entry)]
            font_style['font-size'] = f'{_short_float_fmt(prop.get_size())}px'
            font_style['font-family'] = ', '.join(dict.fromkeys(_get_all_quoted_names(prop)))
            if prop.get_stretch() != 'normal':
                font_style['font-stretch'] = prop.get_stretch()
            attrib['style'] = _generate_css({**font_style, **color_style})
            if mtext and (angle == 0 or mtext.get_rotation_mode() == 'anchor'):
                transform = mtext.get_transform()
                (ax, ay) = transform.transform(mtext.get_unitless_position())
                ay = self.height - ay
                angle_rad = np.deg2rad(angle)
                dir_vert = np.array([np.sin(angle_rad), np.cos(angle_rad)])
                v_offset = np.dot(dir_vert, [x - ax, y - ay])
                ax = ax + v_offset * dir_vert[0]
                ay = ay + v_offset * dir_vert[1]
                ha_mpl_to_svg = {'left': 'start', 'right': 'end', 'center': 'middle'}
                font_style['text-anchor'] = ha_mpl_to_svg[mtext.get_ha()]
                attrib['x'] = _short_float_fmt(ax)
                attrib['y'] = _short_float_fmt(ay)
                attrib['style'] = _generate_css({**font_style, **color_style})
                attrib['transform'] = _generate_transform([('rotate', (-angle, ax, ay))])
            else:
                attrib['transform'] = _generate_transform([('translate', (x, y)), ('rotate', (-angle,))])
            writer.element('text', s, attrib=attrib)
        else:
            writer.comment(s)
            (width, height, descent, glyphs, rects) = self._text2path.mathtext_parser.parse(s, 72, prop)
            writer.start('g', style=_generate_css({**font_style, **color_style}), transform=_generate_transform([('translate', (x, y)), ('rotate', (-angle,))]))
            writer.start('text')
            spans = {}
            for (font, fontsize, thetext, new_x, new_y) in glyphs:
                entry = fm.ttfFontProperty(font)
                font_style = {}
                if entry.style != 'normal':
                    font_style['font-style'] = entry.style
                if entry.variant != 'normal':
                    font_style['font-variant'] = entry.variant
                if entry.weight != 400:
                    font_style['font-weight'] = f'{entry.weight}'
                font_style['font-size'] = f'{_short_float_fmt(fontsize)}px'
                font_style['font-family'] = f'{entry.name!r}'
                if entry.stretch != 'normal':
                    font_style['font-stretch'] = entry.stretch
                style = _generate_css({**font_style, **color_style})
                if thetext == 32:
                    thetext = 160
                spans.setdefault(style, []).append((new_x, -new_y, thetext))
            for (style, chars) in spans.items():
                chars.sort()
                for (x, y, t) in chars:
                    writer.element('tspan', chr(t), x=_short_float_fmt(x), y=_short_float_fmt(y), style=style)
            writer.end('text')
            for (x, y, width, height) in rects:
                writer.element('rect', x=_short_float_fmt(x), y=_short_float_fmt(-y - 1), width=_short_float_fmt(width), height=_short_float_fmt(height))
            writer.end('g')

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        clip_attrs = self._get_clip_attrs(gc)
        if clip_attrs:
            self.writer.start('g', **clip_attrs)
        if gc.get_url() is not None:
            self.writer.start('a', {'xlink:href': gc.get_url()})
        if mpl.rcParams['svg.fonttype'] == 'path':
            self._draw_text_as_path(gc, x, y, s, prop, angle, ismath, mtext)
        else:
            self._draw_text_as_text(gc, x, y, s, prop, angle, ismath, mtext)
        if gc.get_url() is not None:
            self.writer.end('a')
        if clip_attrs:
            self.writer.end('g')

    def flipy(self):
        return True

    def get_canvas_width_height(self):
        return (self.width, self.height)

    def get_text_width_height_descent(self, s, prop, ismath):
        return self._text2path.get_text_width_height_descent(s, prop, ismath)

class FigureCanvasSVG(FigureCanvasBase):
    filetypes = {'svg': 'Scalable Vector Graphics', 'svgz': 'Scalable Vector Graphics'}
    fixed_dpi = 72

    def print_svg(self, filename, *, bbox_inches_restore=None, metadata=None):
        with cbook.open_file_cm(filename, 'w', encoding='utf-8') as fh:
            if not cbook.file_requires_unicode(fh):
                fh = codecs.getwriter('utf-8')(fh)
            dpi = self.figure.dpi
            self.figure.dpi = 72
            (width, height) = self.figure.get_size_inches()
            (w, h) = (width * 72, height * 72)
            renderer = MixedModeRenderer(self.figure, width, height, dpi, RendererSVG(w, h, fh, image_dpi=dpi, metadata=metadata), bbox_inches_restore=bbox_inches_restore)
            self.figure.draw(renderer)
            renderer.finalize()

    def print_svgz(self, filename, **kwargs):
        with cbook.open_file_cm(filename, 'wb') as fh, gzip.GzipFile(mode='w', fileobj=fh) as gzipwriter:
            return self.print_svg(gzipwriter, **kwargs)

    def get_default_filetype(self):
        return 'svg'

    def draw(self):
        self.figure.draw_without_rendering()
        return super().draw()
FigureManagerSVG = FigureManagerBase
svgProlog = '<?xml version="1.0" encoding="utf-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"\n  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n'

@_Backend.export
class _BackendSVG(_Backend):
    backend_version = mpl.__version__
    FigureCanvas = FigureCanvasSVG

# File: matplotlib-main/lib/matplotlib/backends/backend_template.py
""""""
from matplotlib import _api
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import FigureCanvasBase, FigureManagerBase, GraphicsContextBase, RendererBase
from matplotlib.figure import Figure

class RendererTemplate(RendererBase):

    def __init__(self, dpi):
        super().__init__()
        self.dpi = dpi

    def draw_path(self, gc, path, transform, rgbFace=None):
        pass

    def draw_image(self, gc, x, y, im):
        pass

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        pass

    def flipy(self):
        return True

    def get_canvas_width_height(self):
        return (100, 100)

    def get_text_width_height_descent(self, s, prop, ismath):
        return (1, 1, 1)

    def new_gc(self):
        return GraphicsContextTemplate()

    def points_to_pixels(self, points):
        return points

class GraphicsContextTemplate(GraphicsContextBase):

class FigureManagerTemplate(FigureManagerBase):

class FigureCanvasTemplate(FigureCanvasBase):
    manager_class = FigureManagerTemplate

    def draw(self):
        renderer = RendererTemplate(self.figure.dpi)
        self.figure.draw(renderer)
    filetypes = {**FigureCanvasBase.filetypes, 'foo': 'My magic Foo format'}

    def print_foo(self, filename, **kwargs):
        self.draw()

    def get_default_filetype(self):
        return 'foo'
FigureCanvas = FigureCanvasTemplate
FigureManager = FigureManagerTemplate

# File: matplotlib-main/lib/matplotlib/backends/backend_tkagg.py
from . import _backend_tk
from .backend_agg import FigureCanvasAgg
from ._backend_tk import _BackendTk, FigureCanvasTk
from ._backend_tk import FigureManagerTk, NavigationToolbar2Tk

class FigureCanvasTkAgg(FigureCanvasAgg, FigureCanvasTk):

    def draw(self):
        super().draw()
        self.blit()

    def blit(self, bbox=None):
        _backend_tk.blit(self._tkphoto, self.renderer.buffer_rgba(), (0, 1, 2, 3), bbox=bbox)

@_BackendTk.export
class _BackendTkAgg(_BackendTk):
    FigureCanvas = FigureCanvasTkAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_tkcairo.py
import sys
import numpy as np
from . import _backend_tk
from .backend_cairo import cairo, FigureCanvasCairo
from ._backend_tk import _BackendTk, FigureCanvasTk

class FigureCanvasTkCairo(FigureCanvasCairo, FigureCanvasTk):

    def draw(self):
        width = int(self.figure.bbox.width)
        height = int(self.figure.bbox.height)
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
        self._renderer.set_context(cairo.Context(surface))
        self._renderer.dpi = self.figure.dpi
        self.figure.draw(self._renderer)
        buf = np.reshape(surface.get_data(), (height, width, 4))
        _backend_tk.blit(self._tkphoto, buf, (2, 1, 0, 3) if sys.byteorder == 'little' else (1, 2, 3, 0))

@_BackendTk.export
class _BackendTkCairo(_BackendTk):
    FigureCanvas = FigureCanvasTkCairo

# File: matplotlib-main/lib/matplotlib/backends/backend_webagg.py
""""""
from contextlib import contextmanager
import errno
from io import BytesIO
import json
import mimetypes
from pathlib import Path
import random
import sys
import signal
import threading
try:
    import tornado
except ImportError as err:
    raise RuntimeError('The WebAgg backend requires Tornado.') from err
import tornado.web
import tornado.ioloop
import tornado.websocket
import matplotlib as mpl
from matplotlib.backend_bases import _Backend
from matplotlib._pylab_helpers import Gcf
from . import backend_webagg_core as core
from .backend_webagg_core import TimerAsyncio, TimerTornado
webagg_server_thread = threading.Thread(target=lambda : tornado.ioloop.IOLoop.instance().start())

class FigureManagerWebAgg(core.FigureManagerWebAgg):
    _toolbar2_class = core.NavigationToolbar2WebAgg

    @classmethod
    def pyplot_show(cls, *, block=None):
        WebAggApplication.initialize()
        url = 'http://{address}:{port}{prefix}'.format(address=WebAggApplication.address, port=WebAggApplication.port, prefix=WebAggApplication.url_prefix)
        if mpl.rcParams['webagg.open_in_browser']:
            import webbrowser
            if not webbrowser.open(url):
                print(f'To view figure, visit {url}')
        else:
            print(f'To view figure, visit {url}')
        WebAggApplication.start()

class FigureCanvasWebAgg(core.FigureCanvasWebAggCore):
    manager_class = FigureManagerWebAgg

class WebAggApplication(tornado.web.Application):
    initialized = False
    started = False

    class FavIcon(tornado.web.RequestHandler):

        def get(self):
            self.set_header('Content-Type', 'image/png')
            self.write(Path(mpl.get_data_path(), 'images/matplotlib.png').read_bytes())

    class SingleFigurePage(tornado.web.RequestHandler):

        def __init__(self, application, request, *, url_prefix='', **kwargs):
            self.url_prefix = url_prefix
            super().__init__(application, request, **kwargs)

        def get(self, fignum):
            fignum = int(fignum)
            manager = Gcf.get_fig_manager(fignum)
            ws_uri = f'ws://{self.request.host}{self.url_prefix}/'
            self.render('single_figure.html', prefix=self.url_prefix, ws_uri=ws_uri, fig_id=fignum, toolitems=core.NavigationToolbar2WebAgg.toolitems, canvas=manager.canvas)

    class AllFiguresPage(tornado.web.RequestHandler):

        def __init__(self, application, request, *, url_prefix='', **kwargs):
            self.url_prefix = url_prefix
            super().__init__(application, request, **kwargs)

        def get(self):
            ws_uri = f'ws://{self.request.host}{self.url_prefix}/'
            self.render('all_figures.html', prefix=self.url_prefix, ws_uri=ws_uri, figures=sorted(Gcf.figs.items()), toolitems=core.NavigationToolbar2WebAgg.toolitems)

    class MplJs(tornado.web.RequestHandler):

        def get(self):
            self.set_header('Content-Type', 'application/javascript')
            js_content = core.FigureManagerWebAgg.get_javascript()
            self.write(js_content)

    class Download(tornado.web.RequestHandler):

        def get(self, fignum, fmt):
            fignum = int(fignum)
            manager = Gcf.get_fig_manager(fignum)
            self.set_header('Content-Type', mimetypes.types_map.get(fmt, 'binary'))
            buff = BytesIO()
            manager.canvas.figure.savefig(buff, format=fmt)
            self.write(buff.getvalue())

    class WebSocket(tornado.websocket.WebSocketHandler):
        supports_binary = True

        def open(self, fignum):
            self.fignum = int(fignum)
            self.manager = Gcf.get_fig_manager(self.fignum)
            self.manager.add_web_socket(self)
            if hasattr(self, 'set_nodelay'):
                self.set_nodelay(True)

        def on_close(self):
            self.manager.remove_web_socket(self)

        def on_message(self, message):
            message = json.loads(message)
            if message['type'] == 'supports_binary':
                self.supports_binary = message['value']
            else:
                manager = Gcf.get_fig_manager(self.fignum)
                if manager is not None:
                    manager.handle_json(message)

        def send_json(self, content):
            self.write_message(json.dumps(content))

        def send_binary(self, blob):
            if self.supports_binary:
                self.write_message(blob, binary=True)
            else:
                data_uri = 'data:image/png;base64,{}'.format(blob.encode('base64').replace('\n', ''))
                self.write_message(data_uri)

    def __init__(self, url_prefix=''):
        if url_prefix:
            assert url_prefix[0] == '/' and url_prefix[-1] != '/', 'url_prefix must start with a "/" and not end with one.'
        super().__init__([(url_prefix + '/_static/(.*)', tornado.web.StaticFileHandler, {'path': core.FigureManagerWebAgg.get_static_file_path()}), (url_prefix + '/_images/(.*)', tornado.web.StaticFileHandler, {'path': Path(mpl.get_data_path(), 'images')}), (url_prefix + '/favicon.ico', self.FavIcon), (url_prefix + '/([0-9]+)', self.SingleFigurePage, {'url_prefix': url_prefix}), (url_prefix + '/?', self.AllFiguresPage, {'url_prefix': url_prefix}), (url_prefix + '/js/mpl.js', self.MplJs), (url_prefix + '/([0-9]+)/ws', self.WebSocket), (url_prefix + '/([0-9]+)/download.([a-z0-9.]+)', self.Download)], template_path=core.FigureManagerWebAgg.get_static_file_path())

    @classmethod
    def initialize(cls, url_prefix='', port=None, address=None):
        if cls.initialized:
            return
        app = cls(url_prefix=url_prefix)
        cls.url_prefix = url_prefix

        def random_ports(port, n):
            for i in range(min(5, n)):
                yield (port + i)
            for i in range(n - 5):
                yield (port + random.randint(-2 * n, 2 * n))
        if address is None:
            cls.address = mpl.rcParams['webagg.address']
        else:
            cls.address = address
        cls.port = mpl.rcParams['webagg.port']
        for port in random_ports(cls.port, mpl.rcParams['webagg.port_retries']):
            try:
                app.listen(port, cls.address)
            except OSError as e:
                if e.errno != errno.EADDRINUSE:
                    raise
            else:
                cls.port = port
                break
        else:
            raise SystemExit('The webagg server could not be started because an available port could not be found')
        cls.initialized = True

    @classmethod
    def start(cls):
        import asyncio
        try:
            asyncio.get_running_loop()
        except RuntimeError:
            pass
        else:
            cls.started = True
        if cls.started:
            return
        ''
        ioloop = tornado.ioloop.IOLoop.instance()

        def shutdown():
            ioloop.stop()
            print('Server is stopped')
            sys.stdout.flush()
            cls.started = False

        @contextmanager
        def catch_sigint():
            old_handler = signal.signal(signal.SIGINT, lambda sig, frame: ioloop.add_callback_from_signal(shutdown))
            try:
                yield
            finally:
                signal.signal(signal.SIGINT, old_handler)
        cls.started = True
        print('Press Ctrl+C to stop WebAgg server')
        sys.stdout.flush()
        with catch_sigint():
            ioloop.start()

def ipython_inline_display(figure):
    import tornado.template
    WebAggApplication.initialize()
    import asyncio
    try:
        asyncio.get_running_loop()
    except RuntimeError:
        if not webagg_server_thread.is_alive():
            webagg_server_thread.start()
    fignum = figure.number
    tpl = Path(core.FigureManagerWebAgg.get_static_file_path(), 'ipython_inline_figure.html').read_text()
    t = tornado.template.Template(tpl)
    return t.generate(prefix=WebAggApplication.url_prefix, fig_id=fignum, toolitems=core.NavigationToolbar2WebAgg.toolitems, canvas=figure.canvas, port=WebAggApplication.port).decode('utf-8')

@_Backend.export
class _BackendWebAgg(_Backend):
    FigureCanvas = FigureCanvasWebAgg
    FigureManager = FigureManagerWebAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_webagg_core.py
""""""
import asyncio
import datetime
from io import BytesIO, StringIO
import json
import logging
import os
from pathlib import Path
import numpy as np
from PIL import Image
from matplotlib import _api, backend_bases, backend_tools
from matplotlib.backends import backend_agg
from matplotlib.backend_bases import _Backend, KeyEvent, LocationEvent, MouseEvent, ResizeEvent
_log = logging.getLogger(__name__)
_SPECIAL_KEYS_LUT = {'Alt': 'alt', 'AltGraph': 'alt', 'CapsLock': 'caps_lock', 'Control': 'control', 'Meta': 'meta', 'NumLock': 'num_lock', 'ScrollLock': 'scroll_lock', 'Shift': 'shift', 'Super': 'super', 'Enter': 'enter', 'Tab': 'tab', 'ArrowDown': 'down', 'ArrowLeft': 'left', 'ArrowRight': 'right', 'ArrowUp': 'up', 'End': 'end', 'Home': 'home', 'PageDown': 'pagedown', 'PageUp': 'pageup', 'Backspace': 'backspace', 'Delete': 'delete', 'Insert': 'insert', 'Escape': 'escape', 'Pause': 'pause', 'Select': 'select', 'Dead': 'dead', 'F1': 'f1', 'F2': 'f2', 'F3': 'f3', 'F4': 'f4', 'F5': 'f5', 'F6': 'f6', 'F7': 'f7', 'F8': 'f8', 'F9': 'f9', 'F10': 'f10', 'F11': 'f11', 'F12': 'f12'}

def _handle_key(key):
    value = key[key.index('k') + 1:]
    if 'shift+' in key:
        if len(value) == 1:
            key = key.replace('shift+', '')
    if value in _SPECIAL_KEYS_LUT:
        value = _SPECIAL_KEYS_LUT[value]
    key = key[:key.index('k')] + value
    return key

class TimerTornado(backend_bases.TimerBase):

    def __init__(self, *args, **kwargs):
        self._timer = None
        super().__init__(*args, **kwargs)

    def _timer_start(self):
        import tornado
        self._timer_stop()
        if self._single:
            ioloop = tornado.ioloop.IOLoop.instance()
            self._timer = ioloop.add_timeout(datetime.timedelta(milliseconds=self.interval), self._on_timer)
        else:
            self._timer = tornado.ioloop.PeriodicCallback(self._on_timer, max(self.interval, 1e-06))
            self._timer.start()

    def _timer_stop(self):
        import tornado
        if self._timer is None:
            return
        elif self._single:
            ioloop = tornado.ioloop.IOLoop.instance()
            ioloop.remove_timeout(self._timer)
        else:
            self._timer.stop()
        self._timer = None

    def _timer_set_interval(self):
        if self._timer is not None:
            self._timer_stop()
            self._timer_start()

class TimerAsyncio(backend_bases.TimerBase):

    def __init__(self, *args, **kwargs):
        self._task = None
        super().__init__(*args, **kwargs)

    async def _timer_task(self, interval):
        while True:
            try:
                await asyncio.sleep(interval)
                self._on_timer()
                if self._single:
                    break
            except asyncio.CancelledError:
                break

    def _timer_start(self):
        self._timer_stop()
        self._task = asyncio.ensure_future(self._timer_task(max(self.interval / 1000.0, 1e-06)))

    def _timer_stop(self):
        if self._task is not None:
            self._task.cancel()
        self._task = None

    def _timer_set_interval(self):
        if self._task is not None:
            self._timer_stop()
            self._timer_start()

class FigureCanvasWebAggCore(backend_agg.FigureCanvasAgg):
    manager_class = _api.classproperty(lambda cls: FigureManagerWebAgg)
    _timer_cls = TimerAsyncio
    supports_blit = False

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._png_is_old = True
        self._force_full = True
        self._last_buff = np.empty((0, 0))
        self._current_image_mode = 'full'
        self._last_mouse_xy = (None, None)

    def show(self):
        from matplotlib.pyplot import show
        show()

    def draw(self):
        self._png_is_old = True
        try:
            super().draw()
        finally:
            self.manager.refresh_all()

    def blit(self, bbox=None):
        self._png_is_old = True
        self.manager.refresh_all()

    def draw_idle(self):
        self.send_event('draw')

    def set_cursor(self, cursor):
        cursor = _api.check_getitem({backend_tools.Cursors.HAND: 'pointer', backend_tools.Cursors.POINTER: 'default', backend_tools.Cursors.SELECT_REGION: 'crosshair', backend_tools.Cursors.MOVE: 'move', backend_tools.Cursors.WAIT: 'wait', backend_tools.Cursors.RESIZE_HORIZONTAL: 'ew-resize', backend_tools.Cursors.RESIZE_VERTICAL: 'ns-resize'}, cursor=cursor)
        self.send_event('cursor', cursor=cursor)

    def set_image_mode(self, mode):
        _api.check_in_list(['full', 'diff'], mode=mode)
        if self._current_image_mode != mode:
            self._current_image_mode = mode
            self.handle_send_image_mode(None)

    def get_diff_image(self):
        if self._png_is_old:
            renderer = self.get_renderer()
            pixels = np.asarray(renderer.buffer_rgba())
            buff = pixels.view(np.uint32).squeeze(2)
            if self._force_full or buff.shape != self._last_buff.shape or (pixels[:, :, 3] != 255).any():
                self.set_image_mode('full')
                output = buff
            else:
                self.set_image_mode('diff')
                diff = buff != self._last_buff
                output = np.where(diff, buff, 0)
            self._last_buff = buff.copy()
            self._force_full = False
            self._png_is_old = False
            data = output.view(dtype=np.uint8).reshape((*output.shape, 4))
            with BytesIO() as png:
                Image.fromarray(data).save(png, format='png')
                return png.getvalue()

    def handle_event(self, event):
        e_type = event['type']
        handler = getattr(self, f'handle_{e_type}', self.handle_unknown_event)
        return handler(event)

    def handle_unknown_event(self, event):
        _log.warning('Unhandled message type %s. %s', event['type'], event)

    def handle_ack(self, event):
        pass

    def handle_draw(self, event):
        self.draw()

    def _handle_mouse(self, event):
        x = event['x']
        y = event['y']
        y = self.get_renderer().height - y
        self._last_mouse_xy = (x, y)
        button = event['button'] + 1
        e_type = event['type']
        modifiers = event['modifiers']
        guiEvent = event.get('guiEvent')
        if e_type in ['button_press', 'button_release']:
            MouseEvent(e_type + '_event', self, x, y, button, modifiers=modifiers, guiEvent=guiEvent)._process()
        elif e_type == 'dblclick':
            MouseEvent('button_press_event', self, x, y, button, dblclick=True, modifiers=modifiers, guiEvent=guiEvent)._process()
        elif e_type == 'scroll':
            MouseEvent('scroll_event', self, x, y, step=event['step'], modifiers=modifiers, guiEvent=guiEvent)._process()
        elif e_type == 'motion_notify':
            MouseEvent(e_type + '_event', self, x, y, modifiers=modifiers, guiEvent=guiEvent)._process()
        elif e_type in ['figure_enter', 'figure_leave']:
            LocationEvent(e_type + '_event', self, x, y, modifiers=modifiers, guiEvent=guiEvent)._process()
    handle_button_press = handle_button_release = handle_dblclick = handle_figure_enter = handle_figure_leave = handle_motion_notify = handle_scroll = _handle_mouse

    def _handle_key(self, event):
        KeyEvent(event['type'] + '_event', self, _handle_key(event['key']), *self._last_mouse_xy, guiEvent=event.get('guiEvent'))._process()
    handle_key_press = handle_key_release = _handle_key

    def handle_toolbar_button(self, event):
        getattr(self.toolbar, event['name'])()

    def handle_refresh(self, event):
        figure_label = self.figure.get_label()
        if not figure_label:
            figure_label = f'Figure {self.manager.num}'
        self.send_event('figure_label', label=figure_label)
        self._force_full = True
        if self.toolbar:
            self.toolbar.set_history_buttons()
        self.draw_idle()

    def handle_resize(self, event):
        x = int(event.get('width', 800)) * self.device_pixel_ratio
        y = int(event.get('height', 800)) * self.device_pixel_ratio
        fig = self.figure
        fig.set_size_inches(x / fig.dpi, y / fig.dpi, forward=False)
        self._png_is_old = True
        self.manager.resize(*fig.bbox.size, forward=False)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    def handle_send_image_mode(self, event):
        self.send_event('image_mode', mode=self._current_image_mode)

    def handle_set_device_pixel_ratio(self, event):
        self._handle_set_device_pixel_ratio(event.get('device_pixel_ratio', 1))

    def handle_set_dpi_ratio(self, event):
        self._handle_set_device_pixel_ratio(event.get('dpi_ratio', 1))

    def _handle_set_device_pixel_ratio(self, device_pixel_ratio):
        if self._set_device_pixel_ratio(device_pixel_ratio):
            self._force_full = True
            self.draw_idle()

    def send_event(self, event_type, **kwargs):
        if self.manager:
            self.manager._send_event(event_type, **kwargs)
_ALLOWED_TOOL_ITEMS = {'home', 'back', 'forward', 'pan', 'zoom', 'download', None}

class NavigationToolbar2WebAgg(backend_bases.NavigationToolbar2):
    toolitems = [(text, tooltip_text, image_file, name_of_method) for (text, tooltip_text, image_file, name_of_method) in (*backend_bases.NavigationToolbar2.toolitems, ('Download', 'Download plot', 'filesave', 'download')) if name_of_method in _ALLOWED_TOOL_ITEMS]

    def __init__(self, canvas):
        self.message = ''
        super().__init__(canvas)

    def set_message(self, message):
        if message != self.message:
            self.canvas.send_event('message', message=message)
        self.message = message

    def draw_rubberband(self, event, x0, y0, x1, y1):
        self.canvas.send_event('rubberband', x0=x0, y0=y0, x1=x1, y1=y1)

    def remove_rubberband(self):
        self.canvas.send_event('rubberband', x0=-1, y0=-1, x1=-1, y1=-1)

    def save_figure(self, *args):
        self.canvas.send_event('save')

    def pan(self):
        super().pan()
        self.canvas.send_event('navigate_mode', mode=self.mode.name)

    def zoom(self):
        super().zoom()
        self.canvas.send_event('navigate_mode', mode=self.mode.name)

    def set_history_buttons(self):
        can_backward = self._nav_stack._pos > 0
        can_forward = self._nav_stack._pos < len(self._nav_stack) - 1
        self.canvas.send_event('history_buttons', Back=can_backward, Forward=can_forward)

class FigureManagerWebAgg(backend_bases.FigureManagerBase):
    _toolbar2_class = None
    ToolbarCls = NavigationToolbar2WebAgg
    _window_title = 'Matplotlib'

    def __init__(self, canvas, num):
        self.web_sockets = set()
        super().__init__(canvas, num)

    def show(self):
        pass

    def resize(self, w, h, forward=True):
        self._send_event('resize', size=(w / self.canvas.device_pixel_ratio, h / self.canvas.device_pixel_ratio), forward=forward)

    def set_window_title(self, title):
        self._send_event('figure_label', label=title)
        self._window_title = title

    def get_window_title(self):
        return self._window_title

    def add_web_socket(self, web_socket):
        assert hasattr(web_socket, 'send_binary')
        assert hasattr(web_socket, 'send_json')
        self.web_sockets.add(web_socket)
        self.resize(*self.canvas.figure.bbox.size)
        self._send_event('refresh')

    def remove_web_socket(self, web_socket):
        self.web_sockets.remove(web_socket)

    def handle_json(self, content):
        self.canvas.handle_event(content)

    def refresh_all(self):
        if self.web_sockets:
            diff = self.canvas.get_diff_image()
            if diff is not None:
                for s in self.web_sockets:
                    s.send_binary(diff)

    @classmethod
    def get_javascript(cls, stream=None):
        if stream is None:
            output = StringIO()
        else:
            output = stream
        output.write((Path(__file__).parent / 'web_backend/js/mpl.js').read_text(encoding='utf-8'))
        toolitems = []
        for (name, tooltip, image, method) in cls.ToolbarCls.toolitems:
            if name is None:
                toolitems.append(['', '', '', ''])
            else:
                toolitems.append([name, tooltip, image, method])
        output.write(f'mpl.toolbar_items = {json.dumps(toolitems)};\n\n')
        extensions = []
        for (filetype, ext) in sorted(FigureCanvasWebAggCore.get_supported_filetypes_grouped().items()):
            extensions.append(ext[0])
        output.write(f'mpl.extensions = {json.dumps(extensions)};\n\n')
        output.write('mpl.default_extension = {};'.format(json.dumps(FigureCanvasWebAggCore.get_default_filetype())))
        if stream is None:
            return output.getvalue()

    @classmethod
    def get_static_file_path(cls):
        return os.path.join(os.path.dirname(__file__), 'web_backend')

    def _send_event(self, event_type, **kwargs):
        payload = {'type': event_type, **kwargs}
        for s in self.web_sockets:
            s.send_json(payload)

@_Backend.export
class _BackendWebAggCoreAgg(_Backend):
    FigureCanvas = FigureCanvasWebAggCore
    FigureManager = FigureManagerWebAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_wx.py
""""""
import functools
import logging
import math
import pathlib
import sys
import weakref
import numpy as np
import PIL.Image
import matplotlib as mpl
from matplotlib.backend_bases import _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase, MouseButton, NavigationToolbar2, RendererBase, TimerBase, ToolContainerBase, cursors, CloseEvent, KeyEvent, LocationEvent, MouseEvent, ResizeEvent
from matplotlib import _api, cbook, backend_tools, _c_internal_utils
from matplotlib._pylab_helpers import Gcf
from matplotlib.path import Path
from matplotlib.transforms import Affine2D
import wx
import wx.svg
_log = logging.getLogger(__name__)
PIXELS_PER_INCH = 75

@functools.lru_cache(1)
def _create_wxapp():
    wxapp = wx.App(False)
    wxapp.SetExitOnFrameDelete(True)
    cbook._setup_new_guiapp()
    _c_internal_utils.Win32_SetProcessDpiAwareness_max()
    return wxapp

class TimerWx(TimerBase):

    def __init__(self, *args, **kwargs):
        self._timer = wx.Timer()
        self._timer.Notify = self._on_timer
        super().__init__(*args, **kwargs)

    def _timer_start(self):
        self._timer.Start(self._interval, self._single)

    def _timer_stop(self):
        self._timer.Stop()

    def _timer_set_interval(self):
        if self._timer.IsRunning():
            self._timer_start()

@_api.deprecated('2.0', name='wx', obj_type='backend', removal='the future', alternative='wxagg', addendum='See the Matplotlib usage FAQ for more info on backends.')
class RendererWx(RendererBase):
    fontweights = {100: wx.FONTWEIGHT_LIGHT, 200: wx.FONTWEIGHT_LIGHT, 300: wx.FONTWEIGHT_LIGHT, 400: wx.FONTWEIGHT_NORMAL, 500: wx.FONTWEIGHT_NORMAL, 600: wx.FONTWEIGHT_NORMAL, 700: wx.FONTWEIGHT_BOLD, 800: wx.FONTWEIGHT_BOLD, 900: wx.FONTWEIGHT_BOLD, 'ultralight': wx.FONTWEIGHT_LIGHT, 'light': wx.FONTWEIGHT_LIGHT, 'normal': wx.FONTWEIGHT_NORMAL, 'medium': wx.FONTWEIGHT_NORMAL, 'semibold': wx.FONTWEIGHT_NORMAL, 'bold': wx.FONTWEIGHT_BOLD, 'heavy': wx.FONTWEIGHT_BOLD, 'ultrabold': wx.FONTWEIGHT_BOLD, 'black': wx.FONTWEIGHT_BOLD}
    fontangles = {'italic': wx.FONTSTYLE_ITALIC, 'normal': wx.FONTSTYLE_NORMAL, 'oblique': wx.FONTSTYLE_SLANT}
    fontnames = {'Sans': wx.FONTFAMILY_SWISS, 'Roman': wx.FONTFAMILY_ROMAN, 'Script': wx.FONTFAMILY_SCRIPT, 'Decorative': wx.FONTFAMILY_DECORATIVE, 'Modern': wx.FONTFAMILY_MODERN, 'Courier': wx.FONTFAMILY_MODERN, 'courier': wx.FONTFAMILY_MODERN}

    def __init__(self, bitmap, dpi):
        super().__init__()
        _log.debug('%s - __init__()', type(self))
        self.width = bitmap.GetWidth()
        self.height = bitmap.GetHeight()
        self.bitmap = bitmap
        self.fontd = {}
        self.dpi = dpi
        self.gc = None

    def flipy(self):
        return True

    def get_text_width_height_descent(self, s, prop, ismath):
        if ismath:
            s = cbook.strip_math(s)
        if self.gc is None:
            gc = self.new_gc()
        else:
            gc = self.gc
        gfx_ctx = gc.gfx_ctx
        font = self.get_wx_font(s, prop)
        gfx_ctx.SetFont(font, wx.BLACK)
        (w, h, descent, leading) = gfx_ctx.GetFullTextExtent(s)
        return (w, h, descent)

    def get_canvas_width_height(self):
        return (self.width, self.height)

    def handle_clip_rectangle(self, gc):
        new_bounds = gc.get_clip_rectangle()
        if new_bounds is not None:
            new_bounds = new_bounds.bounds
        gfx_ctx = gc.gfx_ctx
        if gfx_ctx._lastcliprect != new_bounds:
            gfx_ctx._lastcliprect = new_bounds
            if new_bounds is None:
                gfx_ctx.ResetClip()
            else:
                gfx_ctx.Clip(new_bounds[0], self.height - new_bounds[1] - new_bounds[3], new_bounds[2], new_bounds[3])

    @staticmethod
    def convert_path(gfx_ctx, path, transform):
        wxpath = gfx_ctx.CreatePath()
        for (points, code) in path.iter_segments(transform):
            if code == Path.MOVETO:
                wxpath.MoveToPoint(*points)
            elif code == Path.LINETO:
                wxpath.AddLineToPoint(*points)
            elif code == Path.CURVE3:
                wxpath.AddQuadCurveToPoint(*points)
            elif code == Path.CURVE4:
                wxpath.AddCurveToPoint(*points)
            elif code == Path.CLOSEPOLY:
                wxpath.CloseSubpath()
        return wxpath

    def draw_path(self, gc, path, transform, rgbFace=None):
        gc.select()
        self.handle_clip_rectangle(gc)
        gfx_ctx = gc.gfx_ctx
        transform = transform + Affine2D().scale(1.0, -1.0).translate(0.0, self.height)
        wxpath = self.convert_path(gfx_ctx, path, transform)
        if rgbFace is not None:
            gfx_ctx.SetBrush(wx.Brush(gc.get_wxcolour(rgbFace)))
            gfx_ctx.DrawPath(wxpath)
        else:
            gfx_ctx.StrokePath(wxpath)
        gc.unselect()

    def draw_image(self, gc, x, y, im):
        bbox = gc.get_clip_rectangle()
        if bbox is not None:
            (l, b, w, h) = bbox.bounds
        else:
            l = 0
            b = 0
            w = self.width
            h = self.height
        (rows, cols) = im.shape[:2]
        bitmap = wx.Bitmap.FromBufferRGBA(cols, rows, im.tobytes())
        gc.select()
        gc.gfx_ctx.DrawBitmap(bitmap, int(l), int(self.height - b), int(w), int(-h))
        gc.unselect()

    def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
        if ismath:
            s = cbook.strip_math(s)
        _log.debug('%s - draw_text()', type(self))
        gc.select()
        self.handle_clip_rectangle(gc)
        gfx_ctx = gc.gfx_ctx
        font = self.get_wx_font(s, prop)
        color = gc.get_wxcolour(gc.get_rgb())
        gfx_ctx.SetFont(font, color)
        (w, h, d) = self.get_text_width_height_descent(s, prop, ismath)
        x = int(x)
        y = int(y - h)
        if angle == 0.0:
            gfx_ctx.DrawText(s, x, y)
        else:
            rads = math.radians(angle)
            xo = h * math.sin(rads)
            yo = h * math.cos(rads)
            gfx_ctx.DrawRotatedText(s, x - xo, y - yo, rads)
        gc.unselect()

    def new_gc(self):
        _log.debug('%s - new_gc()', type(self))
        self.gc = GraphicsContextWx(self.bitmap, self)
        self.gc.select()
        self.gc.unselect()
        return self.gc

    def get_wx_font(self, s, prop):
        _log.debug('%s - get_wx_font()', type(self))
        key = hash(prop)
        font = self.fontd.get(key)
        if font is not None:
            return font
        size = self.points_to_pixels(prop.get_size_in_points())
        self.fontd[key] = font = wx.Font(pointSize=round(size), family=self.fontnames.get(prop.get_name(), wx.ROMAN), style=self.fontangles[prop.get_style()], weight=self.fontweights[prop.get_weight()])
        return font

    def points_to_pixels(self, points):
        return points * (PIXELS_PER_INCH / 72.0 * self.dpi / 72.0)

class GraphicsContextWx(GraphicsContextBase):
    _capd = {'butt': wx.CAP_BUTT, 'projecting': wx.CAP_PROJECTING, 'round': wx.CAP_ROUND}
    _joind = {'bevel': wx.JOIN_BEVEL, 'miter': wx.JOIN_MITER, 'round': wx.JOIN_ROUND}
    _cache = weakref.WeakKeyDictionary()

    def __init__(self, bitmap, renderer):
        super().__init__()
        _log.debug('%s - __init__(): %s', type(self), bitmap)
        (dc, gfx_ctx) = self._cache.get(bitmap, (None, None))
        if dc is None:
            dc = wx.MemoryDC(bitmap)
            gfx_ctx = wx.GraphicsContext.Create(dc)
            gfx_ctx._lastcliprect = None
            self._cache[bitmap] = (dc, gfx_ctx)
        self.bitmap = bitmap
        self.dc = dc
        self.gfx_ctx = gfx_ctx
        self._pen = wx.Pen('BLACK', 1, wx.SOLID)
        gfx_ctx.SetPen(self._pen)
        self.renderer = renderer

    def select(self):
        if sys.platform == 'win32':
            self.dc.SelectObject(self.bitmap)
            self.IsSelected = True

    def unselect(self):
        if sys.platform == 'win32':
            self.dc.SelectObject(wx.NullBitmap)
            self.IsSelected = False

    def set_foreground(self, fg, isRGBA=None):
        _log.debug('%s - set_foreground()', type(self))
        self.select()
        super().set_foreground(fg, isRGBA)
        self._pen.SetColour(self.get_wxcolour(self.get_rgb()))
        self.gfx_ctx.SetPen(self._pen)
        self.unselect()

    def set_linewidth(self, w):
        w = float(w)
        _log.debug('%s - set_linewidth()', type(self))
        self.select()
        if 0 < w < 1:
            w = 1
        super().set_linewidth(w)
        lw = int(self.renderer.points_to_pixels(self._linewidth))
        if lw == 0:
            lw = 1
        self._pen.SetWidth(lw)
        self.gfx_ctx.SetPen(self._pen)
        self.unselect()

    def set_capstyle(self, cs):
        _log.debug('%s - set_capstyle()', type(self))
        self.select()
        super().set_capstyle(cs)
        self._pen.SetCap(GraphicsContextWx._capd[self._capstyle])
        self.gfx_ctx.SetPen(self._pen)
        self.unselect()

    def set_joinstyle(self, js):
        _log.debug('%s - set_joinstyle()', type(self))
        self.select()
        super().set_joinstyle(js)
        self._pen.SetJoin(GraphicsContextWx._joind[self._joinstyle])
        self.gfx_ctx.SetPen(self._pen)
        self.unselect()

    def get_wxcolour(self, color):
        _log.debug('%s - get_wx_color()', type(self))
        return wx.Colour(*[int(255 * x) for x in color])

class _FigureCanvasWxBase(FigureCanvasBase, wx.Panel):
    required_interactive_framework = 'wx'
    _timer_cls = TimerWx
    manager_class = _api.classproperty(lambda cls: FigureManagerWx)
    keyvald = {wx.WXK_CONTROL: 'control', wx.WXK_SHIFT: 'shift', wx.WXK_ALT: 'alt', wx.WXK_CAPITAL: 'caps_lock', wx.WXK_LEFT: 'left', wx.WXK_UP: 'up', wx.WXK_RIGHT: 'right', wx.WXK_DOWN: 'down', wx.WXK_ESCAPE: 'escape', wx.WXK_F1: 'f1', wx.WXK_F2: 'f2', wx.WXK_F3: 'f3', wx.WXK_F4: 'f4', wx.WXK_F5: 'f5', wx.WXK_F6: 'f6', wx.WXK_F7: 'f7', wx.WXK_F8: 'f8', wx.WXK_F9: 'f9', wx.WXK_F10: 'f10', wx.WXK_F11: 'f11', wx.WXK_F12: 'f12', wx.WXK_SCROLL: 'scroll_lock', wx.WXK_PAUSE: 'break', wx.WXK_BACK: 'backspace', wx.WXK_RETURN: 'enter', wx.WXK_INSERT: 'insert', wx.WXK_DELETE: 'delete', wx.WXK_HOME: 'home', wx.WXK_END: 'end', wx.WXK_PAGEUP: 'pageup', wx.WXK_PAGEDOWN: 'pagedown', wx.WXK_NUMPAD0: '0', wx.WXK_NUMPAD1: '1', wx.WXK_NUMPAD2: '2', wx.WXK_NUMPAD3: '3', wx.WXK_NUMPAD4: '4', wx.WXK_NUMPAD5: '5', wx.WXK_NUMPAD6: '6', wx.WXK_NUMPAD7: '7', wx.WXK_NUMPAD8: '8', wx.WXK_NUMPAD9: '9', wx.WXK_NUMPAD_ADD: '+', wx.WXK_NUMPAD_SUBTRACT: '-', wx.WXK_NUMPAD_MULTIPLY: '*', wx.WXK_NUMPAD_DIVIDE: '/', wx.WXK_NUMPAD_DECIMAL: 'dec', wx.WXK_NUMPAD_ENTER: 'enter', wx.WXK_NUMPAD_UP: 'up', wx.WXK_NUMPAD_RIGHT: 'right', wx.WXK_NUMPAD_DOWN: 'down', wx.WXK_NUMPAD_LEFT: 'left', wx.WXK_NUMPAD_PAGEUP: 'pageup', wx.WXK_NUMPAD_PAGEDOWN: 'pagedown', wx.WXK_NUMPAD_HOME: 'home', wx.WXK_NUMPAD_END: 'end', wx.WXK_NUMPAD_INSERT: 'insert', wx.WXK_NUMPAD_DELETE: 'delete'}

    def __init__(self, parent, id, figure=None):
        FigureCanvasBase.__init__(self, figure)
        size = wx.Size(*map(math.ceil, self.figure.bbox.size))
        if wx.Platform != '__WXMSW__':
            size = parent.FromDIP(size)
        wx.Panel.__init__(self, parent, id, size=size)
        self.bitmap = None
        self._isDrawn = False
        self._rubberband_rect = None
        self._rubberband_pen_black = wx.Pen('BLACK', 1, wx.PENSTYLE_SHORT_DASH)
        self._rubberband_pen_white = wx.Pen('WHITE', 1, wx.PENSTYLE_SOLID)
        self.Bind(wx.EVT_SIZE, self._on_size)
        self.Bind(wx.EVT_PAINT, self._on_paint)
        self.Bind(wx.EVT_CHAR_HOOK, self._on_key_down)
        self.Bind(wx.EVT_KEY_UP, self._on_key_up)
        self.Bind(wx.EVT_LEFT_DOWN, self._on_mouse_button)
        self.Bind(wx.EVT_LEFT_DCLICK, self._on_mouse_button)
        self.Bind(wx.EVT_LEFT_UP, self._on_mouse_button)
        self.Bind(wx.EVT_MIDDLE_DOWN, self._on_mouse_button)
        self.Bind(wx.EVT_MIDDLE_DCLICK, self._on_mouse_button)
        self.Bind(wx.EVT_MIDDLE_UP, self._on_mouse_button)
        self.Bind(wx.EVT_RIGHT_DOWN, self._on_mouse_button)
        self.Bind(wx.EVT_RIGHT_DCLICK, self._on_mouse_button)
        self.Bind(wx.EVT_RIGHT_UP, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX1_DOWN, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX1_UP, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX2_DOWN, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX2_UP, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX1_DCLICK, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSE_AUX2_DCLICK, self._on_mouse_button)
        self.Bind(wx.EVT_MOUSEWHEEL, self._on_mouse_wheel)
        self.Bind(wx.EVT_MOTION, self._on_motion)
        self.Bind(wx.EVT_ENTER_WINDOW, self._on_enter)
        self.Bind(wx.EVT_LEAVE_WINDOW, self._on_leave)
        self.Bind(wx.EVT_MOUSE_CAPTURE_CHANGED, self._on_capture_lost)
        self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, self._on_capture_lost)
        self.SetBackgroundStyle(wx.BG_STYLE_PAINT)
        self.SetBackgroundColour(wx.WHITE)
        if wx.Platform == '__WXMAC__':
            dpiScale = self.GetDPIScaleFactor()
            self.SetInitialSize(self.GetSize() * (1 / dpiScale))
            self._set_device_pixel_ratio(dpiScale)

    def Copy_to_Clipboard(self, event=None):
        bmp_obj = wx.BitmapDataObject()
        bmp_obj.SetBitmap(self.bitmap)
        if not wx.TheClipboard.IsOpened():
            open_success = wx.TheClipboard.Open()
            if open_success:
                wx.TheClipboard.SetData(bmp_obj)
                wx.TheClipboard.Flush()
                wx.TheClipboard.Close()

    def _update_device_pixel_ratio(self, *args, **kwargs):
        if self._set_device_pixel_ratio(self.GetDPIScaleFactor()):
            self.draw()

    def draw_idle(self):
        _log.debug('%s - draw_idle()', type(self))
        self._isDrawn = False
        self.Refresh(eraseBackground=False)

    def flush_events(self):
        wx.Yield()

    def start_event_loop(self, timeout=0):
        if hasattr(self, '_event_loop'):
            raise RuntimeError('Event loop already running')
        timer = wx.Timer(self, id=wx.ID_ANY)
        if timeout > 0:
            timer.Start(int(timeout * 1000), oneShot=True)
            self.Bind(wx.EVT_TIMER, self.stop_event_loop, id=timer.GetId())
        self._event_loop = wx.GUIEventLoop()
        self._event_loop.Run()
        timer.Stop()

    def stop_event_loop(self, event=None):
        if hasattr(self, '_event_loop'):
            if self._event_loop.IsRunning():
                self._event_loop.Exit()
            del self._event_loop

    def _get_imagesave_wildcards(self):
        default_filetype = self.get_default_filetype()
        filetypes = self.get_supported_filetypes_grouped()
        sorted_filetypes = sorted(filetypes.items())
        wildcards = []
        extensions = []
        filter_index = 0
        for (i, (name, exts)) in enumerate(sorted_filetypes):
            ext_list = ';'.join(['*.%s' % ext for ext in exts])
            extensions.append(exts[0])
            wildcard = f'{name} ({ext_list})|{ext_list}'
            if default_filetype in exts:
                filter_index = i
            wildcards.append(wildcard)
        wildcards = '|'.join(wildcards)
        return (wildcards, extensions, filter_index)

    def gui_repaint(self, drawDC=None):
        _log.debug('%s - gui_repaint()', type(self))
        if not (self and self.IsShownOnScreen()):
            return
        if not drawDC:
            drawDC = wx.ClientDC(self)
        bmp = self.bitmap.ConvertToImage().ConvertToBitmap() if wx.Platform == '__WXMSW__' and isinstance(self.figure.canvas.get_renderer(), RendererWx) else self.bitmap
        drawDC.DrawBitmap(bmp, 0, 0)
        if self._rubberband_rect is not None:
            (x0, y0, x1, y1) = map(round, self._rubberband_rect)
            rect = [(x0, y0, x1, y0), (x1, y0, x1, y1), (x0, y0, x0, y1), (x0, y1, x1, y1)]
            drawDC.DrawLineList(rect, self._rubberband_pen_white)
            drawDC.DrawLineList(rect, self._rubberband_pen_black)
    filetypes = {**FigureCanvasBase.filetypes, 'bmp': 'Windows bitmap', 'jpeg': 'JPEG', 'jpg': 'JPEG', 'pcx': 'PCX', 'png': 'Portable Network Graphics', 'tif': 'Tagged Image Format File', 'tiff': 'Tagged Image Format File', 'xpm': 'X pixmap'}

    def _on_paint(self, event):
        _log.debug('%s - _on_paint()', type(self))
        drawDC = wx.PaintDC(self)
        if not self._isDrawn:
            self.draw(drawDC=drawDC)
        else:
            self.gui_repaint(drawDC=drawDC)
        drawDC.Destroy()

    def _on_size(self, event):
        self._update_device_pixel_ratio()
        _log.debug('%s - _on_size()', type(self))
        sz = self.GetParent().GetSizer()
        if sz:
            si = sz.GetItem(self)
        if sz and si and (not si.Proportion) and (not si.Flag & wx.EXPAND):
            size = self.GetMinSize()
        else:
            size = self.GetClientSize()
            size.IncTo(self.GetMinSize())
        if getattr(self, '_width', None):
            if size == (self._width, self._height):
                return
        (self._width, self._height) = size
        self._isDrawn = False
        if self._width <= 1 or self._height <= 1:
            return
        dpival = self.figure.dpi
        if not wx.Platform == '__WXMSW__':
            scale = self.GetDPIScaleFactor()
            dpival /= scale
        winch = self._width / dpival
        hinch = self._height / dpival
        self.figure.set_size_inches(winch, hinch, forward=False)
        self.Refresh(eraseBackground=False)
        ResizeEvent('resize_event', self)._process()
        self.draw_idle()

    @staticmethod
    def _mpl_modifiers(event=None, *, exclude=None):
        mod_table = [('ctrl', wx.MOD_CONTROL, wx.WXK_CONTROL), ('alt', wx.MOD_ALT, wx.WXK_ALT), ('shift', wx.MOD_SHIFT, wx.WXK_SHIFT)]
        if event is not None:
            modifiers = event.GetModifiers()
            return [name for (name, mod, key) in mod_table if modifiers & mod and exclude != key]
        else:
            return [name for (name, mod, key) in mod_table if wx.GetKeyState(key)]

    def _get_key(self, event):
        keyval = event.KeyCode
        if keyval in self.keyvald:
            key = self.keyvald[keyval]
        elif keyval < 256:
            key = chr(keyval)
            if not event.ShiftDown():
                key = key.lower()
        else:
            return None
        mods = self._mpl_modifiers(event, exclude=keyval)
        if 'shift' in mods and key.isupper():
            mods.remove('shift')
        return '+'.join([*mods, key])

    def _mpl_coords(self, pos=None):
        if pos is None:
            pos = wx.GetMouseState()
            (x, y) = self.ScreenToClient(pos.X, pos.Y)
        else:
            (x, y) = (pos.X, pos.Y)
        if not wx.Platform == '__WXMSW__':
            scale = self.GetDPIScaleFactor()
            return (x * scale, self.figure.bbox.height - y * scale)
        else:
            return (x, self.figure.bbox.height - y)

    def _on_key_down(self, event):
        KeyEvent('key_press_event', self, self._get_key(event), *self._mpl_coords(), guiEvent=event)._process()
        if self:
            event.Skip()

    def _on_key_up(self, event):
        KeyEvent('key_release_event', self, self._get_key(event), *self._mpl_coords(), guiEvent=event)._process()
        if self:
            event.Skip()

    def set_cursor(self, cursor):
        cursor = wx.Cursor(_api.check_getitem({cursors.MOVE: wx.CURSOR_HAND, cursors.HAND: wx.CURSOR_HAND, cursors.POINTER: wx.CURSOR_ARROW, cursors.SELECT_REGION: wx.CURSOR_CROSS, cursors.WAIT: wx.CURSOR_WAIT, cursors.RESIZE_HORIZONTAL: wx.CURSOR_SIZEWE, cursors.RESIZE_VERTICAL: wx.CURSOR_SIZENS}, cursor=cursor))
        self.SetCursor(cursor)
        self.Refresh()

    def _set_capture(self, capture=True):
        if self.HasCapture():
            self.ReleaseMouse()
        if capture:
            self.CaptureMouse()

    def _on_capture_lost(self, event):
        self._set_capture(False)

    def _on_mouse_button(self, event):
        event.Skip()
        self._set_capture(event.ButtonDown() or event.ButtonDClick())
        (x, y) = self._mpl_coords(event)
        button_map = {wx.MOUSE_BTN_LEFT: MouseButton.LEFT, wx.MOUSE_BTN_MIDDLE: MouseButton.MIDDLE, wx.MOUSE_BTN_RIGHT: MouseButton.RIGHT, wx.MOUSE_BTN_AUX1: MouseButton.BACK, wx.MOUSE_BTN_AUX2: MouseButton.FORWARD}
        button = event.GetButton()
        button = button_map.get(button, button)
        modifiers = self._mpl_modifiers(event)
        if event.ButtonDown():
            MouseEvent('button_press_event', self, x, y, button, modifiers=modifiers, guiEvent=event)._process()
        elif event.ButtonDClick():
            MouseEvent('button_press_event', self, x, y, button, dblclick=True, modifiers=modifiers, guiEvent=event)._process()
        elif event.ButtonUp():
            MouseEvent('button_release_event', self, x, y, button, modifiers=modifiers, guiEvent=event)._process()

    def _on_mouse_wheel(self, event):
        (x, y) = self._mpl_coords(event)
        step = event.LinesPerAction * event.WheelRotation / event.WheelDelta
        event.Skip()
        if wx.Platform == '__WXMAC__':
            if not hasattr(self, '_skipwheelevent'):
                self._skipwheelevent = True
            elif self._skipwheelevent:
                self._skipwheelevent = False
                return
            else:
                self._skipwheelevent = True
        MouseEvent('scroll_event', self, x, y, step=step, modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def _on_motion(self, event):
        event.Skip()
        MouseEvent('motion_notify_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(event), guiEvent=event)._process()

    def _on_enter(self, event):
        event.Skip()
        LocationEvent('figure_enter_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(), guiEvent=event)._process()

    def _on_leave(self, event):
        event.Skip()
        LocationEvent('figure_leave_event', self, *self._mpl_coords(event), modifiers=self._mpl_modifiers(), guiEvent=event)._process()

class FigureCanvasWx(_FigureCanvasWxBase):

    def draw(self, drawDC=None):
        _log.debug('%s - draw()', type(self))
        self.renderer = RendererWx(self.bitmap, self.figure.dpi)
        self.figure.draw(self.renderer)
        self._isDrawn = True
        self.gui_repaint(drawDC=drawDC)

    def _print_image(self, filetype, filename):
        bitmap = wx.Bitmap(math.ceil(self.figure.bbox.width), math.ceil(self.figure.bbox.height))
        self.figure.draw(RendererWx(bitmap, self.figure.dpi))
        saved_obj = bitmap.ConvertToImage() if cbook.is_writable_file_like(filename) else bitmap
        if not saved_obj.SaveFile(filename, filetype):
            raise RuntimeError(f'Could not save figure to {filename}')
        if self._isDrawn:
            self.draw()
        if self:
            self.Refresh()
    print_bmp = functools.partialmethod(_print_image, wx.BITMAP_TYPE_BMP)
    print_jpeg = print_jpg = functools.partialmethod(_print_image, wx.BITMAP_TYPE_JPEG)
    print_pcx = functools.partialmethod(_print_image, wx.BITMAP_TYPE_PCX)
    print_png = functools.partialmethod(_print_image, wx.BITMAP_TYPE_PNG)
    print_tiff = print_tif = functools.partialmethod(_print_image, wx.BITMAP_TYPE_TIF)
    print_xpm = functools.partialmethod(_print_image, wx.BITMAP_TYPE_XPM)

class FigureFrameWx(wx.Frame):

    def __init__(self, num, fig, *, canvas_class):
        if wx.Platform == '__WXMSW__':
            pos = wx.DefaultPosition
        else:
            pos = wx.Point(20, 20)
        super().__init__(parent=None, id=-1, pos=pos)
        _log.debug('%s - __init__()', type(self))
        _set_frame_icon(self)
        self.canvas = canvas_class(self, -1, fig)
        manager = FigureManagerWx(self.canvas, num, self)
        toolbar = self.canvas.manager.toolbar
        if toolbar is not None:
            self.SetToolBar(toolbar)
        (w, h) = map(math.ceil, fig.bbox.size)
        self.canvas.SetInitialSize(self.FromDIP(wx.Size(w, h)))
        self.canvas.SetMinSize(self.FromDIP(wx.Size(2, 2)))
        self.canvas.SetFocus()
        self.Fit()
        self.Bind(wx.EVT_CLOSE, self._on_close)

    def _on_close(self, event):
        _log.debug('%s - on_close()', type(self))
        CloseEvent('close_event', self.canvas)._process()
        self.canvas.stop_event_loop()
        self.canvas.manager.frame = None
        Gcf.destroy(self.canvas.manager)
        try:
            self.canvas.mpl_disconnect(self.canvas.toolbar._id_drag)
        except AttributeError:
            pass
        event.Skip()

class FigureManagerWx(FigureManagerBase):

    def __init__(self, canvas, num, frame):
        _log.debug('%s - __init__()', type(self))
        self.frame = self.window = frame
        super().__init__(canvas, num)

    @classmethod
    def create_with_canvas(cls, canvas_class, figure, num):
        wxapp = wx.GetApp() or _create_wxapp()
        frame = FigureFrameWx(num, figure, canvas_class=canvas_class)
        manager = figure.canvas.manager
        if mpl.is_interactive():
            manager.frame.Show()
            figure.canvas.draw_idle()
        return manager

    @classmethod
    def start_main_loop(cls):
        if not wx.App.IsMainLoopRunning():
            wxapp = wx.GetApp()
            if wxapp is not None:
                wxapp.MainLoop()

    def show(self):
        self.frame.Show()
        self.canvas.draw()
        if mpl.rcParams['figure.raise_window']:
            self.frame.Raise()

    def destroy(self, *args):
        _log.debug('%s - destroy()', type(self))
        frame = self.frame
        if frame:
            wx.CallAfter(frame.Close)

    def full_screen_toggle(self):
        self.frame.ShowFullScreen(not self.frame.IsFullScreen())

    def get_window_title(self):
        return self.window.GetTitle()

    def set_window_title(self, title):
        self.window.SetTitle(title)

    def resize(self, width, height):
        self.window.SetSize(self.window.ClientToWindowSize(wx.Size(math.ceil(width), math.ceil(height))))

def _load_bitmap(filename):
    return wx.Bitmap(str(cbook._get_data_path('images', filename)))

def _set_frame_icon(frame):
    bundle = wx.IconBundle()
    for image in ('matplotlib.png', 'matplotlib_large.png'):
        icon = wx.Icon(_load_bitmap(image))
        if not icon.IsOk():
            return
        bundle.AddIcon(icon)
    frame.SetIcons(bundle)

class NavigationToolbar2Wx(NavigationToolbar2, wx.ToolBar):

    def __init__(self, canvas, coordinates=True, *, style=wx.TB_BOTTOM):
        wx.ToolBar.__init__(self, canvas.GetParent(), -1, style=style)
        if wx.Platform == '__WXMAC__':
            self.SetToolBitmapSize(self.GetToolBitmapSize() * self.GetDPIScaleFactor())
        self.wx_ids = {}
        for (text, tooltip_text, image_file, callback) in self.toolitems:
            if text is None:
                self.AddSeparator()
                continue
            self.wx_ids[text] = self.AddTool(-1, bitmap=self._icon(f'{image_file}.svg'), bmpDisabled=wx.NullBitmap, label=text, shortHelp=tooltip_text, kind=wx.ITEM_CHECK if text in ['Pan', 'Zoom'] else wx.ITEM_NORMAL).Id
            self.Bind(wx.EVT_TOOL, getattr(self, callback), id=self.wx_ids[text])
        self._coordinates = coordinates
        if self._coordinates:
            self.AddStretchableSpace()
            self._label_text = wx.StaticText(self, style=wx.ALIGN_RIGHT)
            self.AddControl(self._label_text)
        self.Realize()
        NavigationToolbar2.__init__(self, canvas)

    @staticmethod
    def _icon(name):
        try:
            dark = wx.SystemSettings.GetAppearance().IsDark()
        except AttributeError:
            bg = wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)
            fg = wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOWTEXT)
            bg_lum = (0.299 * bg.red + 0.587 * bg.green + 0.114 * bg.blue) / 255
            fg_lum = (0.299 * fg.red + 0.587 * fg.green + 0.114 * fg.blue) / 255
            dark = fg_lum - bg_lum > 0.2
        path = cbook._get_data_path('images', name)
        if path.suffix == '.svg':
            svg = path.read_bytes()
            if dark:
                svg = svg.replace(b'fill:black;', b'fill:white;')
            toolbarIconSize = wx.ArtProvider().GetDIPSizeHint(wx.ART_TOOLBAR)
            return wx.BitmapBundle.FromSVG(svg, toolbarIconSize)
        else:
            pilimg = PIL.Image.open(path)
            image = np.array(pilimg.convert('RGBA'))
            if dark:
                fg = wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOWTEXT)
                black_mask = (image[..., :3] == 0).all(axis=-1)
                image[black_mask, :3] = (fg.Red(), fg.Green(), fg.Blue())
            return wx.Bitmap.FromBufferRGBA(image.shape[1], image.shape[0], image.tobytes())

    def _update_buttons_checked(self):
        if 'Pan' in self.wx_ids:
            self.ToggleTool(self.wx_ids['Pan'], self.mode.name == 'PAN')
        if 'Zoom' in self.wx_ids:
            self.ToggleTool(self.wx_ids['Zoom'], self.mode.name == 'ZOOM')

    def zoom(self, *args):
        super().zoom(*args)
        self._update_buttons_checked()

    def pan(self, *args):
        super().pan(*args)
        self._update_buttons_checked()

    def save_figure(self, *args):
        (filetypes, exts, filter_index) = self.canvas._get_imagesave_wildcards()
        default_file = self.canvas.get_default_filename()
        dialog = wx.FileDialog(self.canvas.GetParent(), 'Save to file', mpl.rcParams['savefig.directory'], default_file, filetypes, wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
        dialog.SetFilterIndex(filter_index)
        if dialog.ShowModal() == wx.ID_OK:
            path = pathlib.Path(dialog.GetPath())
            _log.debug('%s - Save file path: %s', type(self), path)
            fmt = exts[dialog.GetFilterIndex()]
            ext = path.suffix[1:]
            if ext in self.canvas.get_supported_filetypes() and fmt != ext:
                _log.warning('extension %s did not match the selected image type %s; going with %s', ext, fmt, ext)
                fmt = ext
            if mpl.rcParams['savefig.directory']:
                mpl.rcParams['savefig.directory'] = str(path.parent)
            try:
                self.canvas.figure.savefig(path, format=fmt)
            except Exception as e:
                dialog = wx.MessageDialog(parent=self.canvas.GetParent(), message=str(e), caption='Matplotlib error')
                dialog.ShowModal()
                dialog.Destroy()

    def draw_rubberband(self, event, x0, y0, x1, y1):
        height = self.canvas.figure.bbox.height
        sf = 1 if wx.Platform == '__WXMSW__' else self.canvas.GetDPIScaleFactor()
        self.canvas._rubberband_rect = (x0 / sf, (height - y0) / sf, x1 / sf, (height - y1) / sf)
        self.canvas.Refresh()

    def remove_rubberband(self):
        self.canvas._rubberband_rect = None
        self.canvas.Refresh()

    def set_message(self, s):
        if self._coordinates:
            self._label_text.SetLabel(s)

    def set_history_buttons(self):
        can_backward = self._nav_stack._pos > 0
        can_forward = self._nav_stack._pos < len(self._nav_stack) - 1
        if 'Back' in self.wx_ids:
            self.EnableTool(self.wx_ids['Back'], can_backward)
        if 'Forward' in self.wx_ids:
            self.EnableTool(self.wx_ids['Forward'], can_forward)

class ToolbarWx(ToolContainerBase, wx.ToolBar):
    _icon_extension = '.svg'

    def __init__(self, toolmanager, parent=None, style=wx.TB_BOTTOM):
        if parent is None:
            parent = toolmanager.canvas.GetParent()
        ToolContainerBase.__init__(self, toolmanager)
        wx.ToolBar.__init__(self, parent, -1, style=style)
        self._space = self.AddStretchableSpace()
        self._label_text = wx.StaticText(self, style=wx.ALIGN_RIGHT)
        self.AddControl(self._label_text)
        self._toolitems = {}
        self._groups = {}

    def _get_tool_pos(self, tool):
        (pos,) = (pos for pos in range(self.ToolsCount) if self.GetToolByPos(pos) == tool)
        return pos

    def add_toolitem(self, name, group, position, image_file, description, toggle):
        if group not in self._groups:
            self._groups[group] = self.InsertSeparator(self._get_tool_pos(self._space))
        sep = self._groups[group]
        seps = [t for t in map(self.GetToolByPos, range(self.ToolsCount)) if t.IsSeparator() and (not t.IsStretchableSpace())]
        if position >= 0:
            start = 0 if sep == seps[0] else self._get_tool_pos(seps[seps.index(sep) - 1]) + 1
        else:
            start = self._get_tool_pos(sep) + 1
        idx = start + position
        if image_file:
            bmp = NavigationToolbar2Wx._icon(image_file)
            kind = wx.ITEM_NORMAL if not toggle else wx.ITEM_CHECK
            tool = self.InsertTool(idx, -1, name, bmp, wx.NullBitmap, kind, description or '')
        else:
            size = (self.GetTextExtent(name)[0] + 10, -1)
            if toggle:
                control = wx.ToggleButton(self, -1, name, size=size)
            else:
                control = wx.Button(self, -1, name, size=size)
            tool = self.InsertControl(idx, control, label=name)
        self.Realize()

        def handler(event):
            self.trigger_tool(name)
        if image_file:
            self.Bind(wx.EVT_TOOL, handler, tool)
        else:
            control.Bind(wx.EVT_LEFT_DOWN, handler)
        self._toolitems.setdefault(name, [])
        self._toolitems[name].append((tool, handler))

    def toggle_toolitem(self, name, toggled):
        if name not in self._toolitems:
            return
        for (tool, handler) in self._toolitems[name]:
            if not tool.IsControl():
                self.ToggleTool(tool.Id, toggled)
            else:
                tool.GetControl().SetValue(toggled)
        self.Refresh()

    def remove_toolitem(self, name):
        for (tool, handler) in self._toolitems.pop(name, []):
            self.DeleteTool(tool.Id)

    def set_message(self, s):
        self._label_text.SetLabel(s)

@backend_tools._register_tool_class(_FigureCanvasWxBase)
class ConfigureSubplotsWx(backend_tools.ConfigureSubplotsBase):

    def trigger(self, *args):
        NavigationToolbar2Wx.configure_subplots(self)

@backend_tools._register_tool_class(_FigureCanvasWxBase)
class SaveFigureWx(backend_tools.SaveFigureBase):

    def trigger(self, *args):
        NavigationToolbar2Wx.save_figure(self._make_classic_style_pseudo_toolbar())

@backend_tools._register_tool_class(_FigureCanvasWxBase)
class RubberbandWx(backend_tools.RubberbandBase):

    def draw_rubberband(self, x0, y0, x1, y1):
        NavigationToolbar2Wx.draw_rubberband(self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)

    def remove_rubberband(self):
        NavigationToolbar2Wx.remove_rubberband(self._make_classic_style_pseudo_toolbar())

class _HelpDialog(wx.Dialog):
    _instance = None
    headers = [('Action', 'Shortcuts', 'Description')]
    widths = [100, 140, 300]

    def __init__(self, parent, help_entries):
        super().__init__(parent, title='Help', style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
        sizer = wx.BoxSizer(wx.VERTICAL)
        grid_sizer = wx.FlexGridSizer(0, 3, 8, 6)
        bold = self.GetFont().MakeBold()
        for (r, row) in enumerate(self.headers + help_entries):
            for (col, width) in zip(row, self.widths):
                label = wx.StaticText(self, label=col)
                if r == 0:
                    label.SetFont(bold)
                label.Wrap(width)
                grid_sizer.Add(label, 0, 0, 0)
        sizer.Add(grid_sizer, 0, wx.ALL, 6)
        ok = wx.Button(self, wx.ID_OK)
        sizer.Add(ok, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 8)
        self.SetSizer(sizer)
        sizer.Fit(self)
        self.Layout()
        self.Bind(wx.EVT_CLOSE, self._on_close)
        ok.Bind(wx.EVT_BUTTON, self._on_close)

    def _on_close(self, event):
        _HelpDialog._instance = None
        self.DestroyLater()
        event.Skip()

    @classmethod
    def show(cls, parent, help_entries):
        if cls._instance:
            cls._instance.Raise()
            return
        cls._instance = cls(parent, help_entries)
        cls._instance.Show()

@backend_tools._register_tool_class(_FigureCanvasWxBase)
class HelpWx(backend_tools.ToolHelpBase):

    def trigger(self, *args):
        _HelpDialog.show(self.figure.canvas.GetTopLevelParent(), self._get_help_entries())

@backend_tools._register_tool_class(_FigureCanvasWxBase)
class ToolCopyToClipboardWx(backend_tools.ToolCopyToClipboardBase):

    def trigger(self, *args, **kwargs):
        if not self.canvas._isDrawn:
            self.canvas.draw()
        if not self.canvas.bitmap.IsOk() or not wx.TheClipboard.Open():
            return
        try:
            wx.TheClipboard.SetData(wx.BitmapDataObject(self.canvas.bitmap))
        finally:
            wx.TheClipboard.Close()
FigureManagerWx._toolbar2_class = NavigationToolbar2Wx
FigureManagerWx._toolmanager_toolbar_class = ToolbarWx

@_Backend.export
class _BackendWx(_Backend):
    FigureCanvas = FigureCanvasWx
    FigureManager = FigureManagerWx
    mainloop = FigureManagerWx.start_main_loop

# File: matplotlib-main/lib/matplotlib/backends/backend_wxagg.py
import wx
from .backend_agg import FigureCanvasAgg
from .backend_wx import _BackendWx, _FigureCanvasWxBase
from .backend_wx import NavigationToolbar2Wx as NavigationToolbar2WxAgg

class FigureCanvasWxAgg(FigureCanvasAgg, _FigureCanvasWxBase):

    def draw(self, drawDC=None):
        FigureCanvasAgg.draw(self)
        self.bitmap = self._create_bitmap()
        self._isDrawn = True
        self.gui_repaint(drawDC=drawDC)

    def blit(self, bbox=None):
        bitmap = self._create_bitmap()
        if bbox is None:
            self.bitmap = bitmap
        else:
            srcDC = wx.MemoryDC(bitmap)
            destDC = wx.MemoryDC(self.bitmap)
            x = int(bbox.x0)
            y = int(self.bitmap.GetHeight() - bbox.y1)
            destDC.Blit(x, y, int(bbox.width), int(bbox.height), srcDC, x, y)
            destDC.SelectObject(wx.NullBitmap)
            srcDC.SelectObject(wx.NullBitmap)
        self.gui_repaint()

    def _create_bitmap(self):
        rgba = self.get_renderer().buffer_rgba()
        (h, w, _) = rgba.shape
        bitmap = wx.Bitmap.FromBufferRGBA(w, h, rgba)
        bitmap.SetScaleFactor(self.GetDPIScaleFactor())
        return bitmap

@_BackendWx.export
class _BackendWxAgg(_BackendWx):
    FigureCanvas = FigureCanvasWxAgg

# File: matplotlib-main/lib/matplotlib/backends/backend_wxcairo.py
import wx.lib.wxcairo as wxcairo
from .backend_cairo import cairo, FigureCanvasCairo
from .backend_wx import _BackendWx, _FigureCanvasWxBase
from .backend_wx import NavigationToolbar2Wx as NavigationToolbar2WxCairo

class FigureCanvasWxCairo(FigureCanvasCairo, _FigureCanvasWxBase):

    def draw(self, drawDC=None):
        size = self.figure.bbox.size.astype(int)
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, *size)
        self._renderer.set_context(cairo.Context(surface))
        self._renderer.dpi = self.figure.dpi
        self.figure.draw(self._renderer)
        self.bitmap = wxcairo.BitmapFromImageSurface(surface)
        self._isDrawn = True
        self.gui_repaint(drawDC=drawDC)

@_BackendWx.export
class _BackendWxCairo(_BackendWx):
    FigureCanvas = FigureCanvasWxCairo

# File: matplotlib-main/lib/matplotlib/backends/qt_compat.py
""""""
import operator
import os
import platform
import sys
from packaging.version import parse as parse_version
import matplotlib as mpl
from . import _QT_FORCE_QT5_BINDING
QT_API_PYQT6 = 'PyQt6'
QT_API_PYSIDE6 = 'PySide6'
QT_API_PYQT5 = 'PyQt5'
QT_API_PYSIDE2 = 'PySide2'
QT_API_ENV = os.environ.get('QT_API')
if QT_API_ENV is not None:
    QT_API_ENV = QT_API_ENV.lower()
_ETS = {'pyqt6': QT_API_PYQT6, 'pyside6': QT_API_PYSIDE6, 'pyqt5': QT_API_PYQT5, 'pyside2': QT_API_PYSIDE2}
if sys.modules.get('PyQt6.QtCore'):
    QT_API = QT_API_PYQT6
elif sys.modules.get('PySide6.QtCore'):
    QT_API = QT_API_PYSIDE6
elif sys.modules.get('PyQt5.QtCore'):
    QT_API = QT_API_PYQT5
elif sys.modules.get('PySide2.QtCore'):
    QT_API = QT_API_PYSIDE2
elif (mpl.rcParams._get_backend_or_none() or '').lower().startswith('qt5'):
    if QT_API_ENV in ['pyqt5', 'pyside2']:
        QT_API = _ETS[QT_API_ENV]
    else:
        _QT_FORCE_QT5_BINDING = True
        QT_API = None
elif QT_API_ENV is None:
    QT_API = None
elif QT_API_ENV in _ETS:
    QT_API = _ETS[QT_API_ENV]
else:
    raise RuntimeError('The environment variable QT_API has the unrecognized value {!r}; valid values are {}'.format(QT_API_ENV, ', '.join(_ETS)))

def _setup_pyqt5plus():
    global QtCore, QtGui, QtWidgets, __version__
    global _isdeleted, _to_int
    if QT_API == QT_API_PYQT6:
        from PyQt6 import QtCore, QtGui, QtWidgets, sip
        __version__ = QtCore.PYQT_VERSION_STR
        QtCore.Signal = QtCore.pyqtSignal
        QtCore.Slot = QtCore.pyqtSlot
        QtCore.Property = QtCore.pyqtProperty
        _isdeleted = sip.isdeleted
        _to_int = operator.attrgetter('value')
    elif QT_API == QT_API_PYSIDE6:
        from PySide6 import QtCore, QtGui, QtWidgets, __version__
        import shiboken6

        def _isdeleted(obj):
            return not shiboken6.isValid(obj)
        if parse_version(__version__) >= parse_version('6.4'):
            _to_int = operator.attrgetter('value')
        else:
            _to_int = int
    elif QT_API == QT_API_PYQT5:
        from PyQt5 import QtCore, QtGui, QtWidgets
        import sip
        __version__ = QtCore.PYQT_VERSION_STR
        QtCore.Signal = QtCore.pyqtSignal
        QtCore.Slot = QtCore.pyqtSlot
        QtCore.Property = QtCore.pyqtProperty
        _isdeleted = sip.isdeleted
        _to_int = int
    elif QT_API == QT_API_PYSIDE2:
        from PySide2 import QtCore, QtGui, QtWidgets, __version__
        try:
            from PySide2 import shiboken2
        except ImportError:
            import shiboken2

        def _isdeleted(obj):
            return not shiboken2.isValid(obj)
        _to_int = int
    else:
        raise AssertionError(f'Unexpected QT_API: {QT_API}')
if QT_API in [QT_API_PYQT6, QT_API_PYQT5, QT_API_PYSIDE6, QT_API_PYSIDE2]:
    _setup_pyqt5plus()
elif QT_API is None:
    if _QT_FORCE_QT5_BINDING:
        _candidates = [(_setup_pyqt5plus, QT_API_PYQT5), (_setup_pyqt5plus, QT_API_PYSIDE2)]
    else:
        _candidates = [(_setup_pyqt5plus, QT_API_PYQT6), (_setup_pyqt5plus, QT_API_PYSIDE6), (_setup_pyqt5plus, QT_API_PYQT5), (_setup_pyqt5plus, QT_API_PYSIDE2)]
    for (_setup, QT_API) in _candidates:
        try:
            _setup()
        except ImportError:
            continue
        break
    else:
        raise ImportError('Failed to import any of the following Qt binding modules: {}'.format(', '.join([QT_API for (_, QT_API) in _candidates])))
else:
    raise AssertionError(f'Unexpected QT_API: {QT_API}')
_version_info = tuple(QtCore.QLibraryInfo.version().segments())
if _version_info < (5, 12):
    raise ImportError(f'The Qt version imported is {QtCore.QLibraryInfo.version().toString()} but Matplotlib requires Qt>=5.12')
if sys.platform == 'darwin' and parse_version(platform.mac_ver()[0]) >= parse_version('10.16') and (_version_info < (5, 15, 2)):
    os.environ.setdefault('QT_MAC_WANTS_LAYER', '1')

def _exec(obj):
    obj.exec() if hasattr(obj, 'exec') else obj.exec_()

# File: matplotlib-main/lib/matplotlib/backends/qt_editor/_formlayout.py
""""""
__version__ = '1.0.10'
__license__ = __doc__
from ast import literal_eval
import copy
import datetime
import logging
from numbers import Integral, Real
from matplotlib import _api, colors as mcolors
from matplotlib.backends.qt_compat import _to_int, QtGui, QtWidgets, QtCore
_log = logging.getLogger(__name__)
BLACKLIST = {'title', 'label'}

class ColorButton(QtWidgets.QPushButton):
    colorChanged = QtCore.Signal(QtGui.QColor)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.setFixedSize(20, 20)
        self.setIconSize(QtCore.QSize(12, 12))
        self.clicked.connect(self.choose_color)
        self._color = QtGui.QColor()

    def choose_color(self):
        color = QtWidgets.QColorDialog.getColor(self._color, self.parentWidget(), '', QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
        if color.isValid():
            self.set_color(color)

    def get_color(self):
        return self._color

    @QtCore.Slot(QtGui.QColor)
    def set_color(self, color):
        if color != self._color:
            self._color = color
            self.colorChanged.emit(self._color)
            pixmap = QtGui.QPixmap(self.iconSize())
            pixmap.fill(color)
            self.setIcon(QtGui.QIcon(pixmap))
    color = QtCore.Property(QtGui.QColor, get_color, set_color)

def to_qcolor(color):
    qcolor = QtGui.QColor()
    try:
        rgba = mcolors.to_rgba(color)
    except ValueError:
        _api.warn_external(f'Ignoring invalid color {color!r}')
        return qcolor
    qcolor.setRgbF(*rgba)
    return qcolor

class ColorLayout(QtWidgets.QHBoxLayout):

    def __init__(self, color, parent=None):
        super().__init__()
        assert isinstance(color, QtGui.QColor)
        self.lineedit = QtWidgets.QLineEdit(mcolors.to_hex(color.getRgbF(), keep_alpha=True), parent)
        self.lineedit.editingFinished.connect(self.update_color)
        self.addWidget(self.lineedit)
        self.colorbtn = ColorButton(parent)
        self.colorbtn.color = color
        self.colorbtn.colorChanged.connect(self.update_text)
        self.addWidget(self.colorbtn)

    def update_color(self):
        color = self.text()
        qcolor = to_qcolor(color)
        self.colorbtn.color = qcolor

    def update_text(self, color):
        self.lineedit.setText(mcolors.to_hex(color.getRgbF(), keep_alpha=True))

    def text(self):
        return self.lineedit.text()

def font_is_installed(font):
    return [fam for fam in QtGui.QFontDatabase().families() if str(fam) == font]

def tuple_to_qfont(tup):
    if not (isinstance(tup, tuple) and len(tup) == 4 and font_is_installed(tup[0]) and isinstance(tup[1], Integral) and isinstance(tup[2], bool) and isinstance(tup[3], bool)):
        return None
    font = QtGui.QFont()
    (family, size, italic, bold) = tup
    font.setFamily(family)
    font.setPointSize(size)
    font.setItalic(italic)
    font.setBold(bold)
    return font

def qfont_to_tuple(font):
    return (str(font.family()), int(font.pointSize()), font.italic(), font.bold())

class FontLayout(QtWidgets.QGridLayout):

    def __init__(self, value, parent=None):
        super().__init__()
        font = tuple_to_qfont(value)
        assert font is not None
        self.family = QtWidgets.QFontComboBox(parent)
        self.family.setCurrentFont(font)
        self.addWidget(self.family, 0, 0, 1, -1)
        self.size = QtWidgets.QComboBox(parent)
        self.size.setEditable(True)
        sizelist = [*range(6, 12), *range(12, 30, 2), 36, 48, 72]
        size = font.pointSize()
        if size not in sizelist:
            sizelist.append(size)
            sizelist.sort()
        self.size.addItems([str(s) for s in sizelist])
        self.size.setCurrentIndex(sizelist.index(size))
        self.addWidget(self.size, 1, 0)
        self.italic = QtWidgets.QCheckBox(self.tr('Italic'), parent)
        self.italic.setChecked(font.italic())
        self.addWidget(self.italic, 1, 1)
        self.bold = QtWidgets.QCheckBox(self.tr('Bold'), parent)
        self.bold.setChecked(font.bold())
        self.addWidget(self.bold, 1, 2)

    def get_font(self):
        font = self.family.currentFont()
        font.setItalic(self.italic.isChecked())
        font.setBold(self.bold.isChecked())
        font.setPointSize(int(self.size.currentText()))
        return qfont_to_tuple(font)

def is_edit_valid(edit):
    text = edit.text()
    state = edit.validator().validate(text, 0)[0]
    return state == QtGui.QDoubleValidator.State.Acceptable

class FormWidget(QtWidgets.QWidget):
    update_buttons = QtCore.Signal()

    def __init__(self, data, comment='', with_margin=False, parent=None):
        super().__init__(parent)
        self.data = copy.deepcopy(data)
        self.widgets = []
        self.formlayout = QtWidgets.QFormLayout(self)
        if not with_margin:
            self.formlayout.setContentsMargins(0, 0, 0, 0)
        if comment:
            self.formlayout.addRow(QtWidgets.QLabel(comment))
            self.formlayout.addRow(QtWidgets.QLabel(' '))

    def get_dialog(self):
        dialog = self.parent()
        while not isinstance(dialog, QtWidgets.QDialog):
            dialog = dialog.parent()
        return dialog

    def setup(self):
        for (label, value) in self.data:
            if label is None and value is None:
                self.formlayout.addRow(QtWidgets.QLabel(' '), QtWidgets.QLabel(' '))
                self.widgets.append(None)
                continue
            elif label is None:
                self.formlayout.addRow(QtWidgets.QLabel(value))
                self.widgets.append(None)
                continue
            elif tuple_to_qfont(value) is not None:
                field = FontLayout(value, self)
            elif label.lower() not in BLACKLIST and mcolors.is_color_like(value):
                field = ColorLayout(to_qcolor(value), self)
            elif isinstance(value, str):
                field = QtWidgets.QLineEdit(value, self)
            elif isinstance(value, (list, tuple)):
                if isinstance(value, tuple):
                    value = list(value)
                selindex = value.pop(0)
                field = QtWidgets.QComboBox(self)
                if isinstance(value[0], (list, tuple)):
                    keys = [key for (key, _val) in value]
                    value = [val for (_key, val) in value]
                else:
                    keys = value
                field.addItems(value)
                if selindex in value:
                    selindex = value.index(selindex)
                elif selindex in keys:
                    selindex = keys.index(selindex)
                elif not isinstance(selindex, Integral):
                    _log.warning("index '%s' is invalid (label: %s, value: %s)", selindex, label, value)
                    selindex = 0
                field.setCurrentIndex(selindex)
            elif isinstance(value, bool):
                field = QtWidgets.QCheckBox(self)
                field.setChecked(value)
            elif isinstance(value, Integral):
                field = QtWidgets.QSpinBox(self)
                field.setRange(-10 ** 9, 10 ** 9)
                field.setValue(value)
            elif isinstance(value, Real):
                field = QtWidgets.QLineEdit(repr(value), self)
                field.setCursorPosition(0)
                field.setValidator(QtGui.QDoubleValidator(field))
                field.validator().setLocale(QtCore.QLocale('C'))
                dialog = self.get_dialog()
                dialog.register_float_field(field)
                field.textChanged.connect(lambda text: dialog.update_buttons())
            elif isinstance(value, datetime.datetime):
                field = QtWidgets.QDateTimeEdit(self)
                field.setDateTime(value)
            elif isinstance(value, datetime.date):
                field = QtWidgets.QDateEdit(self)
                field.setDate(value)
            else:
                field = QtWidgets.QLineEdit(repr(value), self)
            self.formlayout.addRow(label, field)
            self.widgets.append(field)

    def get(self):
        valuelist = []
        for (index, (label, value)) in enumerate(self.data):
            field = self.widgets[index]
            if label is None:
                continue
            elif tuple_to_qfont(value) is not None:
                value = field.get_font()
            elif isinstance(value, str) or mcolors.is_color_like(value):
                value = str(field.text())
            elif isinstance(value, (list, tuple)):
                index = int(field.currentIndex())
                if isinstance(value[0], (list, tuple)):
                    value = value[index][0]
                else:
                    value = value[index]
            elif isinstance(value, bool):
                value = field.isChecked()
            elif isinstance(value, Integral):
                value = int(field.value())
            elif isinstance(value, Real):
                value = float(str(field.text()))
            elif isinstance(value, datetime.datetime):
                datetime_ = field.dateTime()
                if hasattr(datetime_, 'toPyDateTime'):
                    value = datetime_.toPyDateTime()
                else:
                    value = datetime_.toPython()
            elif isinstance(value, datetime.date):
                date_ = field.date()
                if hasattr(date_, 'toPyDate'):
                    value = date_.toPyDate()
                else:
                    value = date_.toPython()
            else:
                value = literal_eval(str(field.text()))
            valuelist.append(value)
        return valuelist

class FormComboWidget(QtWidgets.QWidget):
    update_buttons = QtCore.Signal()

    def __init__(self, datalist, comment='', parent=None):
        super().__init__(parent)
        layout = QtWidgets.QVBoxLayout()
        self.setLayout(layout)
        self.combobox = QtWidgets.QComboBox()
        layout.addWidget(self.combobox)
        self.stackwidget = QtWidgets.QStackedWidget(self)
        layout.addWidget(self.stackwidget)
        self.combobox.currentIndexChanged.connect(self.stackwidget.setCurrentIndex)
        self.widgetlist = []
        for (data, title, comment) in datalist:
            self.combobox.addItem(title)
            widget = FormWidget(data, comment=comment, parent=self)
            self.stackwidget.addWidget(widget)
            self.widgetlist.append(widget)

    def setup(self):
        for widget in self.widgetlist:
            widget.setup()

    def get(self):
        return [widget.get() for widget in self.widgetlist]

class FormTabWidget(QtWidgets.QWidget):
    update_buttons = QtCore.Signal()

    def __init__(self, datalist, comment='', parent=None):
        super().__init__(parent)
        layout = QtWidgets.QVBoxLayout()
        self.tabwidget = QtWidgets.QTabWidget()
        layout.addWidget(self.tabwidget)
        layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(layout)
        self.widgetlist = []
        for (data, title, comment) in datalist:
            if len(data[0]) == 3:
                widget = FormComboWidget(data, comment=comment, parent=self)
            else:
                widget = FormWidget(data, with_margin=True, comment=comment, parent=self)
            index = self.tabwidget.addTab(widget, title)
            self.tabwidget.setTabToolTip(index, comment)
            self.widgetlist.append(widget)

    def setup(self):
        for widget in self.widgetlist:
            widget.setup()

    def get(self):
        return [widget.get() for widget in self.widgetlist]

class FormDialog(QtWidgets.QDialog):

    def __init__(self, data, title='', comment='', icon=None, parent=None, apply=None):
        super().__init__(parent)
        self.apply_callback = apply
        if isinstance(data[0][0], (list, tuple)):
            self.formwidget = FormTabWidget(data, comment=comment, parent=self)
        elif len(data[0]) == 3:
            self.formwidget = FormComboWidget(data, comment=comment, parent=self)
        else:
            self.formwidget = FormWidget(data, comment=comment, parent=self)
        layout = QtWidgets.QVBoxLayout()
        layout.addWidget(self.formwidget)
        self.float_fields = []
        self.formwidget.setup()
        self.bbox = bbox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.StandardButton(_to_int(QtWidgets.QDialogButtonBox.StandardButton.Ok) | _to_int(QtWidgets.QDialogButtonBox.StandardButton.Cancel)))
        self.formwidget.update_buttons.connect(self.update_buttons)
        if self.apply_callback is not None:
            apply_btn = bbox.addButton(QtWidgets.QDialogButtonBox.StandardButton.Apply)
            apply_btn.clicked.connect(self.apply)
        bbox.accepted.connect(self.accept)
        bbox.rejected.connect(self.reject)
        layout.addWidget(bbox)
        self.setLayout(layout)
        self.setWindowTitle(title)
        if not isinstance(icon, QtGui.QIcon):
            icon = QtWidgets.QWidget().style().standardIcon(QtWidgets.QStyle.SP_MessageBoxQuestion)
        self.setWindowIcon(icon)

    def register_float_field(self, field):
        self.float_fields.append(field)

    def update_buttons(self):
        valid = True
        for field in self.float_fields:
            if not is_edit_valid(field):
                valid = False
        for btn_type in ['Ok', 'Apply']:
            btn = self.bbox.button(getattr(QtWidgets.QDialogButtonBox.StandardButton, btn_type))
            if btn is not None:
                btn.setEnabled(valid)

    def accept(self):
        self.data = self.formwidget.get()
        self.apply_callback(self.data)
        super().accept()

    def reject(self):
        self.data = None
        super().reject()

    def apply(self):
        self.apply_callback(self.formwidget.get())

    def get(self):
        return self.data

def fedit(data, title='', comment='', icon=None, parent=None, apply=None):
    if QtWidgets.QApplication.startingUp():
        _app = QtWidgets.QApplication([])
    dialog = FormDialog(data, title, comment, icon, parent, apply)
    if parent is not None:
        if hasattr(parent, '_fedit_dialog'):
            parent._fedit_dialog.close()
        parent._fedit_dialog = dialog
    dialog.show()
if __name__ == '__main__':
    _app = QtWidgets.QApplication([])

    def create_datalist_example():
        return [('str', 'this is a string'), ('list', [0, '1', '3', '4']), ('list2', ['--', ('none', 'None'), ('--', 'Dashed'), ('-.', 'DashDot'), ('-', 'Solid'), ('steps', 'Steps'), (':', 'Dotted')]), ('float', 1.2), (None, 'Other:'), ('int', 12), ('font', ('Arial', 10, False, True)), ('color', '#123409'), ('bool', True), ('date', datetime.date(2010, 10, 10)), ('datetime', datetime.datetime(2010, 10, 10))]

    def create_datagroup_example():
        datalist = create_datalist_example()
        return ((datalist, 'Category 1', 'Category 1 comment'), (datalist, 'Category 2', 'Category 2 comment'), (datalist, 'Category 3', 'Category 3 comment'))
    datalist = create_datalist_example()

    def apply_test(data):
        print('data:', data)
    fedit(datalist, title='Example', comment='This is just an <b>example</b>.', apply=apply_test)
    _app.exec()
    datagroup = create_datagroup_example()
    fedit(datagroup, 'Global title', apply=apply_test)
    _app.exec()
    datalist = create_datalist_example()
    datagroup = create_datagroup_example()
    fedit(((datagroup, 'Title 1', 'Tab 1 comment'), (datalist, 'Title 2', 'Tab 2 comment'), (datalist, 'Title 3', 'Tab 3 comment')), 'Global title', apply=apply_test)
    _app.exec()

# File: matplotlib-main/lib/matplotlib/backends/qt_editor/figureoptions.py
""""""
from itertools import chain
from matplotlib import cbook, cm, colors as mcolors, markers, image as mimage
from matplotlib.backends.qt_compat import QtGui
from matplotlib.backends.qt_editor import _formlayout
from matplotlib.dates import DateConverter, num2date
LINESTYLES = {'-': 'Solid', '--': 'Dashed', '-.': 'DashDot', ':': 'Dotted', 'None': 'None'}
DRAWSTYLES = {'default': 'Default', 'steps-pre': 'Steps (Pre)', 'steps': 'Steps (Pre)', 'steps-mid': 'Steps (Mid)', 'steps-post': 'Steps (Post)'}
MARKERS = markers.MarkerStyle.markers

def figure_edit(axes, parent=None):
    sep = (None, None)

    def convert_limits(lim, converter):
        if isinstance(converter, DateConverter):
            return map(num2date, lim)
        return map(float, lim)
    axis_map = axes._axis_map
    axis_limits = {name: tuple(convert_limits(getattr(axes, f'get_{name}lim')(), axis.converter)) for (name, axis) in axis_map.items()}
    general = [('Title', axes.get_title()), sep, *chain.from_iterable([((None, f'<b>{name.title()}-Axis</b>'), ('Min', axis_limits[name][0]), ('Max', axis_limits[name][1]), ('Label', axis.get_label().get_text()), ('Scale', [axis.get_scale(), 'linear', 'log', 'symlog', 'logit']), sep) for (name, axis) in axis_map.items()]), ('(Re-)Generate automatic legend', False)]
    axis_converter = {name: axis.converter for (name, axis) in axis_map.items()}
    axis_units = {name: axis.get_units() for (name, axis) in axis_map.items()}
    labeled_lines = []
    for line in axes.get_lines():
        label = line.get_label()
        if label == '_nolegend_':
            continue
        labeled_lines.append((label, line))
    curves = []

    def prepare_data(d, init):
        if init not in d:
            d = {**d, init: str(init)}
        name2short = {name: short for (short, name) in d.items()}
        short2name = {short: name for (name, short) in name2short.items()}
        canonical_init = name2short[d[init]]
        return [canonical_init] + sorted(short2name.items(), key=lambda short_and_name: short_and_name[1])
    for (label, line) in labeled_lines:
        color = mcolors.to_hex(mcolors.to_rgba(line.get_color(), line.get_alpha()), keep_alpha=True)
        ec = mcolors.to_hex(mcolors.to_rgba(line.get_markeredgecolor(), line.get_alpha()), keep_alpha=True)
        fc = mcolors.to_hex(mcolors.to_rgba(line.get_markerfacecolor(), line.get_alpha()), keep_alpha=True)
        curvedata = [('Label', label), sep, (None, '<b>Line</b>'), ('Line style', prepare_data(LINESTYLES, line.get_linestyle())), ('Draw style', prepare_data(DRAWSTYLES, line.get_drawstyle())), ('Width', line.get_linewidth()), ('Color (RGBA)', color), sep, (None, '<b>Marker</b>'), ('Style', prepare_data(MARKERS, line.get_marker())), ('Size', line.get_markersize()), ('Face color (RGBA)', fc), ('Edge color (RGBA)', ec)]
        curves.append([curvedata, label, ''])
    has_curve = bool(curves)
    labeled_mappables = []
    for mappable in [*axes.images, *axes.collections]:
        label = mappable.get_label()
        if label == '_nolegend_' or mappable.get_array() is None:
            continue
        labeled_mappables.append((label, mappable))
    mappables = []
    cmaps = [(cmap, name) for (name, cmap) in sorted(cm._colormaps.items())]
    for (label, mappable) in labeled_mappables:
        cmap = mappable.get_cmap()
        if cmap not in cm._colormaps.values():
            cmaps = [(cmap, cmap.name), *cmaps]
        (low, high) = mappable.get_clim()
        mappabledata = [('Label', label), ('Colormap', [cmap.name] + cmaps), ('Min. value', low), ('Max. value', high)]
        if hasattr(mappable, 'get_interpolation'):
            interpolations = [(name, name) for name in sorted(mimage.interpolations_names)]
            mappabledata.append(('Interpolation', [mappable.get_interpolation(), *interpolations]))
            interpolation_stages = ['data', 'rgba', 'auto']
            mappabledata.append(('Interpolation stage', [mappable.get_interpolation_stage(), *interpolation_stages]))
        mappables.append([mappabledata, label, ''])
    has_sm = bool(mappables)
    datalist = [(general, 'Axes', '')]
    if curves:
        datalist.append((curves, 'Curves', ''))
    if mappables:
        datalist.append((mappables, 'Images, etc.', ''))

    def apply_callback(data):
        orig_limits = {name: getattr(axes, f'get_{name}lim')() for name in axis_map}
        general = data.pop(0)
        curves = data.pop(0) if has_curve else []
        mappables = data.pop(0) if has_sm else []
        if data:
            raise ValueError('Unexpected field')
        title = general.pop(0)
        axes.set_title(title)
        generate_legend = general.pop()
        for (i, (name, axis)) in enumerate(axis_map.items()):
            axis_min = general[4 * i]
            axis_max = general[4 * i + 1]
            axis_label = general[4 * i + 2]
            axis_scale = general[4 * i + 3]
            if axis.get_scale() != axis_scale:
                getattr(axes, f'set_{name}scale')(axis_scale)
            axis._set_lim(axis_min, axis_max, auto=False)
            axis.set_label_text(axis_label)
            axis.converter = axis_converter[name]
            axis.set_units(axis_units[name])
        for (index, curve) in enumerate(curves):
            line = labeled_lines[index][1]
            (label, linestyle, drawstyle, linewidth, color, marker, markersize, markerfacecolor, markeredgecolor) = curve
            line.set_label(label)
            line.set_linestyle(linestyle)
            line.set_drawstyle(drawstyle)
            line.set_linewidth(linewidth)
            rgba = mcolors.to_rgba(color)
            line.set_alpha(None)
            line.set_color(rgba)
            if marker != 'none':
                line.set_marker(marker)
                line.set_markersize(markersize)
                line.set_markerfacecolor(markerfacecolor)
                line.set_markeredgecolor(markeredgecolor)
        for (index, mappable_settings) in enumerate(mappables):
            mappable = labeled_mappables[index][1]
            if len(mappable_settings) == 6:
                (label, cmap, low, high, interpolation, interpolation_stage) = mappable_settings
                mappable.set_interpolation(interpolation)
                mappable.set_interpolation_stage(interpolation_stage)
            elif len(mappable_settings) == 4:
                (label, cmap, low, high) = mappable_settings
            mappable.set_label(label)
            mappable.set_cmap(cmap)
            mappable.set_clim(*sorted([low, high]))
        if generate_legend:
            draggable = None
            ncols = 1
            if axes.legend_ is not None:
                old_legend = axes.get_legend()
                draggable = old_legend._draggable is not None
                ncols = old_legend._ncols
            new_legend = axes.legend(ncols=ncols)
            if new_legend:
                new_legend.set_draggable(draggable)
        figure = axes.get_figure()
        figure.canvas.draw()
        for name in axis_map:
            if getattr(axes, f'get_{name}lim')() != orig_limits[name]:
                figure.canvas.toolbar.push_current()
                break
    _formlayout.fedit(datalist, title='Figure options', parent=parent, icon=QtGui.QIcon(str(cbook._get_data_path('images', 'qt4_editor_options.svg'))), apply=apply_callback)

# File: matplotlib-main/lib/matplotlib/backends/registry.py
from enum import Enum
import importlib

class BackendFilter(Enum):
    INTERACTIVE = 0
    NON_INTERACTIVE = 1

class BackendRegistry:
    _BUILTIN_BACKEND_TO_GUI_FRAMEWORK = {'gtk3agg': 'gtk3', 'gtk3cairo': 'gtk3', 'gtk4agg': 'gtk4', 'gtk4cairo': 'gtk4', 'macosx': 'macosx', 'nbagg': 'nbagg', 'notebook': 'nbagg', 'qtagg': 'qt', 'qtcairo': 'qt', 'qt5agg': 'qt5', 'qt5cairo': 'qt5', 'tkagg': 'tk', 'tkcairo': 'tk', 'webagg': 'webagg', 'wx': 'wx', 'wxagg': 'wx', 'wxcairo': 'wx', 'agg': 'headless', 'cairo': 'headless', 'pdf': 'headless', 'pgf': 'headless', 'ps': 'headless', 'svg': 'headless', 'template': 'headless'}
    _GUI_FRAMEWORK_TO_BACKEND = {'gtk3': 'gtk3agg', 'gtk4': 'gtk4agg', 'headless': 'agg', 'macosx': 'macosx', 'qt': 'qtagg', 'qt5': 'qt5agg', 'qt6': 'qtagg', 'tk': 'tkagg', 'wx': 'wxagg'}

    def __init__(self):
        self._loaded_entry_points = False
        self._backend_to_gui_framework = {}
        self._name_to_module = {'notebook': 'nbagg'}

    def _backend_module_name(self, backend):
        if backend.startswith('module://'):
            return backend[9:]
        backend = backend.lower()
        backend = self._name_to_module.get(backend, backend)
        return backend[9:] if backend.startswith('module://') else f'matplotlib.backends.backend_{backend}'

    def _clear(self):
        self.__init__()

    def _ensure_entry_points_loaded(self):
        if not self._loaded_entry_points:
            entries = self._read_entry_points()
            self._validate_and_store_entry_points(entries)
            self._loaded_entry_points = True

    def _get_gui_framework_by_loading(self, backend):
        module = self.load_backend_module(backend)
        canvas_class = module.FigureCanvas
        return canvas_class.required_interactive_framework or 'headless'

    def _read_entry_points(self):
        import importlib.metadata as im
        entry_points = im.entry_points(group='matplotlib.backend')
        entries = [(entry.name, entry.value) for entry in entry_points]

        def backward_compatible_entry_points(entries, module_name, threshold_version, names, target):
            from matplotlib import _parse_to_version_info
            try:
                module_version = im.version(module_name)
                if _parse_to_version_info(module_version) < threshold_version:
                    for name in names:
                        entries.append((name, target))
            except im.PackageNotFoundError:
                pass
        names = [entry[0] for entry in entries]
        if 'inline' not in names:
            backward_compatible_entry_points(entries, 'matplotlib_inline', (0, 1, 7), ['inline'], 'matplotlib_inline.backend_inline')
        if 'ipympl' not in names:
            backward_compatible_entry_points(entries, 'ipympl', (0, 9, 4), ['ipympl', 'widget'], 'ipympl.backend_nbagg')
        return entries

    def _validate_and_store_entry_points(self, entries):
        for (name, module) in set(entries):
            name = name.lower()
            if name.startswith('module://'):
                raise RuntimeError(f"Entry point name '{name}' cannot start with 'module://'")
            if name in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK:
                raise RuntimeError(f"Entry point name '{name}' is a built-in backend")
            if name in self._backend_to_gui_framework:
                raise RuntimeError(f"Entry point name '{name}' duplicated")
            self._name_to_module[name] = 'module://' + module
            self._backend_to_gui_framework[name] = 'unknown'

    def backend_for_gui_framework(self, framework):
        return self._GUI_FRAMEWORK_TO_BACKEND.get(framework.lower())

    def is_valid_backend(self, backend):
        if not backend.startswith('module://'):
            backend = backend.lower()
        backwards_compat = {'module://ipympl.backend_nbagg': 'widget', 'module://matplotlib_inline.backend_inline': 'inline'}
        backend = backwards_compat.get(backend, backend)
        if backend in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK or backend in self._backend_to_gui_framework:
            return True
        if backend.startswith('module://'):
            self._backend_to_gui_framework[backend] = 'unknown'
            return True
        self._ensure_entry_points_loaded()
        if backend in self._backend_to_gui_framework:
            return True
        return False

    def list_all(self):
        self._ensure_entry_points_loaded()
        return [*self.list_builtin(), *self._backend_to_gui_framework]

    def list_builtin(self, filter_=None):
        if filter_ == BackendFilter.INTERACTIVE:
            return [k for (k, v) in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.items() if v != 'headless']
        elif filter_ == BackendFilter.NON_INTERACTIVE:
            return [k for (k, v) in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.items() if v == 'headless']
        return [*self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK]

    def list_gui_frameworks(self):
        return [k for k in self._GUI_FRAMEWORK_TO_BACKEND if k != 'headless']

    def load_backend_module(self, backend):
        module_name = self._backend_module_name(backend)
        return importlib.import_module(module_name)

    def resolve_backend(self, backend):
        if isinstance(backend, str):
            if not backend.startswith('module://'):
                backend = backend.lower()
        else:
            from matplotlib import get_backend
            backend = get_backend()
        gui = self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.get(backend) or self._backend_to_gui_framework.get(backend)
        if gui is None and isinstance(backend, str) and backend.startswith('module://'):
            gui = 'unknown'
        if gui is None and (not self._loaded_entry_points):
            self._ensure_entry_points_loaded()
            gui = self._backend_to_gui_framework.get(backend)
        if gui == 'unknown':
            gui = self._get_gui_framework_by_loading(backend)
            self._backend_to_gui_framework[backend] = gui
        if gui is None:
            raise RuntimeError(f"'{backend}' is not a recognised backend name")
        return (backend, gui if gui != 'headless' else None)

    def resolve_gui_or_backend(self, gui_or_backend):
        if not gui_or_backend.startswith('module://'):
            gui_or_backend = gui_or_backend.lower()
        backend = self.backend_for_gui_framework(gui_or_backend)
        if backend is not None:
            return (backend, gui_or_backend if gui_or_backend != 'headless' else None)
        try:
            return self.resolve_backend(gui_or_backend)
        except Exception:
            raise RuntimeError(f"'{gui_or_backend} is not a recognised GUI loop or backend name")
backend_registry = BackendRegistry()

# File: matplotlib-main/lib/matplotlib/bezier.py
""""""
from functools import lru_cache
import math
import warnings
import numpy as np
from matplotlib import _api

@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

def get_intersection(cx1, cy1, cos_t1, sin_t1, cx2, cy2, cos_t2, sin_t2):
    line1_rhs = sin_t1 * cx1 - cos_t1 * cy1
    line2_rhs = sin_t2 * cx2 - cos_t2 * cy2
    (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.')
    (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):
    if length == 0.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)

def _de_casteljau1(beta, t):
    next_beta = beta[:-1] * (1 - t) + beta[1:] * t
    return next_beta

def split_de_casteljau(beta, t):
    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.0, t1=1.0, tolerance=0.01):
    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:
        if np.hypot(start[0] - end[0], start[1] - end[1]) < tolerance:
            return (t0, t1)
        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:
                return (t0, t1)
            end = middle
        else:
            t0 = middle_t
            if start == middle:
                return (t0, t1)
            start = middle
            start_inside = middle_inside

class BezierSegment:

    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):
        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):
        return tuple(self(t))

    @property
    def control_points(self):
        return self._cpoints

    @property
    def dimension(self):
        return self._d

    @property
    def degree(self):
        return self._N - 1

    @property
    def polynomial_coefficients(self):
        n = self.degree
        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, :]
        prefactor = (-1) ** (i + j) * _comb(j, i)
        return _comb(n, j) * prefactor @ P

    def axis_aligned_extrema(self):
        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):
    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.0)
    return (_left, _right)

def split_path_inout(path, inside, tolerance=0.01, reorder_inout=False):
    from .path import Path
    path_iter = path.iter_segments()
    (ctl_points, command) = next(path_iter)
    begin_inside = inside(ctl_points[-2:])
    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):
    r2 = r ** 2

    def _f(xy):
        (x, y) = xy
        return (x - cx) ** 2 + (y - cy) ** 2 < r2
    return _f

def get_cos_sin(x0, y0, x1, y1):
    (dx, dy) = (x1 - x0, y1 - y0)
    d = (dx * dx + dy * dy) ** 0.5
    if d == 0:
        return (0.0, 0.0)
    return (dx / d, dy / d)

def check_if_parallel(dx1, dy1, dx2, dy2, tolerance=1e-05):
    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):
    (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:
        (cos_t1, sin_t1) = get_cos_sin(c1x, c1y, cmx, cmy)
        (cos_t2, sin_t2) = get_cos_sin(cmx, cmy, c2x, c2y)
    (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)
    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:
        (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))
    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):
    cmx = 0.5 * (4 * mmx - (c1x + c2x))
    cmy = 0.5 * (4 * mmy - (c1y + c2y))
    return [(c1x, c1y), (cmx, cmy), (c2x, c2y)]

def make_wedged_bezier2(bezier2, width, w1=1.0, wm=0.5, w2=0.0):
    (c1x, c1y) = bezier2[0]
    (cmx, cmy) = bezier2[1]
    (c3x, c3y) = bezier2[2]
    (cos_t1, sin_t1) = get_cos_sin(c1x, c1y, cmx, cmy)
    (cos_t2, sin_t2) = get_cos_sin(cmx, cmy, c3x, c3y)
    (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)
    (c12x, c12y) = ((c1x + cmx) * 0.5, (c1y + cmy) * 0.5)
    (c23x, c23y) = ((cmx + c3x) * 0.5, (cmy + c3y) * 0.5)
    (c123x, c123y) = ((c12x + c23x) * 0.5, (c12y + c23y) * 0.5)
    (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)

# File: matplotlib-main/lib/matplotlib/category.py
""""""
from collections import OrderedDict
import dateutil.parser
import itertools
import logging
import numpy as np
from matplotlib import _api, ticker, units
_log = logging.getLogger(__name__)

class StrCategoryConverter(units.ConversionInterface):

    @staticmethod
    def convert(value, unit, axis):
        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)
        values = np.atleast_1d(np.array(value, dtype=object))
        unit.update(values)
        return np.vectorize(unit._mapping.__getitem__, otypes=[float])(values)

    @staticmethod
    def axisinfo(unit, axis):
        StrCategoryConverter._validate_unit(unit)
        majloc = StrCategoryLocator(unit._mapping)
        majfmt = StrCategoryFormatter(unit._mapping)
        return units.AxisInfo(majloc=majloc, majfmt=majfmt)

    @staticmethod
    def default_units(data, axis):
        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):

    def __init__(self, units_mapping):
        self._units = units_mapping

    def __call__(self):
        return list(self._units.values())

    def tick_values(self, vmin, vmax):
        return self()

class StrCategoryFormatter(ticker.Formatter):

    def __init__(self, units_mapping):
        self._units = units_mapping

    def __call__(self, x, pos=None):
        return self.format_ticks([x])[0]

    def format_ticks(self, values):
        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):
        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):
        self._mapping = OrderedDict()
        self._counter = itertools.count()
        if data is not None:
            self.update(data)

    @staticmethod
    def _str_is_convertible(val):
        try:
            float(val)
        except ValueError:
            try:
                dateutil.parser.parse(val)
            except (ValueError, TypeError):
                return False
        return True

    def update(self, data):
        data = np.atleast_1d(np.array(data, dtype=object))
        convertible = True
        for val in OrderedDict.fromkeys(data):
            _api.check_isinstance((str, bytes), value=val)
            if convertible:
                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.')
units.registry[str] = StrCategoryConverter()
units.registry[np.str_] = StrCategoryConverter()
units.registry[bytes] = StrCategoryConverter()
units.registry[np.bytes_] = StrCategoryConverter()

# File: matplotlib-main/lib/matplotlib/cbook.py
""""""
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
except ImportError:
    from numpy import VisibleDeprecationWarning
import matplotlib
from matplotlib import _api, _c_internal_utils

def _get_running_interactive_framework():
    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
        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:

    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):
    try:
        return weakref.WeakMethod(func, callback)
    except TypeError:
        return _StrongRef(func)

class CallbackRegistry:

    def __init__(self, exception_handler=_exception_printer, *, signals=None):
        self._signals = None if signals is None else list(signals)
        self.exception_handler = exception_handler
        self.callbacks = {}
        self._cid_gen = itertools.count()
        self._func_cid_map = {}
        self._pickled_cids = set()

    def __getstate__(self):
        return {**vars(self), 'callbacks': {s: {cid: proxy() for (cid, proxy) in d.items() if cid in self._pickled_cids} for (s, d) in self.callbacks.items()}, '_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, self._remove_proxy) for (cid, func) in d.items()} for (s, d) in self.callbacks.items()}
        self._func_cid_map = {s: {proxy: cid for (cid, proxy) in d.items()} for (s, d) in self.callbacks.items()}
        self._cid_gen = itertools.count(cid_count)

    def connect(self, signal, func):
        if self._signals is not None:
            _api.check_in_list(self._signals, signal=signal)
        self._func_cid_map.setdefault(signal, {})
        proxy = _weak_or_strong_ref(func, self._remove_proxy)
        if proxy in self._func_cid_map[signal]:
            return self._func_cid_map[signal][proxy]
        cid = next(self._cid_gen)
        self._func_cid_map[signal][proxy] = cid
        self.callbacks.setdefault(signal, {})
        self.callbacks[signal][cid] = proxy
        return cid

    def _connect_picklable(self, signal, func):
        cid = self.connect(signal, func)
        self._pickled_cids.add(cid)
        return cid

    def _remove_proxy(self, proxy, *, _is_finalizing=sys.is_finalizing):
        if _is_finalizing():
            return
        for (signal, proxy_to_cid) in list(self._func_cid_map.items()):
            cid = proxy_to_cid.pop(proxy, None)
            if cid is not None:
                del self.callbacks[signal][cid]
                self._pickled_cids.discard(cid)
                break
        else:
            return
        if len(self.callbacks[signal]) == 0:
            del self.callbacks[signal]
            del self._func_cid_map[signal]

    def disconnect(self, cid):
        self._pickled_cids.discard(cid)
        for (signal, cid_to_proxy) in list(self.callbacks.items()):
            proxy = cid_to_proxy.pop(cid, None)
            if proxy is not None:
                break
        else:
            return
        proxy_to_cid = self._func_cid_map[signal]
        for (current_proxy, current_cid) in list(proxy_to_cid.items()):
            if current_cid == cid:
                assert proxy is current_proxy
                del proxy_to_cid[current_proxy]
        if len(self.callbacks[signal]) == 0:
            del self.callbacks[signal]
            del self._func_cid_map[signal]

    def process(self, s, *args, **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)
                except Exception as exc:
                    if self.exception_handler is not None:
                        self.exception_handler(exc)
                    else:
                        raise

    @contextlib.contextmanager
    def blocked(self, *, signal=None):
        orig = self.callbacks
        try:
            if signal is None:
                self.callbacks = {}
            else:
                self.callbacks = {k: orig[k] for k in orig if k != signal}
            yield
        finally:
            self.callbacks = orig

class silent_list(list):

    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):
    if len(s) >= 2 and s[0] == s[-1] == '$':
        s = s[1:-1]
        for (tex, plain) in [('\\times', 'x'), ('\\mathdefault', ''), ('\\rm', ''), ('\\cal', ''), ('\\tt', ''), ('\\it', ''), ('\\', ''), ('{', ''), ('}', '')]:
            s = s.replace(tex, plain)
    return s

def _strip_comment(s):
    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

def is_writable_file_like(obj):
    return callable(getattr(obj, 'write', None))

def file_requires_unicode(x):
    try:
        x.write(b'')
    except TypeError:
        return True
    else:
        return False

def to_filehandle(fname, flag='r', return_opened=False, encoding=None):
    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'):
            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):
    (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 isinstance(val, str) or not np.iterable(val)

@_api.delete_parameter('3.8', 'np_load', alternative='open(get_sample_data(..., asfileobj=False))')
def get_sample_data(fname, asfileobj=True, *, np_load=True):
    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']:
            if np_load:
                return np.load(path)
            else:
                return path.open('rb')
        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 Path(matplotlib.get_data_path(), *args)

def flatten(seq, scalarp=is_scalar_or_string):
    for item in seq:
        if scalarp(item) or item is None:
            yield item
        else:
            yield from flatten(item, scalarp)

@_api.deprecated('3.8')
class Stack:

    def __init__(self, default=None):
        self.clear()
        self._default = default

    def __call__(self):
        if not self._elements:
            return self._default
        else:
            return self._elements[self._pos]

    def __len__(self):
        return len(self._elements)

    def __getitem__(self, ind):
        return self._elements[ind]

    def forward(self):
        self._pos = min(self._pos + 1, len(self._elements) - 1)
        return self()

    def back(self):
        if self._pos > 0:
            self._pos -= 1
        return self()

    def push(self, o):
        self._elements = self._elements[:self._pos + 1] + [o]
        self._pos = len(self._elements) - 1
        return self()

    def home(self):
        if not self._elements:
            return
        self.push(self._elements[0])
        return self()

    def empty(self):
        return len(self._elements) == 0

    def clear(self):
        self._pos = -1
        self._elements = []

    def bubble(self, o):
        if o not in self._elements:
            raise ValueError('Given element not contained in the stack')
        old_elements = self._elements.copy()
        self.clear()
        top_elements = []
        for elem in old_elements:
            if elem == o:
                top_elements.append(elem)
            else:
                self.push(elem)
        for _ in top_elements:
            self.push(o)
        return o

    def remove(self, o):
        if o not in self._elements:
            raise ValueError('Given element not contained in the stack')
        old_elements = self._elements.copy()
        self.clear()
        for elem in old_elements:
            if elem != o:
                self.push(elem)

class _Stack:

    def __init__(self):
        self._pos = -1
        self._elements = []

    def clear(self):
        self._pos = -1
        self._elements = []

    def __call__(self):
        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):
        self._pos = min(self._pos + 1, len(self._elements) - 1)
        return self()

    def back(self):
        self._pos = max(self._pos - 1, 0)
        return self()

    def push(self, o):
        self._elements[self._pos + 1:] = [o]
        self._pos = len(self._elements) - 1
        return o

    def home(self):
        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:
        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):
    import gc

    def print_path(path):
        for (i, step) in enumerate(path):
            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 referent is start:
                print_path(current_path)
            elif referent is objects or isinstance(referent, types.FrameType):
                continue
            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:

    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)

    def __getstate__(self):
        return {**vars(self), '_mapping': {k: set(v) for (k, v) in self._mapping.items()}, '_ordering': {**self._ordering}}

    def __setstate__(self, state):
        vars(self).update(state)
        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

    @_api.deprecated('3.8', alternative='none, you no longer need to clean a Grouper')
    def clean(self):

    def join(self, a, *args):
        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 self._mapping.get(a, object()) is self._mapping.get(b)

    def remove(self, a):
        self._mapping.pop(a, {a}).remove(a)
        self._ordering.pop(a, None)

    def __iter__(self):
        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):
        siblings = self._mapping.get(a, [a])
        return sorted(siblings, key=self._ordering.get)

class GrouperView:

    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 self._grouper.joined(a, b)

    def get_siblings(self, a):
        return self._grouper.get_siblings(a)

def simple_linear_interpolation(a, steps):
    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):
    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 = []
    for (i, x) in enumerate(margs):
        if seqlist[i]:
            if x.ndim > 1:
                continue
            if isinstance(x, np.ma.MaskedArray):
                masks.append(~np.ma.getmaskarray(x))
                xd = x.data
            else:
                xd = x
            try:
                mask = np.isfinite(xd)
                if isinstance(mask, np.ndarray):
                    masks.append(mask)
            except Exception:
                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):
    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)
    masks = []
    for (i, x) in enumerate(args):
        if is_scalar_or_string(x) or len(x) != nrecs:
            margs.append(x)
        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):
                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)
    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):
    masks = [k.mask for k in args if isinstance(k, np.ma.MaskedArray)]
    bcast = np.broadcast_arrays(*args, *masks)
    inputs = bcast[:len(args)]
    masks = bcast[len(args):]
    if masks:
        mask = np.logical_or.reduce(masks)
        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):

    def _bootstrap_median(data, N=5000):
        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:
            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)
    bxpstats = []
    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)):
        stats = {}
        if label is not None:
            stats['label'] = label
        whis = input_whis
        bxpstats.append(stats)
        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
        x = np.ma.asarray(x)
        x = x.data[~x.mask].ravel()
        stats['mean'] = np.mean(x)
        (q1, med, q3) = np.percentile(x, [25, 50, 75])
        stats['iqr'] = q3 - q1
        if stats['iqr'] == 0 and autorange:
            whis = (0, 100)
        (stats['cilo'], stats['cihi']) = _compute_conf_interval(x, med, stats['iqr'], bootstrap)
        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')
        wiskhi = x[x <= hival]
        if len(wiskhi) == 0 or np.max(wiskhi) < q3:
            stats['whishi'] = q3
        else:
            stats['whishi'] = np.max(wiskhi)
        wisklo = x[x >= loval]
        if len(wisklo) == 0 or np.min(wisklo) > q1:
            stats['whislo'] = q1
        else:
            stats['whislo'] = np.min(wisklo)
        stats['fliers'] = np.concatenate([x[x < stats['whislo']], x[x > stats['whishi']]])
        (stats['q1'], stats['med'], stats['q3']) = (q1, med, q3)
    return bxpstats
ls_mapper = {'-': 'solid', '--': 'dashed', '-.': 'dashdot', ':': 'dotted'}
ls_mapper_r = {v: k for (k, v) in ls_mapper.items()}

def contiguous_regions(mask):
    mask = np.asarray(mask, dtype=bool)
    if not mask.size:
        return []
    (idx,) = np.nonzero(mask[:-1] != mask[1:])
    idx += 1
    idx = idx.tolist()
    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):
    s = str(s)
    dollar_count = s.count('$') - s.count('\\$')
    even_dollars = dollar_count > 0 and dollar_count % 2 == 0
    return even_dollars

def _to_unmasked_float_array(x):
    if hasattr(x, 'mask'):
        return np.ma.asarray(x, float).filled(np.nan)
    else:
        return np.asarray(x, float)

def _check_1d(x):
    x = _unpack_to_numpy(x)
    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):
    X = _unpack_to_numpy(X)
    if isinstance(X, np.ndarray):
        X = X.T
        if len(X) == 0:
            return [[]]
        elif X.ndim == 1 and np.ndim(X[0]) == 0:
            return [X]
        elif X.ndim in [1, 2]:
            return [np.reshape(x, -1) for x in X]
        else:
            raise ValueError(f'{name} must have 2 or fewer dimensions')
    if len(X) == 0:
        return [[]]
    result = []
    is_1d = True
    for xi in X:
        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:
        return [np.reshape(result, -1)]
    else:
        return result

def violin_stats(X, method, points=100, quantiles=None):
    vpstats = []
    X = _reshape_2D(X, 'X')
    if quantiles is not None and len(quantiles) != 0:
        quantiles = _reshape_2D(quantiles, 'quantiles')
    else:
        quantiles = [[]] * len(X)
    if len(X) != len(quantiles):
        raise ValueError('List of violinplot statistics and quantiles values must have the same length')
    for (x, q) in zip(X, quantiles):
        stats = {}
        min_val = np.min(x)
        max_val = np.max(x)
        quantile_val = np.percentile(x, 100 * q)
        coords = np.linspace(min_val, max_val, points)
        stats['vals'] = method(x, coords)
        stats['coords'] = coords
        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)
        vpstats.append(stats)
    return vpstats

def pts_to_prestep(x, *args):
    steps = np.zeros((1 + len(args), max(2 * len(x) - 1, 0)))
    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):
    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):
    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]
    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):
    try:
        return (y.index.to_numpy(), y.to_numpy())
    except AttributeError:
        pass
    try:
        y = _check_1d(y)
    except (VisibleDeprecationWarning, ValueError):
        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):
    if isinstance(obj, collections.abc.Iterator):
        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):

    def safe_isfinite(val):
        if val is None:
            return False
        try:
            return math.isfinite(val)
        except (TypeError, ValueError):
            pass
        try:
            return np.isfinite(val) if np.isscalar(val) else True
        except TypeError:
            return True
    if isinstance(obj, np.flatiter):
        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):
    return list(data) if isinstance(data, collections.abc.MappingView) else data

def normalize_kwargs(kw, alias_mapping=None):
    from matplotlib.artist import Artist
    if kw is None:
        return {}
    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 = {}
    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 {k!r}, which are aliases of one another')
        canonical_to_seen[canonical] = k
        ret[canonical] = v
    return ret

@contextlib.contextmanager
def _lock_path(path):
    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:\n    {}\nThis maybe due to another process holding this lock file.  If you are sure no\nother 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'))):
    return _cached_max(reversed(artists))

def _str_equal(obj, s):
    return isinstance(obj, str) and obj == s

def _str_lower_equal(obj, s):
    return isinstance(obj, str) and obj.lower() == s

def _array_perimeter(arr):
    forward = np.s_[0:-1]
    backward = np.s_[-1:0:-1]
    return np.concatenate((arr[0, forward], arr[forward, -1], arr[-1, backward], arr[backward, 0]))

def _unfold(arr, axis, size, step):
    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):
    assert rstride > 0 and cstride > 0
    assert (x.shape[0] - 1) % rstride == 0
    assert (x.shape[1] - 1) % cstride == 0
    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):
    sentinel = object()
    origs = {}
    for attr in kwargs:
        orig = getattr(obj, attr, sentinel)
        if attr in obj.__dict__ or orig is sentinel:
            origs[attr] = orig
        else:
            cls_orig = getattr(type(obj), attr)
            if isinstance(cls_orig, property):
                origs[attr] = orig
            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)

def _premultiplied_argb32_to_unmultiplied_rgba8888(buf):
    rgba = np.take(buf, [2, 1, 0, 3] if sys.byteorder == 'little' else [1, 2, 3, 0], axis=2)
    rgb = rgba[..., :-1]
    alpha = rgba[..., -1]
    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):
    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:]
    if alpha8.min() != 255:
        np.multiply(rgb24, alpha8 / 255, out=rgb24, casting='unsafe')
    return argb32

def _get_nonzero_slices(buf):
    (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):
    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):
    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    {_pformat_subprocess(command)}\nfailed and generated the following output:\n{stdout}\nand the following error:\n{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():
    try:
        _c_internal_utils.Win32_GetCurrentProcessExplicitAppUserModelID()
    except OSError:
        _c_internal_utils.Win32_SetCurrentProcessExplicitAppUserModelID('matplotlib')

def _format_approx(number, precision):
    return f'{number:.{precision}f}'.rstrip('0').rstrip('.') or '0'

def _g_sig_digits(value, delta):
    if delta == 0:
        if value == 0:
            return 3
        delta = abs(np.spacing(value))
    return max(0, (math.floor(math.log10(abs(value))) + 1 if value else 1) - math.floor(math.log10(delta))) if math.isfinite(value) else 0

def _unikey_or_keysym_to_mplkey(unikey, keysym):
    if unikey and unikey.isprintable():
        return unikey
    key = keysym.lower()
    if key.startswith('kp_'):
        key = key[3:]
    if key.startswith('page_'):
        key = key.replace('page_', 'page')
    if key.endswith(('_l', '_r')):
        key = key[:-2]
    if sys.platform == 'darwin' and key == 'meta':
        key = 'cmd'
    key = {'return': 'enter', 'prior': 'pageup', 'next': 'pagedown'}.get(key, key)
    return key

@functools.cache
def _make_class_factory(mixin_class, fmt, attr_name=None):

    @functools.cache
    def class_factory(axes_class):
        if issubclass(axes_class, mixin_class):
            return axes_class
        base_class = axes_class

        class subcls(mixin_class, base_class):
            __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):
    factory = _make_class_factory(mixin_class, fmt, attr_name)
    cls = factory(base_class)
    return cls.__new__(cls)

def _is_torch_array(x):
    try:
        return isinstance(x, sys.modules['torch'].Tensor)
    except Exception:
        return False

def _is_jax_array(x):
    try:
        return isinstance(x, sys.modules['jax'].Array)
    except Exception:
        return False

def _is_tensorflow_array(x):
    try:
        return isinstance(x, sys.modules['tensorflow'].is_tensor(x))
    except Exception:
        return False

def _unpack_to_numpy(x):
    if isinstance(x, np.ndarray):
        return x
    if hasattr(x, 'to_numpy'):
        return x.to_numpy()
    if hasattr(x, 'values'):
        xtmp = x.values
        if isinstance(xtmp, np.ndarray):
            return xtmp
    if _is_torch_array(x) or _is_jax_array(x) or _is_tensorflow_array(x):
        xtmp = np.asarray(x)
        if isinstance(xtmp, np.ndarray):
            return xtmp
    return x

def _auto_format_str(fmt, value):
    try:
        return fmt % (value,)
    except (TypeError, ValueError):
        return fmt.format(value)

# File: matplotlib-main/lib/matplotlib/cm.py
""""""
from collections.abc import Mapping
import functools
import numpy as np
from numpy import ma
import matplotlib as mpl
from matplotlib import _api, colors, cbook, scale
from matplotlib._cm import datad
from matplotlib._cm_listed import cmaps as cmaps_listed
from matplotlib._cm_multivar import cmap_families as multivar_cmaps
from matplotlib._cm_bivar import cmaps as bivar_cmaps
_LUTSIZE = mpl.rcParams['image.lut']

def _gen_cmap_registry():
    cmap_d = {**cmaps_listed}
    for (name, spec) in datad.items():
        cmap_d[name] = colors.LinearSegmentedColormap(name, spec, _LUTSIZE) if 'red' in spec else colors.ListedColormap(spec['listed'], name) if 'listed' in spec else colors.LinearSegmentedColormap.from_list(name, spec, _LUTSIZE)
    aliases = {'grey': 'gray', 'gist_grey': 'gist_gray', 'gist_yerg': 'gist_yarg', 'Grays': 'Greys'}
    for (alias, original_name) in aliases.items():
        cmap = cmap_d[original_name].copy()
        cmap.name = alias
        cmap_d[alias] = cmap
    for cmap in list(cmap_d.values()):
        rmap = cmap.reversed()
        cmap_d[rmap.name] = rmap
    return cmap_d

class ColormapRegistry(Mapping):

    def __init__(self, cmaps):
        self._cmaps = cmaps
        self._builtin_cmaps = tuple(cmaps)

    def __getitem__(self, item):
        try:
            return self._cmaps[item].copy()
        except KeyError:
            raise KeyError(f'{item!r} is not a known colormap name') from None

    def __iter__(self):
        return iter(self._cmaps)

    def __len__(self):
        return len(self._cmaps)

    def __str__(self):
        return 'ColormapRegistry; available colormaps:\n' + ', '.join((f"'{name}'" for name in self))

    def __call__(self):
        return list(self)

    def register(self, cmap, *, name=None, force=False):
        _api.check_isinstance(colors.Colormap, cmap=cmap)
        name = name or cmap.name
        if name in self:
            if not force:
                raise ValueError(f'A colormap named "{name}" is already registered.')
            elif name in self._builtin_cmaps:
                raise ValueError(f'Re-registering the builtin cmap {name!r} is not allowed.')
            _api.warn_external(f'Overwriting the cmap {name!r} that was already in the registry.')
        self._cmaps[name] = cmap.copy()
        if self._cmaps[name].name != name:
            self._cmaps[name].name = name

    def unregister(self, name):
        if name in self._builtin_cmaps:
            raise ValueError(f'cannot unregister {name!r} which is a builtin colormap.')
        self._cmaps.pop(name, None)

    def get_cmap(self, cmap):
        if cmap is None:
            return self[mpl.rcParams['image.cmap']]
        if isinstance(cmap, colors.Colormap):
            return cmap
        if isinstance(cmap, str):
            _api.check_in_list(sorted(_colormaps), cmap=cmap)
            return self[cmap]
        raise TypeError('get_cmap expects None or an instance of a str or Colormap . ' + f'you passed {cmap!r} of type {type(cmap)}')
_colormaps = ColormapRegistry(_gen_cmap_registry())
globals().update(_colormaps)
_multivar_colormaps = ColormapRegistry(multivar_cmaps)
_bivar_colormaps = ColormapRegistry(bivar_cmaps)

@_api.deprecated('3.7', removal='3.11', alternative='``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()``')
def get_cmap(name=None, lut=None):
    if name is None:
        name = mpl.rcParams['image.cmap']
    if isinstance(name, colors.Colormap):
        return name
    _api.check_in_list(sorted(_colormaps), name=name)
    if lut is None:
        return _colormaps[name]
    else:
        return _colormaps[name].resampled(lut)

def _auto_norm_from_scale(scale_cls):
    try:
        norm = colors.make_norm_from_scale(functools.partial(scale_cls, nonpositive='mask'))(colors.Normalize)()
    except TypeError:
        norm = colors.make_norm_from_scale(scale_cls)(colors.Normalize)()
    return type(norm)

class ScalarMappable:

    def __init__(self, norm=None, cmap=None):
        self._A = None
        self._norm = None
        self.set_norm(norm)
        self.cmap = None
        self.set_cmap(cmap)
        self.colorbar = None
        self.callbacks = cbook.CallbackRegistry(signals=['changed'])

    def _scale_norm(self, norm, vmin, vmax):
        if vmin is not None or vmax is not None:
            self.set_clim(vmin, vmax)
            if isinstance(norm, colors.Normalize):
                raise ValueError('Passing a Normalize instance simultaneously with vmin/vmax is not supported.  Please pass vmin/vmax directly to the norm when creating it.')
        self.autoscale_None()

    def to_rgba(self, x, alpha=None, bytes=False, norm=True):
        try:
            if x.ndim == 3:
                if x.shape[2] == 3:
                    if alpha is None:
                        alpha = 1
                    if x.dtype == np.uint8:
                        alpha = np.uint8(alpha * 255)
                    (m, n) = x.shape[:2]
                    xx = np.empty(shape=(m, n, 4), dtype=x.dtype)
                    xx[:, :, :3] = x
                    xx[:, :, 3] = alpha
                elif x.shape[2] == 4:
                    xx = x
                else:
                    raise ValueError('Third dimension must be 3 or 4')
                if xx.dtype.kind == 'f':
                    if np.any((nans := np.isnan(x))):
                        if x.shape[2] == 4:
                            xx = xx.copy()
                        xx[np.any(nans, axis=2), :] = 0
                    if norm and (xx.max() > 1 or xx.min() < 0):
                        raise ValueError('Floating point image RGB values must be in the 0..1 range.')
                    if bytes:
                        xx = (xx * 255).astype(np.uint8)
                elif xx.dtype == np.uint8:
                    if not bytes:
                        xx = xx.astype(np.float32) / 255
                else:
                    raise ValueError('Image RGB array must be uint8 or floating point; found %s' % xx.dtype)
                if np.ma.is_masked(x):
                    xx[np.any(np.ma.getmaskarray(x), axis=2), 3] = 0
                return xx
        except AttributeError:
            pass
        x = ma.asarray(x)
        if norm:
            x = self.norm(x)
        rgba = self.cmap(x, alpha=alpha, bytes=bytes)
        return rgba

    def set_array(self, A):
        if A is None:
            self._A = None
            return
        A = cbook.safe_masked_invalid(A, copy=True)
        if not np.can_cast(A.dtype, float, 'same_kind'):
            raise TypeError(f'Image data of dtype {A.dtype} cannot be converted to float')
        self._A = A
        if not self.norm.scaled():
            self.norm.autoscale_None(A)

    def get_array(self):
        return self._A

    def get_cmap(self):
        return self.cmap

    def get_clim(self):
        return (self.norm.vmin, self.norm.vmax)

    def set_clim(self, vmin=None, vmax=None):
        if vmax is None:
            try:
                (vmin, vmax) = vmin
            except (TypeError, ValueError):
                pass
        if vmin is not None:
            self.norm.vmin = colors._sanitize_extrema(vmin)
        if vmax is not None:
            self.norm.vmax = colors._sanitize_extrema(vmax)

    def get_alpha(self):
        return 1.0

    def set_cmap(self, cmap):
        in_init = self.cmap is None
        self.cmap = _ensure_cmap(cmap)
        if not in_init:
            self.changed()

    @property
    def norm(self):
        return self._norm

    @norm.setter
    def norm(self, norm):
        _api.check_isinstance((colors.Normalize, str, None), norm=norm)
        if norm is None:
            norm = colors.Normalize()
        elif isinstance(norm, str):
            try:
                scale_cls = scale._scale_mapping[norm]
            except KeyError:
                raise ValueError(f"Invalid norm str name; the following values are supported: {', '.join(scale._scale_mapping)}") from None
            norm = _auto_norm_from_scale(scale_cls)()
        if norm is self.norm:
            return
        in_init = self.norm is None
        if not in_init:
            self.norm.callbacks.disconnect(self._id_norm)
        self._norm = norm
        self._id_norm = self.norm.callbacks.connect('changed', self.changed)
        if not in_init:
            self.changed()

    def set_norm(self, norm):
        self.norm = norm

    def autoscale(self):
        if self._A is None:
            raise TypeError('You must first set_array for mappable')
        self.norm.autoscale(self._A)

    def autoscale_None(self):
        if self._A is None:
            raise TypeError('You must first set_array for mappable')
        self.norm.autoscale_None(self._A)

    def changed(self):
        self.callbacks.process('changed', self)
        self.stale = True

    def _format_cursor_data_override(self, data):
        n = self.cmap.N
        if np.ma.getmask(data):
            return '[]'
        normed = self.norm(data)
        if np.isfinite(normed):
            if isinstance(self.norm, colors.BoundaryNorm):
                cur_idx = np.argmin(np.abs(self.norm.boundaries - data))
                neigh_idx = max(0, cur_idx - 1)
                delta = np.diff(self.norm.boundaries[neigh_idx:cur_idx + 2]).max()
            elif self.norm.vmin == self.norm.vmax:
                delta = np.abs(self.norm.vmin * 0.1)
            else:
                neighbors = self.norm.inverse((int(normed * n) + np.array([0, 1])) / n)
                delta = abs(neighbors - data).max()
            g_sig_digits = cbook._g_sig_digits(data, delta)
        else:
            g_sig_digits = 3
        return f'[{data:-#.{g_sig_digits}g}]'
mpl._docstring.interpd.update(cmap_doc='cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n    The Colormap instance or registered colormap name used to map scalar data\n    to colors.', norm_doc='norm : str or `~matplotlib.colors.Normalize`, optional\n    The normalization method used to scale scalar data to the [0, 1] range\n    before mapping to colors using *cmap*. By default, a linear scaling is\n    used, mapping the lowest value to 0 and the highest to 1.\n\n    If given, this can be one of the following:\n\n    - An instance of `.Normalize` or one of its subclasses\n      (see :ref:`colormapnorms`).\n    - A scale name, i.e. one of "linear", "log", "symlog", "logit", etc.  For a\n      list of available scales, call `matplotlib.scale.get_scale_names()`.\n      In that case, a suitable `.Normalize` subclass is dynamically generated\n      and instantiated.', vmin_vmax_doc='vmin, vmax : float, optional\n    When using scalar data and no explicit *norm*, *vmin* and *vmax* define\n    the data range that the colormap covers. By default, the colormap covers\n    the complete value range of the supplied data. It is an error to use\n    *vmin*/*vmax* when a *norm* instance is given (but using a `str` *norm*\n    name together with *vmin*/*vmax* is acceptable).')

def _ensure_cmap(cmap):
    if isinstance(cmap, colors.Colormap):
        return cmap
    cmap_name = cmap if cmap is not None else mpl.rcParams['image.cmap']
    if cmap_name not in _colormaps:
        _api.check_in_list(sorted(_colormaps), cmap=cmap_name)
    return mpl.colormaps[cmap_name]

# File: matplotlib-main/lib/matplotlib/collections.py
""""""
import itertools
import math
from numbers import Number, Real
import warnings
import numpy as np
import matplotlib as mpl
from . import _api, _path, artist, cbook, cm, colors as mcolors, _docstring, hatch as mhatch, lines as mlines, path as mpath, transforms
from ._enums import JoinStyle, CapStyle

@_api.define_aliases({'antialiased': ['antialiaseds', 'aa'], 'edgecolor': ['edgecolors', 'ec'], 'facecolor': ['facecolors', 'fc'], 'linestyle': ['linestyles', 'dashes', 'ls'], 'linewidth': ['linewidths', 'lw'], 'offset_transform': ['transOffset']})
class Collection(artist.Artist, cm.ScalarMappable):
    _transforms = np.empty((0, 3, 3))
    _edge_default = False

    @_docstring.interpd
    def __init__(self, *, edgecolors=None, facecolors=None, linewidths=None, linestyles='solid', capstyle=None, joinstyle=None, antialiaseds=None, offsets=None, offset_transform=None, norm=None, cmap=None, pickradius=5.0, hatch=None, urls=None, zorder=1, **kwargs):
        artist.Artist.__init__(self)
        cm.ScalarMappable.__init__(self, norm, cmap)
        self._us_linestyles = [(0, None)]
        self._linestyles = [(0, None)]
        self._us_lw = [0]
        self._linewidths = [0]
        self._gapcolor = None
        self._face_is_mapped = None
        self._edge_is_mapped = None
        self._mapped_colors = None
        self._hatch_color = mcolors.to_rgba(mpl.rcParams['hatch.color'])
        self.set_facecolor(facecolors)
        self.set_edgecolor(edgecolors)
        self.set_linewidth(linewidths)
        self.set_linestyle(linestyles)
        self.set_antialiased(antialiaseds)
        self.set_pickradius(pickradius)
        self.set_urls(urls)
        self.set_hatch(hatch)
        self.set_zorder(zorder)
        if capstyle:
            self.set_capstyle(capstyle)
        else:
            self._capstyle = None
        if joinstyle:
            self.set_joinstyle(joinstyle)
        else:
            self._joinstyle = None
        if offsets is not None:
            offsets = np.asanyarray(offsets, float)
            if offsets.shape == (2,):
                offsets = offsets[None, :]
        self._offsets = offsets
        self._offset_transform = offset_transform
        self._path_effects = None
        self._internal_update(kwargs)
        self._paths = None

    def get_paths(self):
        return self._paths

    def set_paths(self, paths):
        self._paths = paths
        self.stale = True

    def get_transforms(self):
        return self._transforms

    def get_offset_transform(self):
        if self._offset_transform is None:
            self._offset_transform = transforms.IdentityTransform()
        elif not isinstance(self._offset_transform, transforms.Transform) and hasattr(self._offset_transform, '_as_mpl_transform'):
            self._offset_transform = self._offset_transform._as_mpl_transform(self.axes)
        return self._offset_transform

    def set_offset_transform(self, offset_transform):
        self._offset_transform = offset_transform

    def get_datalim(self, transData):
        transform = self.get_transform()
        offset_trf = self.get_offset_transform()
        if not (isinstance(offset_trf, transforms.IdentityTransform) or offset_trf.contains_branch(transData)):
            return transforms.Bbox.null()
        paths = self.get_paths()
        if not len(paths):
            return transforms.Bbox.null()
        if not transform.is_affine:
            paths = [transform.transform_path_non_affine(p) for p in paths]
        offsets = self.get_offsets()
        if any(transform.contains_branch_seperately(transData)):
            if isinstance(offsets, np.ma.MaskedArray):
                offsets = offsets.filled(np.nan)
            return mpath.get_path_collection_extents(transform.get_affine() - transData, paths, self.get_transforms(), offset_trf.transform_non_affine(offsets), offset_trf.get_affine().frozen())
        if self._offsets is not None:
            offsets = (offset_trf - transData).transform(offsets)
            offsets = np.ma.masked_invalid(offsets)
            if not offsets.mask.all():
                bbox = transforms.Bbox.null()
                bbox.update_from_data_xy(offsets)
                return bbox
        return transforms.Bbox.null()

    def get_window_extent(self, renderer=None):
        return self.get_datalim(transforms.IdentityTransform())

    def _prepare_points(self):
        transform = self.get_transform()
        offset_trf = self.get_offset_transform()
        offsets = self.get_offsets()
        paths = self.get_paths()
        if self.have_units():
            paths = []
            for path in self.get_paths():
                vertices = path.vertices
                (xs, ys) = (vertices[:, 0], vertices[:, 1])
                xs = self.convert_xunits(xs)
                ys = self.convert_yunits(ys)
                paths.append(mpath.Path(np.column_stack([xs, ys]), path.codes))
            xs = self.convert_xunits(offsets[:, 0])
            ys = self.convert_yunits(offsets[:, 1])
            offsets = np.ma.column_stack([xs, ys])
        if not transform.is_affine:
            paths = [transform.transform_path_non_affine(path) for path in paths]
            transform = transform.get_affine()
        if not offset_trf.is_affine:
            offsets = offset_trf.transform_non_affine(offsets)
            offset_trf = offset_trf.get_affine()
        if isinstance(offsets, np.ma.MaskedArray):
            offsets = offsets.filled(np.nan)
        return (transform, offset_trf, offsets, paths)

    @artist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group(self.__class__.__name__, self.get_gid())
        self.update_scalarmappable()
        (transform, offset_trf, offsets, paths) = self._prepare_points()
        gc = renderer.new_gc()
        self._set_gc_clip(gc)
        gc.set_snap(self.get_snap())
        if self._hatch:
            gc.set_hatch(self._hatch)
            gc.set_hatch_color(self._hatch_color)
        if self.get_sketch_params() is not None:
            gc.set_sketch_params(*self.get_sketch_params())
        if self.get_path_effects():
            from matplotlib.patheffects import PathEffectRenderer
            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
        trans = self.get_transforms()
        facecolors = self.get_facecolor()
        edgecolors = self.get_edgecolor()
        do_single_path_optimization = False
        if len(paths) == 1 and len(trans) <= 1 and (len(facecolors) == 1) and (len(edgecolors) == 1) and (len(self._linewidths) == 1) and all((ls[1] is None for ls in self._linestyles)) and (len(self._antialiaseds) == 1) and (len(self._urls) == 1) and (self.get_hatch() is None):
            if len(trans):
                combined_transform = transforms.Affine2D(trans[0]) + transform
            else:
                combined_transform = transform
            extents = paths[0].get_extents(combined_transform)
            if extents.width < self.get_figure(root=True).bbox.width and extents.height < self.get_figure(root=True).bbox.height:
                do_single_path_optimization = True
        if self._joinstyle:
            gc.set_joinstyle(self._joinstyle)
        if self._capstyle:
            gc.set_capstyle(self._capstyle)
        if do_single_path_optimization:
            gc.set_foreground(tuple(edgecolors[0]))
            gc.set_linewidth(self._linewidths[0])
            gc.set_dashes(*self._linestyles[0])
            gc.set_antialiased(self._antialiaseds[0])
            gc.set_url(self._urls[0])
            renderer.draw_markers(gc, paths[0], combined_transform.frozen(), mpath.Path(offsets), offset_trf, tuple(facecolors[0]))
        else:
            if self._gapcolor is not None:
                (ipaths, ilinestyles) = self._get_inverse_paths_linestyles()
                renderer.draw_path_collection(gc, transform.frozen(), ipaths, self.get_transforms(), offsets, offset_trf, [mcolors.to_rgba('none')], self._gapcolor, self._linewidths, ilinestyles, self._antialiaseds, self._urls, 'screen')
            renderer.draw_path_collection(gc, transform.frozen(), paths, self.get_transforms(), offsets, offset_trf, self.get_facecolor(), self.get_edgecolor(), self._linewidths, self._linestyles, self._antialiaseds, self._urls, 'screen')
        gc.restore()
        renderer.close_group(self.__class__.__name__)
        self.stale = False

    def set_pickradius(self, pickradius):
        if not isinstance(pickradius, Real):
            raise ValueError(f'pickradius must be a real-valued number, not {pickradius!r}')
        self._pickradius = pickradius

    def get_pickradius(self):
        return self._pickradius

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent) or not self.get_visible():
            return (False, {})
        pickradius = float(self._picker) if isinstance(self._picker, Number) and self._picker is not True else self._pickradius
        if self.axes:
            self.axes._unstale_viewLim()
        (transform, offset_trf, offsets, paths) = self._prepare_points()
        ind = _path.point_in_path_collection(mouseevent.x, mouseevent.y, pickradius, transform.frozen(), paths, self.get_transforms(), offsets, offset_trf, pickradius <= 0)
        return (len(ind) > 0, dict(ind=ind))

    def set_urls(self, urls):
        self._urls = urls if urls is not None else [None]
        self.stale = True

    def get_urls(self):
        return self._urls

    def set_hatch(self, hatch):
        mhatch._validate_hatch_pattern(hatch)
        self._hatch = hatch
        self.stale = True

    def get_hatch(self):
        return self._hatch

    def set_offsets(self, offsets):
        offsets = np.asanyarray(offsets)
        if offsets.shape == (2,):
            offsets = offsets[None, :]
        cstack = np.ma.column_stack if isinstance(offsets, np.ma.MaskedArray) else np.column_stack
        self._offsets = cstack((np.asanyarray(self.convert_xunits(offsets[:, 0]), float), np.asanyarray(self.convert_yunits(offsets[:, 1]), float)))
        self.stale = True

    def get_offsets(self):
        return np.zeros((1, 2)) if self._offsets is None else self._offsets

    def _get_default_linewidth(self):
        return mpl.rcParams['patch.linewidth']

    def set_linewidth(self, lw):
        if lw is None:
            lw = self._get_default_linewidth()
        self._us_lw = np.atleast_1d(lw)
        (self._linewidths, self._linestyles) = self._bcast_lwls(self._us_lw, self._us_linestyles)
        self.stale = True

    def set_linestyle(self, ls):
        try:
            dashes = [mlines._get_dash_pattern(ls)]
        except ValueError:
            try:
                dashes = [mlines._get_dash_pattern(x) for x in ls]
            except ValueError as err:
                emsg = f'Do not know how to convert {ls!r} to dashes'
                raise ValueError(emsg) from err
        self._us_linestyles = dashes
        (self._linewidths, self._linestyles) = self._bcast_lwls(self._us_lw, self._us_linestyles)

    @_docstring.interpd
    def set_capstyle(self, cs):
        self._capstyle = CapStyle(cs)

    @_docstring.interpd
    def get_capstyle(self):
        return self._capstyle.name if self._capstyle else None

    @_docstring.interpd
    def set_joinstyle(self, js):
        self._joinstyle = JoinStyle(js)

    @_docstring.interpd
    def get_joinstyle(self):
        return self._joinstyle.name if self._joinstyle else None

    @staticmethod
    def _bcast_lwls(linewidths, dashes):
        if mpl.rcParams['_internal.classic_mode']:
            return (linewidths, dashes)
        if len(dashes) != len(linewidths):
            l_dashes = len(dashes)
            l_lw = len(linewidths)
            gcd = math.gcd(l_dashes, l_lw)
            dashes = list(dashes) * (l_lw // gcd)
            linewidths = list(linewidths) * (l_dashes // gcd)
        dashes = [mlines._scale_dashes(o, d, lw) for ((o, d), lw) in zip(dashes, linewidths)]
        return (linewidths, dashes)

    def get_antialiased(self):
        return self._antialiaseds

    def set_antialiased(self, aa):
        if aa is None:
            aa = self._get_default_antialiased()
        self._antialiaseds = np.atleast_1d(np.asarray(aa, bool))
        self.stale = True

    def _get_default_antialiased(self):
        return mpl.rcParams['patch.antialiased']

    def set_color(self, c):
        self.set_facecolor(c)
        self.set_edgecolor(c)

    def _get_default_facecolor(self):
        return mpl.rcParams['patch.facecolor']

    def _set_facecolor(self, c):
        if c is None:
            c = self._get_default_facecolor()
        self._facecolors = mcolors.to_rgba_array(c, self._alpha)
        self.stale = True

    def set_facecolor(self, c):
        if isinstance(c, str) and c.lower() in ('none', 'face'):
            c = c.lower()
        self._original_facecolor = c
        self._set_facecolor(c)

    def get_facecolor(self):
        return self._facecolors

    def get_edgecolor(self):
        if cbook._str_equal(self._edgecolors, 'face'):
            return self.get_facecolor()
        else:
            return self._edgecolors

    def _get_default_edgecolor(self):
        return mpl.rcParams['patch.edgecolor']

    def _set_edgecolor(self, c):
        set_hatch_color = True
        if c is None:
            if mpl.rcParams['patch.force_edgecolor'] or self._edge_default or cbook._str_equal(self._original_facecolor, 'none'):
                c = self._get_default_edgecolor()
            else:
                c = 'none'
                set_hatch_color = False
        if cbook._str_lower_equal(c, 'face'):
            self._edgecolors = 'face'
            self.stale = True
            return
        self._edgecolors = mcolors.to_rgba_array(c, self._alpha)
        if set_hatch_color and len(self._edgecolors):
            self._hatch_color = tuple(self._edgecolors[0])
        self.stale = True

    def set_edgecolor(self, c):
        if isinstance(c, str) and c.lower() in ('none', 'face'):
            c = c.lower()
        self._original_edgecolor = c
        self._set_edgecolor(c)

    def set_alpha(self, alpha):
        artist.Artist._set_alpha_for_array(self, alpha)
        self._set_facecolor(self._original_facecolor)
        self._set_edgecolor(self._original_edgecolor)
    set_alpha.__doc__ = artist.Artist._set_alpha_for_array.__doc__

    def get_linewidth(self):
        return self._linewidths

    def get_linestyle(self):
        return self._linestyles

    def _set_mappable_flags(self):
        edge0 = self._edge_is_mapped
        face0 = self._face_is_mapped
        self._edge_is_mapped = False
        self._face_is_mapped = False
        if self._A is not None:
            if not cbook._str_equal(self._original_facecolor, 'none'):
                self._face_is_mapped = True
                if cbook._str_equal(self._original_edgecolor, 'face'):
                    self._edge_is_mapped = True
            elif self._original_edgecolor is None:
                self._edge_is_mapped = True
        mapped = self._face_is_mapped or self._edge_is_mapped
        changed = edge0 is None or face0 is None or self._edge_is_mapped != edge0 or (self._face_is_mapped != face0)
        return mapped or changed

    def update_scalarmappable(self):
        if not self._set_mappable_flags():
            return
        if self._A is not None:
            if self._A.ndim > 1 and (not isinstance(self, _MeshData)):
                raise ValueError('Collections can only map rank 1 arrays')
            if np.iterable(self._alpha):
                if self._alpha.size != self._A.size:
                    raise ValueError(f'Data array shape, {self._A.shape} is incompatible with alpha array shape, {self._alpha.shape}. This can occur with the deprecated behavior of the "flat" shading option, in which a row and/or column of the data array is dropped.')
                self._alpha = self._alpha.reshape(self._A.shape)
            self._mapped_colors = self.to_rgba(self._A, self._alpha)
        if self._face_is_mapped:
            self._facecolors = self._mapped_colors
        else:
            self._set_facecolor(self._original_facecolor)
        if self._edge_is_mapped:
            self._edgecolors = self._mapped_colors
        else:
            self._set_edgecolor(self._original_edgecolor)
        self.stale = True

    def get_fill(self):
        return not cbook._str_lower_equal(self._original_facecolor, 'none')

    def update_from(self, other):
        artist.Artist.update_from(self, other)
        self._antialiaseds = other._antialiaseds
        self._mapped_colors = other._mapped_colors
        self._edge_is_mapped = other._edge_is_mapped
        self._original_edgecolor = other._original_edgecolor
        self._edgecolors = other._edgecolors
        self._face_is_mapped = other._face_is_mapped
        self._original_facecolor = other._original_facecolor
        self._facecolors = other._facecolors
        self._linewidths = other._linewidths
        self._linestyles = other._linestyles
        self._us_linestyles = other._us_linestyles
        self._pickradius = other._pickradius
        self._hatch = other._hatch
        self._A = other._A
        self.norm = other.norm
        self.cmap = other.cmap
        self.stale = True

class _CollectionWithSizes(Collection):
    _factor = 1.0

    def get_sizes(self):
        return self._sizes

    def set_sizes(self, sizes, dpi=72.0):
        if sizes is None:
            self._sizes = np.array([])
            self._transforms = np.empty((0, 3, 3))
        else:
            self._sizes = np.asarray(sizes)
            self._transforms = np.zeros((len(self._sizes), 3, 3))
            scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor
            self._transforms[:, 0, 0] = scale
            self._transforms[:, 1, 1] = scale
            self._transforms[:, 2, 2] = 1.0
        self.stale = True

    @artist.allow_rasterization
    def draw(self, renderer):
        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
        super().draw(renderer)

class PathCollection(_CollectionWithSizes):

    def __init__(self, paths, sizes=None, **kwargs):
        super().__init__(**kwargs)
        self.set_paths(paths)
        self.set_sizes(sizes)
        self.stale = True

    def get_paths(self):
        return self._paths

    def legend_elements(self, prop='colors', num='auto', fmt=None, func=lambda x: x, **kwargs):
        handles = []
        labels = []
        hasarray = self.get_array() is not None
        if fmt is None:
            fmt = mpl.ticker.ScalarFormatter(useOffset=False, useMathText=True)
        elif isinstance(fmt, str):
            fmt = mpl.ticker.StrMethodFormatter(fmt)
        fmt.create_dummy_axis()
        if prop == 'colors':
            if not hasarray:
                warnings.warn('Collection without array used. Make sure to specify the values to be colormapped via the `c` argument.')
                return (handles, labels)
            u = np.unique(self.get_array())
            size = kwargs.pop('size', mpl.rcParams['lines.markersize'])
        elif prop == 'sizes':
            u = np.unique(self.get_sizes())
            color = kwargs.pop('color', 'k')
        else:
            raise ValueError(f"Valid values for `prop` are 'colors' or 'sizes'. You supplied '{prop}' instead.")
        fu = func(u)
        fmt.axis.set_view_interval(fu.min(), fu.max())
        fmt.axis.set_data_interval(fu.min(), fu.max())
        if num == 'auto':
            num = 9
            if len(u) <= num:
                num = None
        if num is None:
            values = u
            label_values = func(values)
        else:
            if prop == 'colors':
                arr = self.get_array()
            elif prop == 'sizes':
                arr = self.get_sizes()
            if isinstance(num, mpl.ticker.Locator):
                loc = num
            elif np.iterable(num):
                loc = mpl.ticker.FixedLocator(num)
            else:
                num = int(num)
                loc = mpl.ticker.MaxNLocator(nbins=num, min_n_ticks=num - 1, steps=[1, 2, 2.5, 3, 5, 6, 8, 10])
            label_values = loc.tick_values(func(arr).min(), func(arr).max())
            cond = (label_values >= func(arr).min()) & (label_values <= func(arr).max())
            label_values = label_values[cond]
            yarr = np.linspace(arr.min(), arr.max(), 256)
            xarr = func(yarr)
            ix = np.argsort(xarr)
            values = np.interp(label_values, xarr[ix], yarr[ix])
        kw = {'markeredgewidth': self.get_linewidths()[0], 'alpha': self.get_alpha(), **kwargs}
        for (val, lab) in zip(values, label_values):
            if prop == 'colors':
                color = self.cmap(self.norm(val))
            elif prop == 'sizes':
                size = np.sqrt(val)
                if np.isclose(size, 0.0):
                    continue
            h = mlines.Line2D([0], [0], ls='', color=color, ms=size, marker=self.get_paths()[0], **kw)
            handles.append(h)
            if hasattr(fmt, 'set_locs'):
                fmt.set_locs(label_values)
            l = fmt(lab)
            labels.append(l)
        return (handles, labels)

class PolyCollection(_CollectionWithSizes):

    def __init__(self, verts, sizes=None, *, closed=True, **kwargs):
        super().__init__(**kwargs)
        self.set_sizes(sizes)
        self.set_verts(verts, closed)
        self.stale = True

    def set_verts(self, verts, closed=True):
        self.stale = True
        if isinstance(verts, np.ma.MaskedArray):
            verts = verts.astype(float).filled(np.nan)
        if not closed:
            self._paths = [mpath.Path(xy) for xy in verts]
            return
        if isinstance(verts, np.ndarray) and len(verts.shape) == 3:
            verts_pad = np.concatenate((verts, verts[:, :1]), axis=1)
            codes = np.empty(verts_pad.shape[1], dtype=mpath.Path.code_type)
            codes[:] = mpath.Path.LINETO
            codes[0] = mpath.Path.MOVETO
            codes[-1] = mpath.Path.CLOSEPOLY
            self._paths = [mpath.Path(xy, codes) for xy in verts_pad]
            return
        self._paths = []
        for xy in verts:
            if len(xy):
                self._paths.append(mpath.Path._create_closed(xy))
            else:
                self._paths.append(mpath.Path(xy))
    set_paths = set_verts

    def set_verts_and_codes(self, verts, codes):
        if len(verts) != len(codes):
            raise ValueError("'codes' must be a 1D list or array with the same length of 'verts'")
        self._paths = [mpath.Path(xy, cds) if len(xy) else mpath.Path(xy) for (xy, cds) in zip(verts, codes)]
        self.stale = True

class RegularPolyCollection(_CollectionWithSizes):
    _path_generator = mpath.Path.unit_regular_polygon
    _factor = np.pi ** (-1 / 2)

    def __init__(self, numsides, *, rotation=0, sizes=(1,), **kwargs):
        super().__init__(**kwargs)
        self.set_sizes(sizes)
        self._numsides = numsides
        self._paths = [self._path_generator(numsides)]
        self._rotation = rotation
        self.set_transform(transforms.IdentityTransform())

    def get_numsides(self):
        return self._numsides

    def get_rotation(self):
        return self._rotation

    @artist.allow_rasterization
    def draw(self, renderer):
        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
        self._transforms = [transforms.Affine2D(x).rotate(-self._rotation).get_matrix() for x in self._transforms]
        Collection.draw(self, renderer)

class StarPolygonCollection(RegularPolyCollection):
    _path_generator = mpath.Path.unit_regular_star

class AsteriskPolygonCollection(RegularPolyCollection):
    _path_generator = mpath.Path.unit_regular_asterisk

class LineCollection(Collection):
    _edge_default = True

    def __init__(self, segments, *, zorder=2, **kwargs):
        kwargs.setdefault('facecolors', 'none')
        super().__init__(zorder=zorder, **kwargs)
        self.set_segments(segments)

    def set_segments(self, segments):
        if segments is None:
            return
        self._paths = [mpath.Path(seg) if isinstance(seg, np.ma.MaskedArray) else mpath.Path(np.asarray(seg, float)) for seg in segments]
        self.stale = True
    set_verts = set_segments
    set_paths = set_segments

    def get_segments(self):
        segments = []
        for path in self._paths:
            vertices = [vertex for (vertex, _) in path.iter_segments(simplify=False)]
            vertices = np.asarray(vertices)
            segments.append(vertices)
        return segments

    def _get_default_linewidth(self):
        return mpl.rcParams['lines.linewidth']

    def _get_default_antialiased(self):
        return mpl.rcParams['lines.antialiased']

    def _get_default_edgecolor(self):
        return mpl.rcParams['lines.color']

    def _get_default_facecolor(self):
        return 'none'

    def set_alpha(self, alpha):
        super().set_alpha(alpha)
        if self._gapcolor is not None:
            self.set_gapcolor(self._original_gapcolor)

    def set_color(self, c):
        self.set_edgecolor(c)
    set_colors = set_color

    def get_color(self):
        return self._edgecolors
    get_colors = get_color

    def set_gapcolor(self, gapcolor):
        self._original_gapcolor = gapcolor
        self._set_gapcolor(gapcolor)

    def _set_gapcolor(self, gapcolor):
        if gapcolor is not None:
            gapcolor = mcolors.to_rgba_array(gapcolor, self._alpha)
        self._gapcolor = gapcolor
        self.stale = True

    def get_gapcolor(self):
        return self._gapcolor

    def _get_inverse_paths_linestyles(self):
        path_patterns = [(mpath.Path(np.full((1, 2), np.nan)), ls) if ls == (0, None) else (path, mlines._get_inverse_dash_pattern(*ls)) for (path, ls) in zip(self._paths, itertools.cycle(self._linestyles))]
        return zip(*path_patterns)

class EventCollection(LineCollection):
    _edge_default = True

    def __init__(self, positions, orientation='horizontal', *, lineoffset=0, linelength=1, linewidth=None, color=None, linestyle='solid', antialiased=None, **kwargs):
        super().__init__([], linewidths=linewidth, linestyles=linestyle, colors=color, antialiaseds=antialiased, **kwargs)
        self._is_horizontal = True
        self._linelength = linelength
        self._lineoffset = lineoffset
        self.set_orientation(orientation)
        self.set_positions(positions)

    def get_positions(self):
        pos = 0 if self.is_horizontal() else 1
        return [segment[0, pos] for segment in self.get_segments()]

    def set_positions(self, positions):
        if positions is None:
            positions = []
        if np.ndim(positions) != 1:
            raise ValueError('positions must be one-dimensional')
        lineoffset = self.get_lineoffset()
        linelength = self.get_linelength()
        pos_idx = 0 if self.is_horizontal() else 1
        segments = np.empty((len(positions), 2, 2))
        segments[:, :, pos_idx] = np.sort(positions)[:, None]
        segments[:, 0, 1 - pos_idx] = lineoffset + linelength / 2
        segments[:, 1, 1 - pos_idx] = lineoffset - linelength / 2
        self.set_segments(segments)

    def add_positions(self, position):
        if position is None or (hasattr(position, 'len') and len(position) == 0):
            return
        positions = self.get_positions()
        positions = np.hstack([positions, np.asanyarray(position)])
        self.set_positions(positions)
    extend_positions = append_positions = add_positions

    def is_horizontal(self):
        return self._is_horizontal

    def get_orientation(self):
        return 'horizontal' if self.is_horizontal() else 'vertical'

    def switch_orientation(self):
        segments = self.get_segments()
        for (i, segment) in enumerate(segments):
            segments[i] = np.fliplr(segment)
        self.set_segments(segments)
        self._is_horizontal = not self.is_horizontal()
        self.stale = True

    def set_orientation(self, orientation):
        is_horizontal = _api.check_getitem({'horizontal': True, 'vertical': False}, orientation=orientation)
        if is_horizontal == self.is_horizontal():
            return
        self.switch_orientation()

    def get_linelength(self):
        return self._linelength

    def set_linelength(self, linelength):
        if linelength == self.get_linelength():
            return
        lineoffset = self.get_lineoffset()
        segments = self.get_segments()
        pos = 1 if self.is_horizontal() else 0
        for segment in segments:
            segment[0, pos] = lineoffset + linelength / 2.0
            segment[1, pos] = lineoffset - linelength / 2.0
        self.set_segments(segments)
        self._linelength = linelength

    def get_lineoffset(self):
        return self._lineoffset

    def set_lineoffset(self, lineoffset):
        if lineoffset == self.get_lineoffset():
            return
        linelength = self.get_linelength()
        segments = self.get_segments()
        pos = 1 if self.is_horizontal() else 0
        for segment in segments:
            segment[0, pos] = lineoffset + linelength / 2.0
            segment[1, pos] = lineoffset - linelength / 2.0
        self.set_segments(segments)
        self._lineoffset = lineoffset

    def get_linewidth(self):
        return super().get_linewidth()[0]

    def get_linewidths(self):
        return super().get_linewidth()

    def get_color(self):
        return self.get_colors()[0]

class CircleCollection(_CollectionWithSizes):
    _factor = np.pi ** (-1 / 2)

    def __init__(self, sizes, **kwargs):
        super().__init__(**kwargs)
        self.set_sizes(sizes)
        self.set_transform(transforms.IdentityTransform())
        self._paths = [mpath.Path.unit_circle()]

class EllipseCollection(Collection):

    def __init__(self, widths, heights, angles, *, units='points', **kwargs):
        super().__init__(**kwargs)
        self.set_widths(widths)
        self.set_heights(heights)
        self.set_angles(angles)
        self._units = units
        self.set_transform(transforms.IdentityTransform())
        self._transforms = np.empty((0, 3, 3))
        self._paths = [mpath.Path.unit_circle()]

    def _set_transforms(self):
        ax = self.axes
        fig = self.get_figure(root=False)
        if self._units == 'xy':
            sc = 1
        elif self._units == 'x':
            sc = ax.bbox.width / ax.viewLim.width
        elif self._units == 'y':
            sc = ax.bbox.height / ax.viewLim.height
        elif self._units == 'inches':
            sc = fig.dpi
        elif self._units == 'points':
            sc = fig.dpi / 72.0
        elif self._units == 'width':
            sc = ax.bbox.width
        elif self._units == 'height':
            sc = ax.bbox.height
        elif self._units == 'dots':
            sc = 1.0
        else:
            raise ValueError(f'Unrecognized units: {self._units!r}')
        self._transforms = np.zeros((len(self._widths), 3, 3))
        widths = self._widths * sc
        heights = self._heights * sc
        sin_angle = np.sin(self._angles)
        cos_angle = np.cos(self._angles)
        self._transforms[:, 0, 0] = widths * cos_angle
        self._transforms[:, 0, 1] = heights * -sin_angle
        self._transforms[:, 1, 0] = widths * sin_angle
        self._transforms[:, 1, 1] = heights * cos_angle
        self._transforms[:, 2, 2] = 1.0
        _affine = transforms.Affine2D
        if self._units == 'xy':
            m = ax.transData.get_affine().get_matrix().copy()
            m[:2, 2:] = 0
            self.set_transform(_affine(m))

    def set_widths(self, widths):
        self._widths = 0.5 * np.asarray(widths).ravel()
        self.stale = True

    def set_heights(self, heights):
        self._heights = 0.5 * np.asarray(heights).ravel()
        self.stale = True

    def set_angles(self, angles):
        self._angles = np.deg2rad(angles).ravel()
        self.stale = True

    def get_widths(self):
        return self._widths * 2

    def get_heights(self):
        return self._heights * 2

    def get_angles(self):
        return np.rad2deg(self._angles)

    @artist.allow_rasterization
    def draw(self, renderer):
        self._set_transforms()
        super().draw(renderer)

class PatchCollection(Collection):

    def __init__(self, patches, *, match_original=False, **kwargs):
        if match_original:

            def determine_facecolor(patch):
                if patch.get_fill():
                    return patch.get_facecolor()
                return [0, 0, 0, 0]
            kwargs['facecolors'] = [determine_facecolor(p) for p in patches]
            kwargs['edgecolors'] = [p.get_edgecolor() for p in patches]
            kwargs['linewidths'] = [p.get_linewidth() for p in patches]
            kwargs['linestyles'] = [p.get_linestyle() for p in patches]
            kwargs['antialiaseds'] = [p.get_antialiased() for p in patches]
        super().__init__(**kwargs)
        self.set_paths(patches)

    def set_paths(self, patches):
        paths = [p.get_transform().transform_path(p.get_path()) for p in patches]
        self._paths = paths

class TriMesh(Collection):

    def __init__(self, triangulation, **kwargs):
        super().__init__(**kwargs)
        self._triangulation = triangulation
        self._shading = 'gouraud'
        self._bbox = transforms.Bbox.unit()
        xy = np.hstack((triangulation.x.reshape(-1, 1), triangulation.y.reshape(-1, 1)))
        self._bbox.update_from_data_xy(xy)

    def get_paths(self):
        if self._paths is None:
            self.set_paths()
        return self._paths

    def set_paths(self):
        self._paths = self.convert_mesh_to_paths(self._triangulation)

    @staticmethod
    def convert_mesh_to_paths(tri):
        triangles = tri.get_masked_triangles()
        verts = np.stack((tri.x[triangles], tri.y[triangles]), axis=-1)
        return [mpath.Path(x) for x in verts]

    @artist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group(self.__class__.__name__, gid=self.get_gid())
        transform = self.get_transform()
        tri = self._triangulation
        triangles = tri.get_masked_triangles()
        verts = np.stack((tri.x[triangles], tri.y[triangles]), axis=-1)
        self.update_scalarmappable()
        colors = self._facecolors[triangles]
        gc = renderer.new_gc()
        self._set_gc_clip(gc)
        gc.set_linewidth(self.get_linewidth()[0])
        renderer.draw_gouraud_triangles(gc, verts, colors, transform.frozen())
        gc.restore()
        renderer.close_group(self.__class__.__name__)

class _MeshData:

    def __init__(self, coordinates, *, shading='flat'):
        _api.check_shape((None, None, 2), coordinates=coordinates)
        self._coordinates = coordinates
        self._shading = shading

    def set_array(self, A):
        (height, width) = self._coordinates.shape[0:-1]
        if self._shading == 'flat':
            (h, w) = (height - 1, width - 1)
        else:
            (h, w) = (height, width)
        ok_shapes = [(h, w, 3), (h, w, 4), (h, w), (h * w,)]
        if A is not None:
            shape = np.shape(A)
            if shape not in ok_shapes:
                raise ValueError(f"For X ({width}) and Y ({height}) with {self._shading} shading, A should have shape {' or '.join(map(str, ok_shapes))}, not {A.shape}")
        return super().set_array(A)

    def get_coordinates(self):
        return self._coordinates

    def get_edgecolor(self):
        return super().get_edgecolor().reshape(-1, 4)

    def get_facecolor(self):
        return super().get_facecolor().reshape(-1, 4)

    @staticmethod
    def _convert_mesh_to_paths(coordinates):
        if isinstance(coordinates, np.ma.MaskedArray):
            c = coordinates.data
        else:
            c = coordinates
        points = np.concatenate([c[:-1, :-1], c[:-1, 1:], c[1:, 1:], c[1:, :-1], c[:-1, :-1]], axis=2).reshape((-1, 5, 2))
        return [mpath.Path(x) for x in points]

    def _convert_mesh_to_triangles(self, coordinates):
        if isinstance(coordinates, np.ma.MaskedArray):
            p = coordinates.data
        else:
            p = coordinates
        p_a = p[:-1, :-1]
        p_b = p[:-1, 1:]
        p_c = p[1:, 1:]
        p_d = p[1:, :-1]
        p_center = (p_a + p_b + p_c + p_d) / 4.0
        triangles = np.concatenate([p_a, p_b, p_center, p_b, p_c, p_center, p_c, p_d, p_center, p_d, p_a, p_center], axis=2).reshape((-1, 3, 2))
        c = self.get_facecolor().reshape((*coordinates.shape[:2], 4))
        z = self.get_array()
        mask = z.mask if np.ma.is_masked(z) else None
        if mask is not None:
            c[mask, 3] = np.nan
        c_a = c[:-1, :-1]
        c_b = c[:-1, 1:]
        c_c = c[1:, 1:]
        c_d = c[1:, :-1]
        c_center = (c_a + c_b + c_c + c_d) / 4.0
        colors = np.concatenate([c_a, c_b, c_center, c_b, c_c, c_center, c_c, c_d, c_center, c_d, c_a, c_center], axis=2).reshape((-1, 3, 4))
        tmask = np.isnan(colors[..., 2, 3])
        return (triangles[~tmask], colors[~tmask])

class QuadMesh(_MeshData, Collection):

    def __init__(self, coordinates, *, antialiased=True, shading='flat', **kwargs):
        kwargs.setdefault('pickradius', 0)
        super().__init__(coordinates=coordinates, shading=shading)
        Collection.__init__(self, **kwargs)
        self._antialiased = antialiased
        self._bbox = transforms.Bbox.unit()
        self._bbox.update_from_data_xy(self._coordinates.reshape(-1, 2))
        self.set_mouseover(False)

    def get_paths(self):
        if self._paths is None:
            self.set_paths()
        return self._paths

    def set_paths(self):
        self._paths = self._convert_mesh_to_paths(self._coordinates)
        self.stale = True

    def get_datalim(self, transData):
        return (self.get_transform() - transData).transform_bbox(self._bbox)

    @artist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group(self.__class__.__name__, self.get_gid())
        transform = self.get_transform()
        offset_trf = self.get_offset_transform()
        offsets = self.get_offsets()
        if self.have_units():
            xs = self.convert_xunits(offsets[:, 0])
            ys = self.convert_yunits(offsets[:, 1])
            offsets = np.column_stack([xs, ys])
        self.update_scalarmappable()
        if not transform.is_affine:
            coordinates = self._coordinates.reshape((-1, 2))
            coordinates = transform.transform(coordinates)
            coordinates = coordinates.reshape(self._coordinates.shape)
            transform = transforms.IdentityTransform()
        else:
            coordinates = self._coordinates
        if not offset_trf.is_affine:
            offsets = offset_trf.transform_non_affine(offsets)
            offset_trf = offset_trf.get_affine()
        gc = renderer.new_gc()
        gc.set_snap(self.get_snap())
        self._set_gc_clip(gc)
        gc.set_linewidth(self.get_linewidth()[0])
        if self._shading == 'gouraud':
            (triangles, colors) = self._convert_mesh_to_triangles(coordinates)
            renderer.draw_gouraud_triangles(gc, triangles, colors, transform.frozen())
        else:
            renderer.draw_quad_mesh(gc, transform.frozen(), coordinates.shape[1] - 1, coordinates.shape[0] - 1, coordinates, offsets, offset_trf, self.get_facecolor().reshape((-1, 4)), self._antialiased, self.get_edgecolors().reshape((-1, 4)))
        gc.restore()
        renderer.close_group(self.__class__.__name__)
        self.stale = False

    def get_cursor_data(self, event):
        (contained, info) = self.contains(event)
        if contained and self.get_array() is not None:
            return self.get_array().ravel()[info['ind']]
        return None

class PolyQuadMesh(_MeshData, PolyCollection):

    def __init__(self, coordinates, **kwargs):
        super().__init__(coordinates=coordinates)
        PolyCollection.__init__(self, verts=[], **kwargs)
        self._set_unmasked_verts()

    def _get_unmasked_polys(self):
        mask = np.any(np.ma.getmaskarray(self._coordinates), axis=-1)
        mask = mask[0:-1, 0:-1] | mask[1:, 1:] | mask[0:-1, 1:] | mask[1:, 0:-1]
        arr = self.get_array()
        if arr is not None:
            arr = np.ma.getmaskarray(arr)
            if arr.ndim == 3:
                mask |= np.any(arr, axis=-1)
            elif arr.ndim == 2:
                mask |= arr
            else:
                mask |= arr.reshape(self._coordinates[:-1, :-1, :].shape[:2])
        return ~mask

    def _set_unmasked_verts(self):
        X = self._coordinates[..., 0]
        Y = self._coordinates[..., 1]
        unmask = self._get_unmasked_polys()
        X1 = np.ma.filled(X[:-1, :-1])[unmask]
        Y1 = np.ma.filled(Y[:-1, :-1])[unmask]
        X2 = np.ma.filled(X[1:, :-1])[unmask]
        Y2 = np.ma.filled(Y[1:, :-1])[unmask]
        X3 = np.ma.filled(X[1:, 1:])[unmask]
        Y3 = np.ma.filled(Y[1:, 1:])[unmask]
        X4 = np.ma.filled(X[:-1, 1:])[unmask]
        Y4 = np.ma.filled(Y[:-1, 1:])[unmask]
        npoly = len(X1)
        xy = np.ma.stack([X1, Y1, X2, Y2, X3, Y3, X4, Y4, X1, Y1], axis=-1)
        verts = xy.reshape((npoly, 5, 2))
        self.set_verts(verts)

    def get_edgecolor(self):
        ec = super().get_edgecolor()
        unmasked_polys = self._get_unmasked_polys().ravel()
        if len(ec) != len(unmasked_polys):
            return ec
        return ec[unmasked_polys, :]

    def get_facecolor(self):
        fc = super().get_facecolor()
        unmasked_polys = self._get_unmasked_polys().ravel()
        if len(fc) != len(unmasked_polys):
            return fc
        return fc[unmasked_polys, :]

    def set_array(self, A):
        prev_unmask = self._get_unmasked_polys()
        super().set_array(A)
        if not np.array_equal(prev_unmask, self._get_unmasked_polys()):
            self._set_unmasked_verts()

# File: matplotlib-main/lib/matplotlib/colorbar.py
""""""
import logging
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, collections, cm, colors, contour, ticker
import matplotlib.artist as martist
import matplotlib.patches as mpatches
import matplotlib.path as mpath
import matplotlib.spines as mspines
import matplotlib.transforms as mtransforms
from matplotlib import _docstring
_log = logging.getLogger(__name__)
_docstring.interpd.update(_make_axes_kw_doc="\nlocation : None or {'left', 'right', 'top', 'bottom'}\n    The location, relative to the parent Axes, where the colorbar Axes\n    is created.  It also determines the *orientation* of the colorbar\n    (colorbars on the left and right are vertical, colorbars at the top\n    and bottom are horizontal).  If None, the location will come from the\n    *orientation* if it is set (vertical colorbars on the right, horizontal\n    ones at the bottom), or default to 'right' if *orientation* is unset.\n\norientation : None or {'vertical', 'horizontal'}\n    The orientation of the colorbar.  It is preferable to set the *location*\n    of the colorbar, as that also determines the *orientation*; passing\n    incompatible values for *location* and *orientation* raises an exception.\n\nfraction : float, default: 0.15\n    Fraction of original Axes to use for colorbar.\n\nshrink : float, default: 1.0\n    Fraction by which to multiply the size of the colorbar.\n\naspect : float, default: 20\n    Ratio of long to short dimensions.\n\npad : float, default: 0.05 if vertical, 0.15 if horizontal\n    Fraction of original Axes between colorbar and new image Axes.\n\nanchor : (float, float), optional\n    The anchor point of the colorbar Axes.\n    Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal.\n\npanchor : (float, float), or *False*, optional\n    The anchor point of the colorbar parent Axes. If *False*, the parent\n    axes' anchor will be unchanged.\n    Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal.", _colormap_kw_doc='\nextend : {\'neither\', \'both\', \'min\', \'max\'}\n    Make pointed end(s) for out-of-range values (unless \'neither\').  These are\n    set for a given colormap using the colormap set_under and set_over methods.\n\nextendfrac : {*None*, \'auto\', length, lengths}\n    If set to *None*, both the minimum and maximum triangular colorbar\n    extensions will have a length of 5% of the interior colorbar length (this\n    is the default setting).\n\n    If set to \'auto\', makes the triangular colorbar extensions the same lengths\n    as the interior boxes (when *spacing* is set to \'uniform\') or the same\n    lengths as the respective adjacent interior boxes (when *spacing* is set to\n    \'proportional\').\n\n    If a scalar, indicates the length of both the minimum and maximum\n    triangular colorbar extensions as a fraction of the interior colorbar\n    length.  A two-element sequence of fractions may also be given, indicating\n    the lengths of the minimum and maximum colorbar extensions respectively as\n    a fraction of the interior colorbar length.\n\nextendrect : bool\n    If *False* the minimum and maximum colorbar extensions will be triangular\n    (the default).  If *True* the extensions will be rectangular.\n\nspacing : {\'uniform\', \'proportional\'}\n    For discrete colorbars (`.BoundaryNorm` or contours), \'uniform\' gives each\n    color the same space; \'proportional\' makes the space proportional to the\n    data interval.\n\nticks : None or list of ticks or Locator\n    If None, ticks are determined automatically from the input.\n\nformat : None or str or Formatter\n    If None, `~.ticker.ScalarFormatter` is used.\n    Format strings, e.g., ``"%4.2e"`` or ``"{x:.2e}"``, are supported.\n    An alternative `~.ticker.Formatter` may be given instead.\n\ndrawedges : bool\n    Whether to draw lines at color boundaries.\n\nlabel : str\n    The label on the colorbar\'s long axis.\n\nboundaries, values : None or a sequence\n    If unset, the colormap will be displayed on a 0-1 scale.\n    If sequences, *values* must have a length 1 less than *boundaries*.  For\n    each region delimited by adjacent entries in *boundaries*, the color mapped\n    to the corresponding value in values will be used.\n    Normally only useful for indexed colors (i.e. ``norm=NoNorm()``) or other\n    unusual circumstances.')

def _set_ticks_on_axis_warn(*args, **kwargs):
    _api.warn_external('Use the colorbar set_ticks() method instead.')

class _ColorbarSpine(mspines.Spine):

    def __init__(self, axes):
        self._ax = axes
        super().__init__(axes, 'colorbar', mpath.Path(np.empty((0, 2))))
        mpatches.Patch.set_transform(self, axes.transAxes)

    def get_window_extent(self, renderer=None):
        return mpatches.Patch.get_window_extent(self, renderer=renderer)

    def set_xy(self, xy):
        self._path = mpath.Path(xy, closed=True)
        self._xy = xy
        self.stale = True

    def draw(self, renderer):
        ret = mpatches.Patch.draw(self, renderer)
        self.stale = False
        return ret

class _ColorbarAxesLocator:

    def __init__(self, cbar):
        self._cbar = cbar
        self._orig_locator = cbar.ax._axes_locator

    def __call__(self, ax, renderer):
        if self._orig_locator is not None:
            pos = self._orig_locator(ax, renderer)
        else:
            pos = ax.get_position(original=True)
        if self._cbar.extend == 'neither':
            return pos
        (y, extendlen) = self._cbar._proportional_y()
        if not self._cbar._extend_lower():
            extendlen[0] = 0
        if not self._cbar._extend_upper():
            extendlen[1] = 0
        len = sum(extendlen) + 1
        shrink = 1 / len
        offset = extendlen[0] / len
        if hasattr(ax, '_colorbar_info'):
            aspect = ax._colorbar_info['aspect']
        else:
            aspect = False
        if self._cbar.orientation == 'vertical':
            if aspect:
                self._cbar.ax.set_box_aspect(aspect * shrink)
            pos = pos.shrunk(1, shrink).translated(0, offset * pos.height)
        else:
            if aspect:
                self._cbar.ax.set_box_aspect(1 / (aspect * shrink))
            pos = pos.shrunk(shrink, 1).translated(offset * pos.width, 0)
        return pos

    def get_subplotspec(self):
        return self._cbar.ax.get_subplotspec() or getattr(self._orig_locator, 'get_subplotspec', lambda : None)()

@_docstring.interpd
class Colorbar:
    n_rasterize = 50

    def __init__(self, ax, mappable=None, *, cmap=None, norm=None, alpha=None, values=None, boundaries=None, orientation=None, ticklocation='auto', extend=None, spacing='uniform', ticks=None, format=None, drawedges=False, extendfrac=None, extendrect=False, label='', location=None):
        if mappable is None:
            mappable = cm.ScalarMappable(norm=norm, cmap=cmap)
        self.mappable = mappable
        cmap = mappable.cmap
        norm = mappable.norm
        filled = True
        if isinstance(mappable, contour.ContourSet):
            cs = mappable
            alpha = cs.get_alpha()
            boundaries = cs._levels
            values = cs.cvalues
            extend = cs.extend
            filled = cs.filled
            if ticks is None:
                ticks = ticker.FixedLocator(cs.levels, nbins=10)
        elif isinstance(mappable, martist.Artist):
            alpha = mappable.get_alpha()
        mappable.colorbar = self
        mappable.colorbar_cid = mappable.callbacks.connect('changed', self.update_normal)
        location_orientation = _get_orientation_from_location(location)
        _api.check_in_list([None, 'vertical', 'horizontal'], orientation=orientation)
        _api.check_in_list(['auto', 'left', 'right', 'top', 'bottom'], ticklocation=ticklocation)
        _api.check_in_list(['uniform', 'proportional'], spacing=spacing)
        if location_orientation is not None and orientation is not None:
            if location_orientation != orientation:
                raise TypeError('location and orientation are mutually exclusive')
        else:
            orientation = orientation or location_orientation or 'vertical'
        self.ax = ax
        self.ax._axes_locator = _ColorbarAxesLocator(self)
        if extend is None:
            if not isinstance(mappable, contour.ContourSet) and getattr(cmap, 'colorbar_extend', False) is not False:
                extend = cmap.colorbar_extend
            elif hasattr(norm, 'extend'):
                extend = norm.extend
            else:
                extend = 'neither'
        self.alpha = None
        self.set_alpha(alpha)
        self.cmap = cmap
        self.norm = norm
        self.values = values
        self.boundaries = boundaries
        self.extend = extend
        self._inside = _api.check_getitem({'neither': slice(0, None), 'both': slice(1, -1), 'min': slice(1, None), 'max': slice(0, -1)}, extend=extend)
        self.spacing = spacing
        self.orientation = orientation
        self.drawedges = drawedges
        self._filled = filled
        self.extendfrac = extendfrac
        self.extendrect = extendrect
        self._extend_patches = []
        self.solids = None
        self.solids_patches = []
        self.lines = []
        for spine in self.ax.spines.values():
            spine.set_visible(False)
        self.outline = self.ax.spines['outline'] = _ColorbarSpine(self.ax)
        self.dividers = collections.LineCollection([], colors=[mpl.rcParams['axes.edgecolor']], linewidths=[0.5 * mpl.rcParams['axes.linewidth']], clip_on=False)
        self.ax.add_collection(self.dividers)
        self._locator = None
        self._minorlocator = None
        self._formatter = None
        self._minorformatter = None
        if ticklocation == 'auto':
            ticklocation = _get_ticklocation_from_orientation(orientation) if location is None else location
        self.ticklocation = ticklocation
        self.set_label(label)
        self._reset_locator_formatter_scale()
        if np.iterable(ticks):
            self._locator = ticker.FixedLocator(ticks, nbins=len(ticks))
        else:
            self._locator = ticks
        if isinstance(format, str):
            try:
                self._formatter = ticker.FormatStrFormatter(format)
                _ = self._formatter(0)
            except (TypeError, ValueError):
                self._formatter = ticker.StrMethodFormatter(format)
        else:
            self._formatter = format
        self._draw_all()
        if isinstance(mappable, contour.ContourSet) and (not mappable.filled):
            self.add_lines(mappable)
        self.ax._colorbar = self
        if isinstance(self.norm, (colors.BoundaryNorm, colors.NoNorm)) or isinstance(self.mappable, contour.ContourSet):
            self.ax.set_navigate(False)
        self._interactive_funcs = ['_get_view', '_set_view', '_set_view_from_bbox', 'drag_pan']
        for x in self._interactive_funcs:
            setattr(self.ax, x, getattr(self, x))
        self.ax.cla = self._cbar_cla
        self._extend_cid1 = self.ax.callbacks.connect('xlim_changed', self._do_extends)
        self._extend_cid2 = self.ax.callbacks.connect('ylim_changed', self._do_extends)

    @property
    def locator(self):
        return self._long_axis().get_major_locator()

    @locator.setter
    def locator(self, loc):
        self._long_axis().set_major_locator(loc)
        self._locator = loc

    @property
    def minorlocator(self):
        return self._long_axis().get_minor_locator()

    @minorlocator.setter
    def minorlocator(self, loc):
        self._long_axis().set_minor_locator(loc)
        self._minorlocator = loc

    @property
    def formatter(self):
        return self._long_axis().get_major_formatter()

    @formatter.setter
    def formatter(self, fmt):
        self._long_axis().set_major_formatter(fmt)
        self._formatter = fmt

    @property
    def minorformatter(self):
        return self._long_axis().get_minor_formatter()

    @minorformatter.setter
    def minorformatter(self, fmt):
        self._long_axis().set_minor_formatter(fmt)
        self._minorformatter = fmt

    def _cbar_cla(self):
        for x in self._interactive_funcs:
            delattr(self.ax, x)
        del self.ax.cla
        self.ax.cla()

    def update_normal(self, mappable):
        _log.debug('colorbar update normal %r %r', mappable.norm, self.norm)
        self.mappable = mappable
        self.set_alpha(mappable.get_alpha())
        self.cmap = mappable.cmap
        if mappable.norm != self.norm:
            self.norm = mappable.norm
            self._reset_locator_formatter_scale()
        self._draw_all()
        if isinstance(self.mappable, contour.ContourSet):
            CS = self.mappable
            if not CS.filled:
                self.add_lines(CS)
        self.stale = True

    def _draw_all(self):
        if self.orientation == 'vertical':
            if mpl.rcParams['ytick.minor.visible']:
                self.minorticks_on()
        elif mpl.rcParams['xtick.minor.visible']:
            self.minorticks_on()
        self._long_axis().set(label_position=self.ticklocation, ticks_position=self.ticklocation)
        self._short_axis().set_ticks([])
        self._short_axis().set_ticks([], minor=True)
        self._process_values()
        (self.vmin, self.vmax) = self._boundaries[self._inside][[0, -1]]
        (X, Y) = self._mesh()
        self._do_extends()
        (lower, upper) = (self.vmin, self.vmax)
        if self._long_axis().get_inverted():
            (lower, upper) = (upper, lower)
        if self.orientation == 'vertical':
            self.ax.set_xlim(0, 1)
            self.ax.set_ylim(lower, upper)
        else:
            self.ax.set_ylim(0, 1)
            self.ax.set_xlim(lower, upper)
        self.update_ticks()
        if self._filled:
            ind = np.arange(len(self._values))
            if self._extend_lower():
                ind = ind[1:]
            if self._extend_upper():
                ind = ind[:-1]
            self._add_solids(X, Y, self._values[ind, np.newaxis])

    def _add_solids(self, X, Y, C):
        if self.solids is not None:
            self.solids.remove()
        for solid in self.solids_patches:
            solid.remove()
        mappable = getattr(self, 'mappable', None)
        if isinstance(mappable, contour.ContourSet) and any((hatch is not None for hatch in mappable.hatches)):
            self._add_solids_patches(X, Y, C, mappable)
        else:
            self.solids = self.ax.pcolormesh(X, Y, C, cmap=self.cmap, norm=self.norm, alpha=self.alpha, edgecolors='none', shading='flat')
            if not self.drawedges:
                if len(self._y) >= self.n_rasterize:
                    self.solids.set_rasterized(True)
        self._update_dividers()

    def _update_dividers(self):
        if not self.drawedges:
            self.dividers.set_segments([])
            return
        if self.orientation == 'vertical':
            lims = self.ax.get_ylim()
            bounds = (lims[0] < self._y) & (self._y < lims[1])
        else:
            lims = self.ax.get_xlim()
            bounds = (lims[0] < self._y) & (self._y < lims[1])
        y = self._y[bounds]
        if self._extend_lower():
            y = np.insert(y, 0, lims[0])
        if self._extend_upper():
            y = np.append(y, lims[1])
        (X, Y) = np.meshgrid([0, 1], y)
        if self.orientation == 'vertical':
            segments = np.dstack([X, Y])
        else:
            segments = np.dstack([Y, X])
        self.dividers.set_segments(segments)

    def _add_solids_patches(self, X, Y, C, mappable):
        hatches = mappable.hatches * (len(C) + 1)
        if self._extend_lower():
            hatches = hatches[1:]
        patches = []
        for i in range(len(X) - 1):
            xy = np.array([[X[i, 0], Y[i, 1]], [X[i, 1], Y[i, 0]], [X[i + 1, 1], Y[i + 1, 0]], [X[i + 1, 0], Y[i + 1, 1]]])
            patch = mpatches.PathPatch(mpath.Path(xy), facecolor=self.cmap(self.norm(C[i][0])), hatch=hatches[i], linewidth=0, antialiased=False, alpha=self.alpha)
            self.ax.add_patch(patch)
            patches.append(patch)
        self.solids_patches = patches

    def _do_extends(self, ax=None):
        for patch in self._extend_patches:
            patch.remove()
        self._extend_patches = []
        (_, extendlen) = self._proportional_y()
        bot = 0 - (extendlen[0] if self._extend_lower() else 0)
        top = 1 + (extendlen[1] if self._extend_upper() else 0)
        if not self.extendrect:
            xyout = np.array([[0, 0], [0.5, bot], [1, 0], [1, 1], [0.5, top], [0, 1], [0, 0]])
        else:
            xyout = np.array([[0, 0], [0, bot], [1, bot], [1, 0], [1, 1], [1, top], [0, top], [0, 1], [0, 0]])
        if self.orientation == 'horizontal':
            xyout = xyout[:, ::-1]
        self.outline.set_xy(xyout)
        if not self._filled:
            return
        mappable = getattr(self, 'mappable', None)
        if isinstance(mappable, contour.ContourSet) and any((hatch is not None for hatch in mappable.hatches)):
            hatches = mappable.hatches * (len(self._y) + 1)
        else:
            hatches = [None] * (len(self._y) + 1)
        if self._extend_lower():
            if not self.extendrect:
                xy = np.array([[0, 0], [0.5, bot], [1, 0]])
            else:
                xy = np.array([[0, 0], [0, bot], [1.0, bot], [1, 0]])
            if self.orientation == 'horizontal':
                xy = xy[:, ::-1]
            val = -1 if self._long_axis().get_inverted() else 0
            color = self.cmap(self.norm(self._values[val]))
            patch = mpatches.PathPatch(mpath.Path(xy), facecolor=color, alpha=self.alpha, linewidth=0, antialiased=False, transform=self.ax.transAxes, hatch=hatches[0], clip_on=False, zorder=np.nextafter(self.ax.patch.zorder, -np.inf))
            self.ax.add_patch(patch)
            self._extend_patches.append(patch)
            hatches = hatches[1:]
        if self._extend_upper():
            if not self.extendrect:
                xy = np.array([[0, 1], [0.5, top], [1, 1]])
            else:
                xy = np.array([[0, 1], [0, top], [1, top], [1, 1]])
            if self.orientation == 'horizontal':
                xy = xy[:, ::-1]
            val = 0 if self._long_axis().get_inverted() else -1
            color = self.cmap(self.norm(self._values[val]))
            hatch_idx = len(self._y) - 1
            patch = mpatches.PathPatch(mpath.Path(xy), facecolor=color, alpha=self.alpha, linewidth=0, antialiased=False, transform=self.ax.transAxes, hatch=hatches[hatch_idx], clip_on=False, zorder=np.nextafter(self.ax.patch.zorder, -np.inf))
            self.ax.add_patch(patch)
            self._extend_patches.append(patch)
        self._update_dividers()

    def add_lines(self, *args, **kwargs):
        params = _api.select_matching_signature([lambda self, CS, erase=True: locals(), lambda self, levels, colors, linewidths, erase=True: locals()], self, *args, **kwargs)
        if 'CS' in params:
            (self, cs, erase) = params.values()
            if not isinstance(cs, contour.ContourSet) or cs.filled:
                raise ValueError('If a single artist is passed to add_lines, it must be a ContourSet of lines')
            return self.add_lines(cs.levels, cs.to_rgba(cs.cvalues, cs.alpha), cs.get_linewidths(), erase=erase)
        else:
            (self, levels, colors, linewidths, erase) = params.values()
        y = self._locate(levels)
        rtol = (self._y[-1] - self._y[0]) * 1e-10
        igood = (y < self._y[-1] + rtol) & (y > self._y[0] - rtol)
        y = y[igood]
        if np.iterable(colors):
            colors = np.asarray(colors)[igood]
        if np.iterable(linewidths):
            linewidths = np.asarray(linewidths)[igood]
        (X, Y) = np.meshgrid([0, 1], y)
        if self.orientation == 'vertical':
            xy = np.stack([X, Y], axis=-1)
        else:
            xy = np.stack([Y, X], axis=-1)
        col = collections.LineCollection(xy, linewidths=linewidths, colors=colors)
        if erase and self.lines:
            for lc in self.lines:
                lc.remove()
            self.lines = []
        self.lines.append(col)
        fac = np.max(linewidths) / 72
        xy = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])
        inches = self.ax.get_figure().dpi_scale_trans
        xy = inches.inverted().transform(self.ax.transAxes.transform(xy))
        xy[[0, 1, 4], 1] -= fac
        xy[[2, 3], 1] += fac
        xy = self.ax.transAxes.inverted().transform(inches.transform(xy))
        col.set_clip_path(mpath.Path(xy, closed=True), self.ax.transAxes)
        self.ax.add_collection(col)
        self.stale = True

    def update_ticks(self):
        self._get_ticker_locator_formatter()
        self._long_axis().set_major_locator(self._locator)
        self._long_axis().set_minor_locator(self._minorlocator)
        self._long_axis().set_major_formatter(self._formatter)

    def _get_ticker_locator_formatter(self):
        locator = self._locator
        formatter = self._formatter
        minorlocator = self._minorlocator
        if isinstance(self.norm, colors.BoundaryNorm):
            b = self.norm.boundaries
            if locator is None:
                locator = ticker.FixedLocator(b, nbins=10)
            if minorlocator is None:
                minorlocator = ticker.FixedLocator(b)
        elif isinstance(self.norm, colors.NoNorm):
            if locator is None:
                nv = len(self._values)
                base = 1 + int(nv / 10)
                locator = ticker.IndexLocator(base=base, offset=0.5)
        elif self.boundaries is not None:
            b = self._boundaries[self._inside]
            if locator is None:
                locator = ticker.FixedLocator(b, nbins=10)
        else:
            if locator is None:
                locator = self._long_axis().get_major_locator()
            if minorlocator is None:
                minorlocator = self._long_axis().get_minor_locator()
        if minorlocator is None:
            minorlocator = ticker.NullLocator()
        if formatter is None:
            formatter = self._long_axis().get_major_formatter()
        self._locator = locator
        self._formatter = formatter
        self._minorlocator = minorlocator
        _log.debug('locator: %r', locator)

    def set_ticks(self, ticks, *, labels=None, minor=False, **kwargs):
        if np.iterable(ticks):
            self._long_axis().set_ticks(ticks, labels=labels, minor=minor, **kwargs)
            self._locator = self._long_axis().get_major_locator()
        else:
            self._locator = ticks
            self._long_axis().set_major_locator(self._locator)
        self.stale = True

    def get_ticks(self, minor=False):
        if minor:
            return self._long_axis().get_minorticklocs()
        else:
            return self._long_axis().get_majorticklocs()

    def set_ticklabels(self, ticklabels, *, minor=False, **kwargs):
        self._long_axis().set_ticklabels(ticklabels, minor=minor, **kwargs)

    def minorticks_on(self):
        self.ax.minorticks_on()
        self._short_axis().set_minor_locator(ticker.NullLocator())

    def minorticks_off(self):
        self._minorlocator = ticker.NullLocator()
        self._long_axis().set_minor_locator(self._minorlocator)

    def set_label(self, label, *, loc=None, **kwargs):
        if self.orientation == 'vertical':
            self.ax.set_ylabel(label, loc=loc, **kwargs)
        else:
            self.ax.set_xlabel(label, loc=loc, **kwargs)
        self.stale = True

    def set_alpha(self, alpha):
        self.alpha = None if isinstance(alpha, np.ndarray) else alpha

    def _set_scale(self, scale, **kwargs):
        self._long_axis()._set_axes_scale(scale, **kwargs)

    def remove(self):
        if hasattr(self.ax, '_colorbar_info'):
            parents = self.ax._colorbar_info['parents']
            for a in parents:
                if self.ax in a._colorbars:
                    a._colorbars.remove(self.ax)
        self.ax.remove()
        self.mappable.callbacks.disconnect(self.mappable.colorbar_cid)
        self.mappable.colorbar = None
        self.mappable.colorbar_cid = None
        self.ax.callbacks.disconnect(self._extend_cid1)
        self.ax.callbacks.disconnect(self._extend_cid2)
        try:
            ax = self.mappable.axes
        except AttributeError:
            return
        try:
            subplotspec = self.ax.get_subplotspec().get_gridspec()._subplot_spec
        except AttributeError:
            pos = ax.get_position(original=True)
            ax._set_position(pos)
        else:
            ax.set_subplotspec(subplotspec)

    def _process_values(self):
        if self.values is not None:
            self._values = np.array(self.values)
            if self.boundaries is None:
                b = np.zeros(len(self.values) + 1)
                b[1:-1] = 0.5 * (self._values[:-1] + self._values[1:])
                b[0] = 2.0 * b[1] - b[2]
                b[-1] = 2.0 * b[-2] - b[-3]
                self._boundaries = b
                return
            self._boundaries = np.array(self.boundaries)
            return
        if isinstance(self.norm, colors.BoundaryNorm):
            b = self.norm.boundaries
        elif isinstance(self.norm, colors.NoNorm):
            b = np.arange(self.cmap.N + 1) - 0.5
        elif self.boundaries is not None:
            b = self.boundaries
        else:
            N = self.cmap.N + 1
            (b, _) = self._uniform_y(N)
        if self._extend_lower():
            b = np.hstack((b[0] - 1, b))
        if self._extend_upper():
            b = np.hstack((b, b[-1] + 1))
        if self.mappable.get_array() is not None:
            self.mappable.autoscale_None()
        if not self.norm.scaled():
            self.norm.vmin = 0
            self.norm.vmax = 1
        (self.norm.vmin, self.norm.vmax) = mtransforms.nonsingular(self.norm.vmin, self.norm.vmax, expander=0.1)
        if not isinstance(self.norm, colors.BoundaryNorm) and self.boundaries is None:
            b = self.norm.inverse(b)
        self._boundaries = np.asarray(b, dtype=float)
        self._values = 0.5 * (self._boundaries[:-1] + self._boundaries[1:])
        if isinstance(self.norm, colors.NoNorm):
            self._values = (self._values + 1e-05).astype(np.int16)

    def _mesh(self):
        (y, _) = self._proportional_y()
        if isinstance(self.norm, (colors.BoundaryNorm, colors.NoNorm)) or self.boundaries is not None:
            y = y * (self.vmax - self.vmin) + self.vmin
        else:
            with self.norm.callbacks.blocked(), cbook._setattr_cm(self.norm, vmin=self.vmin, vmax=self.vmax):
                y = self.norm.inverse(y)
        self._y = y
        (X, Y) = np.meshgrid([0.0, 1.0], y)
        if self.orientation == 'vertical':
            return (X, Y)
        else:
            return (Y, X)

    def _forward_boundaries(self, x):
        b = self._boundaries
        y = np.interp(x, b, np.linspace(0, 1, len(b)))
        eps = (b[-1] - b[0]) * 1e-06
        y[x < b[0] - eps] = -1
        y[x > b[-1] + eps] = 2
        return y

    def _inverse_boundaries(self, x):
        b = self._boundaries
        return np.interp(x, np.linspace(0, 1, len(b)), b)

    def _reset_locator_formatter_scale(self):
        self._process_values()
        self._locator = None
        self._minorlocator = None
        self._formatter = None
        self._minorformatter = None
        if isinstance(self.mappable, contour.ContourSet) and isinstance(self.norm, colors.LogNorm):
            self._set_scale('log')
        elif self.boundaries is not None or isinstance(self.norm, colors.BoundaryNorm):
            if self.spacing == 'uniform':
                funcs = (self._forward_boundaries, self._inverse_boundaries)
                self._set_scale('function', functions=funcs)
            elif self.spacing == 'proportional':
                self._set_scale('linear')
        elif getattr(self.norm, '_scale', None):
            self._set_scale(self.norm._scale)
        elif type(self.norm) is colors.Normalize:
            self._set_scale('linear')
        else:
            funcs = (self.norm, self.norm.inverse)
            self._set_scale('function', functions=funcs)

    def _locate(self, x):
        if isinstance(self.norm, (colors.NoNorm, colors.BoundaryNorm)):
            b = self._boundaries
            xn = x
        else:
            b = self.norm(self._boundaries, clip=False).filled()
            xn = self.norm(x, clip=False).filled()
        bunique = b[self._inside]
        yunique = self._y
        z = np.interp(xn, bunique, yunique)
        return z

    def _uniform_y(self, N):
        automin = automax = 1.0 / (N - 1.0)
        extendlength = self._get_extension_lengths(self.extendfrac, automin, automax, default=0.05)
        y = np.linspace(0, 1, N)
        return (y, extendlength)

    def _proportional_y(self):
        if isinstance(self.norm, colors.BoundaryNorm) or self.boundaries is not None:
            y = self._boundaries - self._boundaries[self._inside][0]
            y = y / (self._boundaries[self._inside][-1] - self._boundaries[self._inside][0])
            if self.spacing == 'uniform':
                yscaled = self._forward_boundaries(self._boundaries)
            else:
                yscaled = y
        else:
            y = self.norm(self._boundaries.copy())
            y = np.ma.filled(y, np.nan)
            yscaled = y
        y = y[self._inside]
        yscaled = yscaled[self._inside]
        norm = colors.Normalize(y[0], y[-1])
        y = np.ma.filled(norm(y), np.nan)
        norm = colors.Normalize(yscaled[0], yscaled[-1])
        yscaled = np.ma.filled(norm(yscaled), np.nan)
        automin = yscaled[1] - yscaled[0]
        automax = yscaled[-1] - yscaled[-2]
        extendlength = [0, 0]
        if self._extend_lower() or self._extend_upper():
            extendlength = self._get_extension_lengths(self.extendfrac, automin, automax, default=0.05)
        return (y, extendlength)

    def _get_extension_lengths(self, frac, automin, automax, default=0.05):
        extendlength = np.array([default, default])
        if isinstance(frac, str):
            _api.check_in_list(['auto'], extendfrac=frac.lower())
            extendlength[:] = [automin, automax]
        elif frac is not None:
            try:
                extendlength[:] = frac
                if np.isnan(extendlength).any():
                    raise ValueError()
            except (TypeError, ValueError) as err:
                raise ValueError('invalid value for extendfrac') from err
        return extendlength

    def _extend_lower(self):
        minmax = 'max' if self._long_axis().get_inverted() else 'min'
        return self.extend in ('both', minmax)

    def _extend_upper(self):
        minmax = 'min' if self._long_axis().get_inverted() else 'max'
        return self.extend in ('both', minmax)

    def _long_axis(self):
        if self.orientation == 'vertical':
            return self.ax.yaxis
        return self.ax.xaxis

    def _short_axis(self):
        if self.orientation == 'vertical':
            return self.ax.xaxis
        return self.ax.yaxis

    def _get_view(self):
        return (self.norm.vmin, self.norm.vmax)

    def _set_view(self, view):
        (self.norm.vmin, self.norm.vmax) = view

    def _set_view_from_bbox(self, bbox, direction='in', mode=None, twinx=False, twiny=False):
        (new_xbound, new_ybound) = self.ax._prepare_view_from_bbox(bbox, direction=direction, mode=mode, twinx=twinx, twiny=twiny)
        if self.orientation == 'horizontal':
            (self.norm.vmin, self.norm.vmax) = new_xbound
        elif self.orientation == 'vertical':
            (self.norm.vmin, self.norm.vmax) = new_ybound

    def drag_pan(self, button, key, x, y):
        points = self.ax._get_pan_points(button, key, x, y)
        if points is not None:
            if self.orientation == 'horizontal':
                (self.norm.vmin, self.norm.vmax) = points[:, 0]
            elif self.orientation == 'vertical':
                (self.norm.vmin, self.norm.vmax) = points[:, 1]
ColorbarBase = Colorbar

def _normalize_location_orientation(location, orientation):
    if location is None:
        location = _get_ticklocation_from_orientation(orientation)
    loc_settings = _api.check_getitem({'left': {'location': 'left', 'anchor': (1.0, 0.5), 'panchor': (0.0, 0.5), 'pad': 0.1}, 'right': {'location': 'right', 'anchor': (0.0, 0.5), 'panchor': (1.0, 0.5), 'pad': 0.05}, 'top': {'location': 'top', 'anchor': (0.5, 0.0), 'panchor': (0.5, 1.0), 'pad': 0.05}, 'bottom': {'location': 'bottom', 'anchor': (0.5, 1.0), 'panchor': (0.5, 0.0), 'pad': 0.15}}, location=location)
    loc_settings['orientation'] = _get_orientation_from_location(location)
    if orientation is not None and orientation != loc_settings['orientation']:
        raise TypeError('location and orientation are mutually exclusive')
    return loc_settings

def _get_orientation_from_location(location):
    return _api.check_getitem({None: None, 'left': 'vertical', 'right': 'vertical', 'top': 'horizontal', 'bottom': 'horizontal'}, location=location)

def _get_ticklocation_from_orientation(orientation):
    return _api.check_getitem({None: 'right', 'vertical': 'right', 'horizontal': 'bottom'}, orientation=orientation)

@_docstring.interpd
def make_axes(parents, location=None, orientation=None, fraction=0.15, shrink=1.0, aspect=20, **kwargs):
    loc_settings = _normalize_location_orientation(location, orientation)
    kwargs['orientation'] = loc_settings['orientation']
    location = kwargs['ticklocation'] = loc_settings['location']
    anchor = kwargs.pop('anchor', loc_settings['anchor'])
    panchor = kwargs.pop('panchor', loc_settings['panchor'])
    aspect0 = aspect
    if isinstance(parents, np.ndarray):
        parents = list(parents.flat)
    elif np.iterable(parents):
        parents = list(parents)
    else:
        parents = [parents]
    fig = parents[0].get_figure()
    pad0 = 0.05 if fig.get_constrained_layout() else loc_settings['pad']
    pad = kwargs.pop('pad', pad0)
    if not all((fig is ax.get_figure() for ax in parents)):
        raise ValueError('Unable to create a colorbar Axes as not all parents share the same figure.')
    parents_bbox = mtransforms.Bbox.union([ax.get_position(original=True).frozen() for ax in parents])
    pb = parents_bbox
    if location in ('left', 'right'):
        if location == 'left':
            (pbcb, _, pb1) = pb.splitx(fraction, fraction + pad)
        else:
            (pb1, _, pbcb) = pb.splitx(1 - fraction - pad, 1 - fraction)
        pbcb = pbcb.shrunk(1.0, shrink).anchored(anchor, pbcb)
    else:
        if location == 'bottom':
            (pbcb, _, pb1) = pb.splity(fraction, fraction + pad)
        else:
            (pb1, _, pbcb) = pb.splity(1 - fraction - pad, 1 - fraction)
        pbcb = pbcb.shrunk(shrink, 1.0).anchored(anchor, pbcb)
        aspect = 1.0 / aspect
    shrinking_trans = mtransforms.BboxTransform(parents_bbox, pb1)
    for ax in parents:
        new_posn = shrinking_trans.transform(ax.get_position(original=True))
        new_posn = mtransforms.Bbox(new_posn)
        ax._set_position(new_posn)
        if panchor is not False:
            ax.set_anchor(panchor)
    cax = fig.add_axes(pbcb, label='<colorbar>')
    for a in parents:
        a._colorbars += [cax]
    cax._colorbar_info = dict(parents=parents, location=location, shrink=shrink, anchor=anchor, panchor=panchor, fraction=fraction, aspect=aspect0, pad=pad)
    cax.set_anchor(anchor)
    cax.set_box_aspect(aspect)
    cax.set_aspect('auto')
    return (cax, kwargs)

@_docstring.interpd
def make_axes_gridspec(parent, *, location=None, orientation=None, fraction=0.15, shrink=1.0, aspect=20, **kwargs):
    loc_settings = _normalize_location_orientation(location, orientation)
    kwargs['orientation'] = loc_settings['orientation']
    location = kwargs['ticklocation'] = loc_settings['location']
    aspect0 = aspect
    anchor = kwargs.pop('anchor', loc_settings['anchor'])
    panchor = kwargs.pop('panchor', loc_settings['panchor'])
    pad = kwargs.pop('pad', loc_settings['pad'])
    wh_space = 2 * pad / (1 - pad)
    if location in ('left', 'right'):
        gs = parent.get_subplotspec().subgridspec(3, 2, wspace=wh_space, hspace=0, height_ratios=[(1 - anchor[1]) * (1 - shrink), shrink, anchor[1] * (1 - shrink)])
        if location == 'left':
            gs.set_width_ratios([fraction, 1 - fraction - pad])
            ss_main = gs[:, 1]
            ss_cb = gs[1, 0]
        else:
            gs.set_width_ratios([1 - fraction - pad, fraction])
            ss_main = gs[:, 0]
            ss_cb = gs[1, 1]
    else:
        gs = parent.get_subplotspec().subgridspec(2, 3, hspace=wh_space, wspace=0, width_ratios=[anchor[0] * (1 - shrink), shrink, (1 - anchor[0]) * (1 - shrink)])
        if location == 'top':
            gs.set_height_ratios([fraction, 1 - fraction - pad])
            ss_main = gs[1, :]
            ss_cb = gs[0, 1]
        else:
            gs.set_height_ratios([1 - fraction - pad, fraction])
            ss_main = gs[0, :]
            ss_cb = gs[1, 1]
        aspect = 1 / aspect
    parent.set_subplotspec(ss_main)
    if panchor is not False:
        parent.set_anchor(panchor)
    fig = parent.get_figure()
    cax = fig.add_subplot(ss_cb, label='<colorbar>')
    cax.set_anchor(anchor)
    cax.set_box_aspect(aspect)
    cax.set_aspect('auto')
    cax._colorbar_info = dict(location=location, parents=[parent], shrink=shrink, anchor=anchor, panchor=panchor, fraction=fraction, aspect=aspect0, pad=pad)
    return (cax, kwargs)

# File: matplotlib-main/lib/matplotlib/colors.py
""""""
import base64
from collections.abc import Sized, Sequence, Mapping
import functools
import importlib
import inspect
import io
import itertools
from numbers import Real
import re
from PIL import Image
from PIL.PngImagePlugin import PngInfo
import matplotlib as mpl
import numpy as np
from matplotlib import _api, _cm, cbook, scale, _image
from ._color_data import BASE_COLORS, TABLEAU_COLORS, CSS4_COLORS, XKCD_COLORS

class _ColorMapping(dict):

    def __init__(self, mapping):
        super().__init__(mapping)
        self.cache = {}

    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self.cache.clear()

    def __delitem__(self, key):
        super().__delitem__(key)
        self.cache.clear()
_colors_full_map = {}
_colors_full_map.update(XKCD_COLORS)
_colors_full_map.update({k.replace('grey', 'gray'): v for (k, v) in XKCD_COLORS.items() if 'grey' in k})
_colors_full_map.update(CSS4_COLORS)
_colors_full_map.update(TABLEAU_COLORS)
_colors_full_map.update({k.replace('gray', 'grey'): v for (k, v) in TABLEAU_COLORS.items() if 'gray' in k})
_colors_full_map.update(BASE_COLORS)
_colors_full_map = _ColorMapping(_colors_full_map)
_REPR_PNG_SIZE = (512, 64)
_BIVAR_REPR_PNG_SIZE = 256

def get_named_colors_mapping():
    return _colors_full_map

class ColorSequenceRegistry(Mapping):
    _BUILTIN_COLOR_SEQUENCES = {'tab10': _cm._tab10_data, 'tab20': _cm._tab20_data, 'tab20b': _cm._tab20b_data, 'tab20c': _cm._tab20c_data, 'Pastel1': _cm._Pastel1_data, 'Pastel2': _cm._Pastel2_data, 'Paired': _cm._Paired_data, 'Accent': _cm._Accent_data, 'Dark2': _cm._Dark2_data, 'Set1': _cm._Set1_data, 'Set2': _cm._Set2_data, 'Set3': _cm._Set3_data, 'petroff10': _cm._petroff10_data}

    def __init__(self):
        self._color_sequences = {**self._BUILTIN_COLOR_SEQUENCES}

    def __getitem__(self, item):
        try:
            return list(self._color_sequences[item])
        except KeyError:
            raise KeyError(f'{item!r} is not a known color sequence name')

    def __iter__(self):
        return iter(self._color_sequences)

    def __len__(self):
        return len(self._color_sequences)

    def __str__(self):
        return 'ColorSequenceRegistry; available colormaps:\n' + ', '.join((f"'{name}'" for name in self))

    def register(self, name, color_list):
        if name in self._BUILTIN_COLOR_SEQUENCES:
            raise ValueError(f'{name!r} is a reserved name for a builtin color sequence')
        color_list = list(color_list)
        for color in color_list:
            try:
                to_rgba(color)
            except ValueError:
                raise ValueError(f'{color!r} is not a valid color specification')
        self._color_sequences[name] = color_list

    def unregister(self, name):
        if name in self._BUILTIN_COLOR_SEQUENCES:
            raise ValueError(f'Cannot unregister builtin color sequence {name!r}')
        self._color_sequences.pop(name, None)
_color_sequences = ColorSequenceRegistry()

def _sanitize_extrema(ex):
    if ex is None:
        return ex
    try:
        ret = ex.item()
    except AttributeError:
        ret = float(ex)
    return ret
_nth_color_re = re.compile('\\AC[0-9]+\\Z')

def _is_nth_color(c):
    return isinstance(c, str) and _nth_color_re.match(c)

def is_color_like(c):
    if _is_nth_color(c):
        return True
    try:
        to_rgba(c)
    except (TypeError, ValueError):
        return False
    else:
        return True

def _has_alpha_channel(c):
    return not isinstance(c, str) and len(c) == 4

def _check_color_like(**kwargs):
    for (k, v) in kwargs.items():
        if not is_color_like(v):
            raise ValueError(f"{v!r} is not a valid value for {k}: supported inputs are (r, g, b) and (r, g, b, a) 0-1 float tuples; '#rrggbb', '#rrggbbaa', '#rgb', '#rgba' strings; named color strings; string reprs of 0-1 floats for grayscale values; 'C0', 'C1', ... strings for colors of the color cycle; and pairs combining one of the above with an alpha value")

def same_color(c1, c2):
    c1 = to_rgba_array(c1)
    c2 = to_rgba_array(c2)
    n1 = max(c1.shape[0], 1)
    n2 = max(c2.shape[0], 1)
    if n1 != n2:
        raise ValueError('Different number of elements passed.')
    return c1.shape == c2.shape and (c1 == c2).all()

def to_rgba(c, alpha=None):
    if isinstance(c, tuple) and len(c) == 2:
        if alpha is None:
            (c, alpha) = c
        else:
            c = c[0]
    if _is_nth_color(c):
        prop_cycler = mpl.rcParams['axes.prop_cycle']
        colors = prop_cycler.by_key().get('color', ['k'])
        c = colors[int(c[1:]) % len(colors)]
    try:
        rgba = _colors_full_map.cache[c, alpha]
    except (KeyError, TypeError):
        rgba = None
    if rgba is None:
        rgba = _to_rgba_no_colorcycle(c, alpha)
        try:
            _colors_full_map.cache[c, alpha] = rgba
        except TypeError:
            pass
    return rgba

def _to_rgba_no_colorcycle(c, alpha=None):
    if alpha is not None and (not 0 <= alpha <= 1):
        raise ValueError("'alpha' must be between 0 and 1, inclusive")
    orig_c = c
    if c is np.ma.masked:
        return (0.0, 0.0, 0.0, 0.0)
    if isinstance(c, str):
        if c.lower() == 'none':
            return (0.0, 0.0, 0.0, 0.0)
        try:
            c = _colors_full_map[c]
        except KeyError:
            if len(orig_c) != 1:
                try:
                    c = _colors_full_map[c.lower()]
                except KeyError:
                    pass
    if isinstance(c, str):
        match = re.match('\\A#[a-fA-F0-9]{6}\\Z', c)
        if match:
            return tuple((int(n, 16) / 255 for n in [c[1:3], c[3:5], c[5:7]])) + (alpha if alpha is not None else 1.0,)
        match = re.match('\\A#[a-fA-F0-9]{3}\\Z', c)
        if match:
            return tuple((int(n, 16) / 255 for n in [c[1] * 2, c[2] * 2, c[3] * 2])) + (alpha if alpha is not None else 1.0,)
        match = re.match('\\A#[a-fA-F0-9]{8}\\Z', c)
        if match:
            color = [int(n, 16) / 255 for n in [c[1:3], c[3:5], c[5:7], c[7:9]]]
            if alpha is not None:
                color[-1] = alpha
            return tuple(color)
        match = re.match('\\A#[a-fA-F0-9]{4}\\Z', c)
        if match:
            color = [int(n, 16) / 255 for n in [c[1] * 2, c[2] * 2, c[3] * 2, c[4] * 2]]
            if alpha is not None:
                color[-1] = alpha
            return tuple(color)
        try:
            c = float(c)
        except ValueError:
            pass
        else:
            if not 0 <= c <= 1:
                raise ValueError(f'Invalid string grayscale value {orig_c!r}. Value must be within 0-1 range')
            return (c, c, c, alpha if alpha is not None else 1.0)
        raise ValueError(f'Invalid RGBA argument: {orig_c!r}')
    if isinstance(c, np.ndarray):
        if c.ndim == 2 and c.shape[0] == 1:
            c = c.reshape(-1)
    if not np.iterable(c):
        raise ValueError(f'Invalid RGBA argument: {orig_c!r}')
    if len(c) not in [3, 4]:
        raise ValueError('RGBA sequence should have length 3 or 4')
    if not all((isinstance(x, Real) for x in c)):
        raise ValueError(f'Invalid RGBA argument: {orig_c!r}')
    c = tuple(map(float, c))
    if len(c) == 3 and alpha is None:
        alpha = 1
    if alpha is not None:
        c = c[:3] + (alpha,)
    if any((elem < 0 or elem > 1 for elem in c)):
        raise ValueError('RGBA values should be within 0-1 range')
    return c

def to_rgba_array(c, alpha=None):
    if isinstance(c, tuple) and len(c) == 2 and isinstance(c[1], Real):
        if alpha is None:
            (c, alpha) = c
        else:
            c = c[0]
    if np.iterable(alpha):
        alpha = np.asarray(alpha).ravel()
    if isinstance(c, np.ndarray) and c.dtype.kind in 'if' and (c.ndim == 2) and (c.shape[1] in [3, 4]):
        mask = c.mask.any(axis=1) if np.ma.is_masked(c) else None
        c = np.ma.getdata(c)
        if np.iterable(alpha):
            if c.shape[0] == 1 and alpha.shape[0] > 1:
                c = np.tile(c, (alpha.shape[0], 1))
            elif c.shape[0] != alpha.shape[0]:
                raise ValueError('The number of colors must match the number of alpha values if there are more than one of each.')
        if c.shape[1] == 3:
            result = np.column_stack([c, np.zeros(len(c))])
            result[:, -1] = alpha if alpha is not None else 1.0
        elif c.shape[1] == 4:
            result = c.copy()
            if alpha is not None:
                result[:, -1] = alpha
        if mask is not None:
            result[mask] = 0
        if np.any((result < 0) | (result > 1)):
            raise ValueError('RGBA values should be within 0-1 range')
        return result
    if cbook._str_lower_equal(c, 'none'):
        return np.zeros((0, 4), float)
    try:
        if np.iterable(alpha):
            return np.array([to_rgba(c, a) for a in alpha], float)
        else:
            return np.array([to_rgba(c, alpha)], float)
    except TypeError:
        pass
    except ValueError as e:
        if e.args == ("'alpha' must be between 0 and 1, inclusive",):
            raise e
    if isinstance(c, str):
        raise ValueError(f'{c!r} is not a valid color value.')
    if len(c) == 0:
        return np.zeros((0, 4), float)
    if isinstance(c, Sequence):
        lens = {len(cc) if isinstance(cc, (list, tuple)) else -1 for cc in c}
        if lens == {3}:
            rgba = np.column_stack([c, np.ones(len(c))])
        elif lens == {4}:
            rgba = np.array(c)
        else:
            rgba = np.array([to_rgba(cc) for cc in c])
    else:
        rgba = np.array([to_rgba(cc) for cc in c])
    if alpha is not None:
        rgba[:, 3] = alpha
        if isinstance(c, Sequence):
            none_mask = [cbook._str_equal(cc, 'none') for cc in c]
            rgba[:, 3][none_mask] = 0
    return rgba

def to_rgb(c):
    return to_rgba(c)[:3]

def to_hex(c, keep_alpha=False):
    c = to_rgba(c)
    if not keep_alpha:
        c = c[:3]
    return '#' + ''.join((format(round(val * 255), '02x') for val in c))
cnames = CSS4_COLORS
hexColorPattern = re.compile('\\A#[a-fA-F0-9]{6}\\Z')
rgb2hex = to_hex
hex2color = to_rgb

class ColorConverter:
    colors = _colors_full_map
    cache = _colors_full_map.cache
    to_rgb = staticmethod(to_rgb)
    to_rgba = staticmethod(to_rgba)
    to_rgba_array = staticmethod(to_rgba_array)
colorConverter = ColorConverter()

def _create_lookup_table(N, data, gamma=1.0):
    if callable(data):
        xind = np.linspace(0, 1, N) ** gamma
        lut = np.clip(np.array(data(xind), dtype=float), 0, 1)
        return lut
    try:
        adata = np.array(data)
    except Exception as err:
        raise TypeError('data must be convertible to an array') from err
    _api.check_shape((None, 3), data=adata)
    x = adata[:, 0]
    y0 = adata[:, 1]
    y1 = adata[:, 2]
    if x[0] != 0.0 or x[-1] != 1.0:
        raise ValueError('data mapping points must start with x=0 and end with x=1')
    if (np.diff(x) < 0).any():
        raise ValueError('data mapping points must have x in increasing order')
    if N == 1:
        lut = np.array(y0[-1])
    else:
        x = x * (N - 1)
        xind = (N - 1) * np.linspace(0, 1, N) ** gamma
        ind = np.searchsorted(x, xind)[1:-1]
        distance = (xind[1:-1] - x[ind - 1]) / (x[ind] - x[ind - 1])
        lut = np.concatenate([[y1[0]], distance * (y0[ind] - y1[ind - 1]) + y1[ind - 1], [y0[-1]]])
    return np.clip(lut, 0.0, 1.0)

class Colormap:

    def __init__(self, name, N=256):
        self.name = name
        self.N = int(N)
        self._rgba_bad = (0.0, 0.0, 0.0, 0.0)
        self._rgba_under = None
        self._rgba_over = None
        self._i_under = self.N
        self._i_over = self.N + 1
        self._i_bad = self.N + 2
        self._isinit = False
        self.n_variates = 1
        self.colorbar_extend = False

    def __call__(self, X, alpha=None, bytes=False):
        (rgba, mask) = self._get_rgba_and_mask(X, alpha=alpha, bytes=bytes)
        if not np.iterable(X):
            rgba = tuple(rgba)
        return rgba

    def _get_rgba_and_mask(self, X, alpha=None, bytes=False):
        if not self._isinit:
            self._init()
        xa = np.array(X, copy=True)
        if not xa.dtype.isnative:
            xa = xa.byteswap().view(xa.dtype.newbyteorder())
        if xa.dtype.kind == 'f':
            xa *= self.N
            xa[xa == self.N] = self.N - 1
        mask_under = xa < 0
        mask_over = xa >= self.N
        mask_bad = X.mask if np.ma.is_masked(X) else np.isnan(xa)
        with np.errstate(invalid='ignore'):
            xa = xa.astype(int)
        xa[mask_under] = self._i_under
        xa[mask_over] = self._i_over
        xa[mask_bad] = self._i_bad
        lut = self._lut
        if bytes:
            lut = (lut * 255).astype(np.uint8)
        rgba = lut.take(xa, axis=0, mode='clip')
        if alpha is not None:
            alpha = np.clip(alpha, 0, 1)
            if bytes:
                alpha *= 255
            if alpha.shape not in [(), xa.shape]:
                raise ValueError(f'alpha is array-like but its shape {alpha.shape} does not match that of X {xa.shape}')
            rgba[..., -1] = alpha
            if (lut[-1] == 0).all():
                rgba[mask_bad] = (0, 0, 0, 0)
        return (rgba, mask_bad)

    def __copy__(self):
        cls = self.__class__
        cmapobject = cls.__new__(cls)
        cmapobject.__dict__.update(self.__dict__)
        if self._isinit:
            cmapobject._lut = np.copy(self._lut)
        return cmapobject

    def __eq__(self, other):
        if not isinstance(other, Colormap) or self.colorbar_extend != other.colorbar_extend:
            return False
        if not self._isinit:
            self._init()
        if not other._isinit:
            other._init()
        return np.array_equal(self._lut, other._lut)

    def get_bad(self):
        if not self._isinit:
            self._init()
        return np.array(self._lut[self._i_bad])

    def set_bad(self, color='k', alpha=None):
        self._rgba_bad = to_rgba(color, alpha)
        if self._isinit:
            self._set_extremes()

    def get_under(self):
        if not self._isinit:
            self._init()
        return np.array(self._lut[self._i_under])

    def set_under(self, color='k', alpha=None):
        self._rgba_under = to_rgba(color, alpha)
        if self._isinit:
            self._set_extremes()

    def get_over(self):
        if not self._isinit:
            self._init()
        return np.array(self._lut[self._i_over])

    def set_over(self, color='k', alpha=None):
        self._rgba_over = to_rgba(color, alpha)
        if self._isinit:
            self._set_extremes()

    def set_extremes(self, *, bad=None, under=None, over=None):
        if bad is not None:
            self.set_bad(bad)
        if under is not None:
            self.set_under(under)
        if over is not None:
            self.set_over(over)

    def with_extremes(self, *, bad=None, under=None, over=None):
        new_cm = self.copy()
        new_cm.set_extremes(bad=bad, under=under, over=over)
        return new_cm

    def _set_extremes(self):
        if self._rgba_under:
            self._lut[self._i_under] = self._rgba_under
        else:
            self._lut[self._i_under] = self._lut[0]
        if self._rgba_over:
            self._lut[self._i_over] = self._rgba_over
        else:
            self._lut[self._i_over] = self._lut[self.N - 1]
        self._lut[self._i_bad] = self._rgba_bad

    def _init(self):
        raise NotImplementedError('Abstract class only')

    def is_gray(self):
        if not self._isinit:
            self._init()
        return np.all(self._lut[:, 0] == self._lut[:, 1]) and np.all(self._lut[:, 0] == self._lut[:, 2])

    def resampled(self, lutsize):
        if hasattr(self, '_resample'):
            _api.warn_external(f'The ability to resample a color map is now public API However the class {type(self)} still only implements the previous private _resample method.  Please update your class.')
            return self._resample(lutsize)
        raise NotImplementedError()

    def reversed(self, name=None):
        raise NotImplementedError()

    def _repr_png_(self):
        X = np.tile(np.linspace(0, 1, _REPR_PNG_SIZE[0]), (_REPR_PNG_SIZE[1], 1))
        pixels = self(X, bytes=True)
        png_bytes = io.BytesIO()
        title = self.name + ' colormap'
        author = f'Matplotlib v{mpl.__version__}, https://matplotlib.org'
        pnginfo = PngInfo()
        pnginfo.add_text('Title', title)
        pnginfo.add_text('Description', title)
        pnginfo.add_text('Author', author)
        pnginfo.add_text('Software', author)
        Image.fromarray(pixels).save(png_bytes, format='png', pnginfo=pnginfo)
        return png_bytes.getvalue()

    def _repr_html_(self):
        png_bytes = self._repr_png_()
        png_base64 = base64.b64encode(png_bytes).decode('ascii')

        def color_block(color):
            hex_color = to_hex(color, keep_alpha=True)
            return f'<div title="{hex_color}" style="display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: {hex_color};"></div>'
        return f'<div style="vertical-align: middle;"><strong>{self.name}</strong> </div><div class="cmap"><img alt="{self.name} colormap" title="{self.name}" style="border: 1px solid #555;" src="data:image/png;base64,{png_base64}"></div><div style="vertical-align: middle; max-width: {_REPR_PNG_SIZE[0] + 2}px; display: flex; justify-content: space-between;"><div style="float: left;">{color_block(self.get_under())} under</div><div style="margin: 0 auto; display: inline-block;">bad {color_block(self.get_bad())}</div><div style="float: right;">over {color_block(self.get_over())}</div></div>'

    def copy(self):
        return self.__copy__()

class LinearSegmentedColormap(Colormap):

    def __init__(self, name, segmentdata, N=256, gamma=1.0):
        self.monochrome = False
        super().__init__(name, N)
        self._segmentdata = segmentdata
        self._gamma = gamma

    def _init(self):
        self._lut = np.ones((self.N + 3, 4), float)
        self._lut[:-3, 0] = _create_lookup_table(self.N, self._segmentdata['red'], self._gamma)
        self._lut[:-3, 1] = _create_lookup_table(self.N, self._segmentdata['green'], self._gamma)
        self._lut[:-3, 2] = _create_lookup_table(self.N, self._segmentdata['blue'], self._gamma)
        if 'alpha' in self._segmentdata:
            self._lut[:-3, 3] = _create_lookup_table(self.N, self._segmentdata['alpha'], 1)
        self._isinit = True
        self._set_extremes()

    def set_gamma(self, gamma):
        self._gamma = gamma
        self._init()

    @staticmethod
    def from_list(name, colors, N=256, gamma=1.0):
        if not np.iterable(colors):
            raise ValueError('colors must be iterable')
        if isinstance(colors[0], Sized) and len(colors[0]) == 2 and (not isinstance(colors[0], str)):
            (vals, colors) = zip(*colors)
        else:
            vals = np.linspace(0, 1, len(colors))
        (r, g, b, a) = to_rgba_array(colors).T
        cdict = {'red': np.column_stack([vals, r, r]), 'green': np.column_stack([vals, g, g]), 'blue': np.column_stack([vals, b, b]), 'alpha': np.column_stack([vals, a, a])}
        return LinearSegmentedColormap(name, cdict, N, gamma)

    def resampled(self, lutsize):
        new_cmap = LinearSegmentedColormap(self.name, self._segmentdata, lutsize)
        new_cmap._rgba_over = self._rgba_over
        new_cmap._rgba_under = self._rgba_under
        new_cmap._rgba_bad = self._rgba_bad
        return new_cmap

    @staticmethod
    def _reverser(func, x):
        return func(1 - x)

    def reversed(self, name=None):
        if name is None:
            name = self.name + '_r'
        data_r = {key: functools.partial(self._reverser, data) if callable(data) else [(1.0 - x, y1, y0) for (x, y0, y1) in reversed(data)] for (key, data) in self._segmentdata.items()}
        new_cmap = LinearSegmentedColormap(name, data_r, self.N, self._gamma)
        new_cmap._rgba_over = self._rgba_under
        new_cmap._rgba_under = self._rgba_over
        new_cmap._rgba_bad = self._rgba_bad
        return new_cmap

class ListedColormap(Colormap):

    def __init__(self, colors, name='from_list', N=None):
        self.monochrome = False
        if N is None:
            self.colors = colors
            N = len(colors)
        elif isinstance(colors, str):
            self.colors = [colors] * N
            self.monochrome = True
        elif np.iterable(colors):
            if len(colors) == 1:
                self.monochrome = True
            self.colors = list(itertools.islice(itertools.cycle(colors), N))
        else:
            try:
                gray = float(colors)
            except TypeError:
                pass
            else:
                self.colors = [gray] * N
            self.monochrome = True
        super().__init__(name, N)

    def _init(self):
        self._lut = np.zeros((self.N + 3, 4), float)
        self._lut[:-3] = to_rgba_array(self.colors)
        self._isinit = True
        self._set_extremes()

    def resampled(self, lutsize):
        colors = self(np.linspace(0, 1, lutsize))
        new_cmap = ListedColormap(colors, name=self.name)
        new_cmap._rgba_over = self._rgba_over
        new_cmap._rgba_under = self._rgba_under
        new_cmap._rgba_bad = self._rgba_bad
        return new_cmap

    def reversed(self, name=None):
        if name is None:
            name = self.name + '_r'
        colors_r = list(reversed(self.colors))
        new_cmap = ListedColormap(colors_r, name=name, N=self.N)
        new_cmap._rgba_over = self._rgba_under
        new_cmap._rgba_under = self._rgba_over
        new_cmap._rgba_bad = self._rgba_bad
        return new_cmap

class MultivarColormap:

    def __init__(self, colormaps, combination_mode, name='multivariate colormap'):
        self.name = name
        if not np.iterable(colormaps) or len(colormaps) == 1 or isinstance(colormaps, str):
            raise ValueError('A MultivarColormap must have more than one colormap.')
        colormaps = list(colormaps)
        for (i, cmap) in enumerate(colormaps):
            if isinstance(cmap, str):
                colormaps[i] = mpl.colormaps[cmap]
            elif not isinstance(cmap, Colormap):
                raise ValueError('colormaps must be a list of objects that subclass Colormap or a name found in the colormap registry.')
        self._colormaps = colormaps
        _api.check_in_list(['sRGB_add', 'sRGB_sub'], combination_mode=combination_mode)
        self._combination_mode = combination_mode
        self.n_variates = len(colormaps)
        self._rgba_bad = (0.0, 0.0, 0.0, 0.0)

    def __call__(self, X, alpha=None, bytes=False, clip=True):
        if len(X) != len(self):
            raise ValueError(f'For the selected colormap the data must have a first dimension {len(self)}, not {len(X)}')
        (rgba, mask_bad) = self[0]._get_rgba_and_mask(X[0], bytes=False)
        for (c, xx) in zip(self[1:], X[1:]):
            (sub_rgba, sub_mask_bad) = c._get_rgba_and_mask(xx, bytes=False)
            rgba[..., :3] += sub_rgba[..., :3]
            rgba[..., 3] *= sub_rgba[..., 3]
            mask_bad |= sub_mask_bad
        if self.combination_mode == 'sRGB_sub':
            rgba[..., :3] -= len(self) - 1
        rgba[mask_bad] = self.get_bad()
        if clip:
            rgba = np.clip(rgba, 0, 1)
        if alpha is not None:
            if clip:
                alpha = np.clip(alpha, 0, 1)
            if np.shape(alpha) not in [(), np.shape(X[0])]:
                raise ValueError(f'alpha is array-like but its shape {np.shape(alpha)} does not match that of X[0] {np.shape(X[0])}')
            rgba[..., -1] *= alpha
        if bytes:
            if not clip:
                raise ValueError('clip cannot be false while bytes is true as uint8 does not support values below 0 or above 255.')
            rgba = (rgba * 255).astype('uint8')
        if not np.iterable(X[0]):
            rgba = tuple(rgba)
        return rgba

    def copy(self):
        return self.__copy__()

    def __copy__(self):
        cls = self.__class__
        cmapobject = cls.__new__(cls)
        cmapobject.__dict__.update(self.__dict__)
        cmapobject._colormaps = [cm.copy() for cm in self._colormaps]
        cmapobject._rgba_bad = np.copy(self._rgba_bad)
        return cmapobject

    def __eq__(self, other):
        if not isinstance(other, MultivarColormap):
            return False
        if len(self) != len(other):
            return False
        for (c0, c1) in zip(self, other):
            if c0 != c1:
                return False
        if not all(self._rgba_bad == other._rgba_bad):
            return False
        if self.combination_mode != other.combination_mode:
            return False
        return True

    def __getitem__(self, item):
        return self._colormaps[item]

    def __iter__(self):
        for c in self._colormaps:
            yield c

    def __len__(self):
        return len(self._colormaps)

    def __str__(self):
        return self.name

    def get_bad(self):
        return np.array(self._rgba_bad)

    def resampled(self, lutshape):
        if not np.iterable(lutshape) or len(lutshape) != len(self):
            raise ValueError(f'lutshape must be of length {len(self)}')
        new_cmap = self.copy()
        for (i, s) in enumerate(lutshape):
            if s is not None:
                new_cmap._colormaps[i] = self[i].resampled(s)
        return new_cmap

    def with_extremes(self, *, bad=None, under=None, over=None):
        new_cm = self.copy()
        if bad is not None:
            new_cm._rgba_bad = to_rgba(bad)
        if under is not None:
            if not np.iterable(under) or len(under) != len(new_cm):
                raise ValueError(f'*under* must contain a color for each scalar colormap i.e. be of length {len(new_cm)}.')
            else:
                for (c, b) in zip(new_cm, under):
                    c.set_under(b)
        if over is not None:
            if not np.iterable(over) or len(over) != len(new_cm):
                raise ValueError(f'*over* must contain a color for each scalar colormap i.e. be of length {len(new_cm)}.')
            else:
                for (c, b) in zip(new_cm, over):
                    c.set_over(b)
        return new_cm

    @property
    def combination_mode(self):
        return self._combination_mode

    def _repr_png_(self):
        X = np.tile(np.linspace(0, 1, _REPR_PNG_SIZE[0]), (_REPR_PNG_SIZE[1], 1))
        pixels = np.zeros((_REPR_PNG_SIZE[1] * len(self), _REPR_PNG_SIZE[0], 4), dtype=np.uint8)
        for (i, c) in enumerate(self):
            pixels[i * _REPR_PNG_SIZE[1]:(i + 1) * _REPR_PNG_SIZE[1], :] = c(X, bytes=True)
        png_bytes = io.BytesIO()
        title = self.name + ' multivariate colormap'
        author = f'Matplotlib v{mpl.__version__}, https://matplotlib.org'
        pnginfo = PngInfo()
        pnginfo.add_text('Title', title)
        pnginfo.add_text('Description', title)
        pnginfo.add_text('Author', author)
        pnginfo.add_text('Software', author)
        Image.fromarray(pixels).save(png_bytes, format='png', pnginfo=pnginfo)
        return png_bytes.getvalue()

    def _repr_html_(self):
        return ''.join([c._repr_html_() for c in self._colormaps])

class BivarColormap:

    def __init__(self, N=256, M=256, shape='square', origin=(0, 0), name='bivariate colormap'):
        self.name = name
        self.N = int(N)
        self.M = int(M)
        _api.check_in_list(['square', 'circle', 'ignore', 'circleignore'], shape=shape)
        self._shape = shape
        self._rgba_bad = (0.0, 0.0, 0.0, 0.0)
        self._rgba_outside = (1.0, 0.0, 1.0, 1.0)
        self._isinit = False
        self.n_variates = 2
        self._origin = (float(origin[0]), float(origin[1]))
        ''

    def __call__(self, X, alpha=None, bytes=False):
        if len(X) != 2:
            raise ValueError(f'For a `BivarColormap` the data must have a first dimension 2, not {len(X)}')
        if not self._isinit:
            self._init()
        X0 = np.ma.array(X[0], copy=True)
        X1 = np.ma.array(X[1], copy=True)
        self._clip((X0, X1))
        if not X0.dtype.isnative:
            X0 = X0.byteswap().view(X0.dtype.newbyteorder())
        if not X1.dtype.isnative:
            X1 = X1.byteswap().view(X1.dtype.newbyteorder())
        if X0.dtype.kind == 'f':
            X0 *= self.N
            X0[X0 == self.N] = self.N - 1
        if X1.dtype.kind == 'f':
            X1 *= self.M
            X1[X1 == self.M] = self.M - 1
        mask_outside = (X0 < 0) | (X1 < 0) | (X0 >= self.N) | (X1 >= self.M)
        mask_bad_0 = X0.mask if np.ma.is_masked(X0) else np.isnan(X0)
        mask_bad_1 = X1.mask if np.ma.is_masked(X1) else np.isnan(X1)
        mask_bad = mask_bad_0 | mask_bad_1
        with np.errstate(invalid='ignore'):
            X0 = X0.astype(int)
            X1 = X1.astype(int)
        for X_part in [X0, X1]:
            X_part[mask_outside] = 0
            X_part[mask_bad] = 0
        rgba = self._lut[X0, X1]
        if np.isscalar(X[0]):
            rgba = np.copy(rgba)
        rgba[mask_outside] = self._rgba_outside
        rgba[mask_bad] = self._rgba_bad
        if bytes:
            rgba = (rgba * 255).astype(np.uint8)
        if alpha is not None:
            alpha = np.clip(alpha, 0, 1)
            if bytes:
                alpha *= 255
            if np.shape(alpha) not in [(), np.shape(X0)]:
                raise ValueError(f'alpha is array-like but its shape {np.shape(alpha)} does not match that of X[0] {np.shape(X0)}')
            rgba[..., -1] = alpha
            if (np.array(self._rgba_bad) == 0).all():
                rgba[mask_bad] = (0, 0, 0, 0)
        if not np.iterable(X[0]):
            rgba = tuple(rgba)
        return rgba

    @property
    def lut(self):
        if not self._isinit:
            self._init()
        lut = np.copy(self._lut)
        if self.shape == 'circle' or self.shape == 'circleignore':
            n = np.linspace(-1, 1, self.N)
            m = np.linspace(-1, 1, self.M)
            radii_sqr = (n ** 2)[:, np.newaxis] + (m ** 2)[np.newaxis, :]
            mask_outside = radii_sqr > 1
            lut[mask_outside, 3] = 0
        return lut

    def __copy__(self):
        cls = self.__class__
        cmapobject = cls.__new__(cls)
        cmapobject.__dict__.update(self.__dict__)
        cmapobject._rgba_outside = np.copy(self._rgba_outside)
        cmapobject._rgba_bad = np.copy(self._rgba_bad)
        cmapobject._shape = self.shape
        if self._isinit:
            cmapobject._lut = np.copy(self._lut)
        return cmapobject

    def __eq__(self, other):
        if not isinstance(other, BivarColormap):
            return False
        if not self._isinit:
            self._init()
        if not other._isinit:
            other._init()
        if not np.array_equal(self._lut, other._lut):
            return False
        if not np.array_equal(self._rgba_bad, other._rgba_bad):
            return False
        if not np.array_equal(self._rgba_outside, other._rgba_outside):
            return False
        if self.shape != other.shape:
            return False
        return True

    def get_bad(self):
        return self._rgba_bad

    def get_outside(self):
        return self._rgba_outside

    def resampled(self, lutshape, transposed=False):
        if not np.iterable(lutshape) or len(lutshape) != 2:
            raise ValueError('lutshape must be of length 2')
        lutshape = [lutshape[0], lutshape[1]]
        if lutshape[0] is None or lutshape[0] == 1:
            lutshape[0] = self.N
        if lutshape[1] is None or lutshape[1] == 1:
            lutshape[1] = self.M
        inverted = [False, False]
        if lutshape[0] < 0:
            inverted[0] = True
            lutshape[0] = -lutshape[0]
            if lutshape[0] == 1:
                lutshape[0] = self.N
        if lutshape[1] < 0:
            inverted[1] = True
            lutshape[1] = -lutshape[1]
            if lutshape[1] == 1:
                lutshape[1] = self.M
        (x_0, x_1) = np.mgrid[0:1:lutshape[0] * 1j, 0:1:lutshape[1] * 1j]
        if inverted[0]:
            x_0 = x_0[::-1, :]
        if inverted[1]:
            x_1 = x_1[:, ::-1]
        shape_memory = self._shape
        self._shape = 'square'
        if transposed:
            new_lut = self((x_1, x_0))
            new_cmap = BivarColormapFromImage(new_lut, name=self.name, shape=shape_memory, origin=self.origin[::-1])
        else:
            new_lut = self((x_0, x_1))
            new_cmap = BivarColormapFromImage(new_lut, name=self.name, shape=shape_memory, origin=self.origin)
        self._shape = shape_memory
        new_cmap._rgba_bad = self._rgba_bad
        new_cmap._rgba_outside = self._rgba_outside
        return new_cmap

    def reversed(self, axis_0=True, axis_1=True):
        r_0 = -1 if axis_0 else 1
        r_1 = -1 if axis_1 else 1
        return self.resampled((r_0, r_1))

    def transposed(self):
        return self.resampled((None, None), transposed=True)

    def with_extremes(self, *, bad=None, outside=None, shape=None, origin=None):
        new_cm = self.copy()
        if bad is not None:
            new_cm._rgba_bad = to_rgba(bad)
        if outside is not None:
            new_cm._rgba_outside = to_rgba(outside)
        if shape is not None:
            _api.check_in_list(['square', 'circle', 'ignore', 'circleignore'], shape=shape)
            new_cm._shape = shape
        if origin is not None:
            new_cm._origin = (float(origin[0]), float(origin[1]))
        return new_cm

    def _init(self):
        raise NotImplementedError('Abstract class only')

    @property
    def shape(self):
        return self._shape

    @property
    def origin(self):
        return self._origin

    def _clip(self, X):
        if self.shape == 'square':
            for (X_part, mx) in zip(X, (self.N, self.M)):
                X_part[X_part < 0] = 0
                if X_part.dtype.kind == 'f':
                    X_part[X_part > 1] = 1
                else:
                    X_part[X_part >= mx] = mx - 1
        elif self.shape == 'ignore':
            for (X_part, mx) in zip(X, (self.N, self.M)):
                X_part[X_part < 0] = -1
                if X_part.dtype.kind == 'f':
                    X_part[X_part > 1] = -1
                else:
                    X_part[X_part >= mx] = -1
        elif self.shape == 'circle' or self.shape == 'circleignore':
            for X_part in X:
                if X_part.dtype.kind != 'f':
                    raise NotImplementedError('Circular bivariate colormaps are only implemented for use with with floats')
            radii_sqr = (X[0] - 0.5) ** 2 + (X[1] - 0.5) ** 2
            mask_outside = radii_sqr > 0.25
            if self.shape == 'circle':
                overextend = 2 * np.sqrt(radii_sqr[mask_outside])
                X[0][mask_outside] = (X[0][mask_outside] - 0.5) / overextend + 0.5
                X[1][mask_outside] = (X[1][mask_outside] - 0.5) / overextend + 0.5
            else:
                X[0][mask_outside] = -1
                X[1][mask_outside] = -1

    def __getitem__(self, item):
        if not self._isinit:
            self._init()
        if item == 0:
            origin_1_as_int = int(self._origin[1] * self.M)
            if origin_1_as_int > self.M - 1:
                origin_1_as_int = self.M - 1
            one_d_lut = self._lut[:, origin_1_as_int]
            new_cmap = ListedColormap(one_d_lut, name=f'{self.name}_0', N=self.N)
        elif item == 1:
            origin_0_as_int = int(self._origin[0] * self.N)
            if origin_0_as_int > self.N - 1:
                origin_0_as_int = self.N - 1
            one_d_lut = self._lut[origin_0_as_int, :]
            new_cmap = ListedColormap(one_d_lut, name=f'{self.name}_1', N=self.M)
        else:
            raise KeyError(f'only 0 or 1 are valid keys for BivarColormap, not {item!r}')
        new_cmap._rgba_bad = self._rgba_bad
        if self.shape in ['ignore', 'circleignore']:
            new_cmap.set_over(self._rgba_outside)
            new_cmap.set_under(self._rgba_outside)
        return new_cmap

    def _repr_png_(self):
        if not self._isinit:
            self._init()
        pixels = self.lut
        if pixels.shape[0] < _BIVAR_REPR_PNG_SIZE:
            pixels = np.repeat(pixels, repeats=_BIVAR_REPR_PNG_SIZE // pixels.shape[0], axis=0)[:256, :]
        if pixels.shape[1] < _BIVAR_REPR_PNG_SIZE:
            pixels = np.repeat(pixels, repeats=_BIVAR_REPR_PNG_SIZE // pixels.shape[1], axis=1)[:, :256]
        pixels = (pixels[::-1, :, :] * 255).astype(np.uint8)
        png_bytes = io.BytesIO()
        title = self.name + ' BivarColormap'
        author = f'Matplotlib v{mpl.__version__}, https://matplotlib.org'
        pnginfo = PngInfo()
        pnginfo.add_text('Title', title)
        pnginfo.add_text('Description', title)
        pnginfo.add_text('Author', author)
        pnginfo.add_text('Software', author)
        Image.fromarray(pixels).save(png_bytes, format='png', pnginfo=pnginfo)
        return png_bytes.getvalue()

    def _repr_html_(self):
        png_bytes = self._repr_png_()
        png_base64 = base64.b64encode(png_bytes).decode('ascii')

        def color_block(color):
            hex_color = to_hex(color, keep_alpha=True)
            return f'<div title="{hex_color}" style="display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: {hex_color};"></div>'
        return f'<div style="vertical-align: middle;"><strong>{self.name}</strong> </div><div class="cmap"><img alt="{self.name} BivarColormap" title="{self.name}" style="border: 1px solid #555;" src="data:image/png;base64,{png_base64}"></div><div style="vertical-align: middle; max-width: {_BIVAR_REPR_PNG_SIZE + 2}px; display: flex; justify-content: space-between;"><div style="float: left;">{color_block(self.get_outside())} outside</div><div style="float: right;">bad {color_block(self.get_bad())}</div></div>'

    def copy(self):
        return self.__copy__()

class SegmentedBivarColormap(BivarColormap):

    def __init__(self, patch, N=256, shape='square', origin=(0, 0), name='segmented bivariate colormap'):
        _api.check_shape((None, None, 3), patch=patch)
        self.patch = patch
        super().__init__(N, N, shape, origin, name=name)

    def _init(self):
        s = self.patch.shape
        _patch = np.empty((s[0], s[1], 4))
        _patch[:, :, :3] = self.patch
        _patch[:, :, 3] = 1
        transform = mpl.transforms.Affine2D().translate(-0.5, -0.5).scale(self.N / (s[1] - 1), self.N / (s[0] - 1))
        self._lut = np.empty((self.N, self.N, 4))
        _image.resample(_patch, self._lut, transform, _image.BILINEAR, resample=False, alpha=1)
        self._isinit = True

class BivarColormapFromImage(BivarColormap):

    def __init__(self, lut, shape='square', origin=(0, 0), name='from image'):
        lut = np.array(lut, copy=True)
        if lut.ndim != 3 or lut.shape[2] not in (3, 4):
            raise ValueError('The lut must be an array of shape (n, m, 3) or (n, m, 4)', ' or a PIL.image encoded as RGB or RGBA')
        if lut.dtype == np.uint8:
            lut = lut.astype(np.float32) / 255
        if lut.shape[2] == 3:
            new_lut = np.empty((lut.shape[0], lut.shape[1], 4), dtype=lut.dtype)
            new_lut[:, :, :3] = lut
            new_lut[:, :, 3] = 1.0
            lut = new_lut
        self._lut = lut
        super().__init__(lut.shape[0], lut.shape[1], shape, origin, name=name)

    def _init(self):
        self._isinit = True

class Normalize:

    def __init__(self, vmin=None, vmax=None, clip=False):
        self._vmin = _sanitize_extrema(vmin)
        self._vmax = _sanitize_extrema(vmax)
        self._clip = clip
        self._scale = None
        self.callbacks = cbook.CallbackRegistry(signals=['changed'])

    @property
    def vmin(self):
        return self._vmin

    @vmin.setter
    def vmin(self, value):
        value = _sanitize_extrema(value)
        if value != self._vmin:
            self._vmin = value
            self._changed()

    @property
    def vmax(self):
        return self._vmax

    @vmax.setter
    def vmax(self, value):
        value = _sanitize_extrema(value)
        if value != self._vmax:
            self._vmax = value
            self._changed()

    @property
    def clip(self):
        return self._clip

    @clip.setter
    def clip(self, value):
        if value != self._clip:
            self._clip = value
            self._changed()

    def _changed(self):
        self.callbacks.process('changed')

    @staticmethod
    def process_value(value):
        is_scalar = not np.iterable(value)
        if is_scalar:
            value = [value]
        dtype = np.min_scalar_type(value)
        if np.issubdtype(dtype, np.integer) or dtype.type is np.bool_:
            dtype = np.promote_types(dtype, np.float32)
        mask = np.ma.getmask(value)
        data = np.asarray(value)
        result = np.ma.array(data, mask=mask, dtype=dtype, copy=True)
        return (result, is_scalar)

    def __call__(self, value, clip=None):
        if clip is None:
            clip = self.clip
        (result, is_scalar) = self.process_value(value)
        if self.vmin is None or self.vmax is None:
            self.autoscale_None(result)
        ((vmin,), _) = self.process_value(self.vmin)
        ((vmax,), _) = self.process_value(self.vmax)
        if vmin == vmax:
            result.fill(0)
        elif vmin > vmax:
            raise ValueError('minvalue must be less than or equal to maxvalue')
        else:
            if clip:
                mask = np.ma.getmask(result)
                result = np.ma.array(np.clip(result.filled(vmax), vmin, vmax), mask=mask)
            resdat = result.data
            resdat -= vmin
            resdat /= vmax - vmin
            result = np.ma.array(resdat, mask=result.mask, copy=False)
        if is_scalar:
            result = result[0]
        return result

    def inverse(self, value):
        if not self.scaled():
            raise ValueError('Not invertible until both vmin and vmax are set')
        ((vmin,), _) = self.process_value(self.vmin)
        ((vmax,), _) = self.process_value(self.vmax)
        if np.iterable(value):
            val = np.ma.asarray(value)
            return vmin + val * (vmax - vmin)
        else:
            return vmin + value * (vmax - vmin)

    def autoscale(self, A):
        with self.callbacks.blocked():
            self.vmin = self.vmax = None
            self.autoscale_None(A)
        self._changed()

    def autoscale_None(self, A):
        A = np.asanyarray(A)
        if isinstance(A, np.ma.MaskedArray):
            if A.mask is False or not A.mask.shape:
                A = A.data
        if self.vmin is None and A.size:
            self.vmin = A.min()
        if self.vmax is None and A.size:
            self.vmax = A.max()

    def scaled(self):
        return self.vmin is not None and self.vmax is not None

class TwoSlopeNorm(Normalize):

    def __init__(self, vcenter, vmin=None, vmax=None):
        super().__init__(vmin=vmin, vmax=vmax)
        self._vcenter = vcenter
        if vcenter is not None and vmax is not None and (vcenter >= vmax):
            raise ValueError('vmin, vcenter, and vmax must be in ascending order')
        if vcenter is not None and vmin is not None and (vcenter <= vmin):
            raise ValueError('vmin, vcenter, and vmax must be in ascending order')

    @property
    def vcenter(self):
        return self._vcenter

    @vcenter.setter
    def vcenter(self, value):
        if value != self._vcenter:
            self._vcenter = value
            self._changed()

    def autoscale_None(self, A):
        super().autoscale_None(A)
        if self.vmin >= self.vcenter:
            self.vmin = self.vcenter - (self.vmax - self.vcenter)
        if self.vmax <= self.vcenter:
            self.vmax = self.vcenter + (self.vcenter - self.vmin)

    def __call__(self, value, clip=None):
        (result, is_scalar) = self.process_value(value)
        self.autoscale_None(result)
        if not self.vmin <= self.vcenter <= self.vmax:
            raise ValueError('vmin, vcenter, vmax must increase monotonically')
        result = np.ma.masked_array(np.interp(result, [self.vmin, self.vcenter, self.vmax], [0, 0.5, 1], left=-np.inf, right=np.inf), mask=np.ma.getmask(result))
        if is_scalar:
            result = np.atleast_1d(result)[0]
        return result

    def inverse(self, value):
        if not self.scaled():
            raise ValueError('Not invertible until both vmin and vmax are set')
        ((vmin,), _) = self.process_value(self.vmin)
        ((vmax,), _) = self.process_value(self.vmax)
        ((vcenter,), _) = self.process_value(self.vcenter)
        result = np.interp(value, [0, 0.5, 1], [vmin, vcenter, vmax], left=-np.inf, right=np.inf)
        return result

class CenteredNorm(Normalize):

    def __init__(self, vcenter=0, halfrange=None, clip=False):
        super().__init__(vmin=None, vmax=None, clip=clip)
        self._vcenter = vcenter
        self.halfrange = halfrange

    def autoscale(self, A):
        A = np.asanyarray(A)
        self.halfrange = max(self._vcenter - A.min(), A.max() - self._vcenter)

    def autoscale_None(self, A):
        A = np.asanyarray(A)
        if self.halfrange is None and A.size:
            self.autoscale(A)

    @property
    def vmin(self):
        return self._vmin

    @vmin.setter
    def vmin(self, value):
        value = _sanitize_extrema(value)
        if value != self._vmin:
            self._vmin = value
            self._vmax = 2 * self.vcenter - value
            self._changed()

    @property
    def vmax(self):
        return self._vmax

    @vmax.setter
    def vmax(self, value):
        value = _sanitize_extrema(value)
        if value != self._vmax:
            self._vmax = value
            self._vmin = 2 * self.vcenter - value
            self._changed()

    @property
    def vcenter(self):
        return self._vcenter

    @vcenter.setter
    def vcenter(self, vcenter):
        if vcenter != self._vcenter:
            self._vcenter = vcenter
            self.halfrange = self.halfrange
            self._changed()

    @property
    def halfrange(self):
        if self.vmin is None or self.vmax is None:
            return None
        return (self.vmax - self.vmin) / 2

    @halfrange.setter
    def halfrange(self, halfrange):
        if halfrange is None:
            self.vmin = None
            self.vmax = None
        else:
            self.vmin = self.vcenter - abs(halfrange)
            self.vmax = self.vcenter + abs(halfrange)

def make_norm_from_scale(scale_cls, base_norm_cls=None, *, init=None):
    if base_norm_cls is None:
        return functools.partial(make_norm_from_scale, scale_cls, init=init)
    if isinstance(scale_cls, functools.partial):
        scale_args = scale_cls.args
        scale_kwargs_items = tuple(scale_cls.keywords.items())
        scale_cls = scale_cls.func
    else:
        scale_args = scale_kwargs_items = ()
    if init is None:

        def init(vmin=None, vmax=None, clip=False):
            pass
    return _make_norm_from_scale(scale_cls, scale_args, scale_kwargs_items, base_norm_cls, inspect.signature(init))

@functools.cache
def _make_norm_from_scale(scale_cls, scale_args, scale_kwargs_items, base_norm_cls, bound_init_signature):

    class Norm(base_norm_cls):

        def __reduce__(self):
            cls = type(self)
            try:
                if cls is getattr(importlib.import_module(cls.__module__), cls.__qualname__):
                    return (_create_empty_object_of_class, (cls,), vars(self))
            except (ImportError, AttributeError):
                pass
            return (_picklable_norm_constructor, (scale_cls, scale_args, scale_kwargs_items, base_norm_cls, bound_init_signature), vars(self))

        def __init__(self, *args, **kwargs):
            ba = bound_init_signature.bind(*args, **kwargs)
            ba.apply_defaults()
            super().__init__(**{k: ba.arguments.pop(k) for k in ['vmin', 'vmax', 'clip']})
            self._scale = functools.partial(scale_cls, *scale_args, **dict(scale_kwargs_items))(axis=None, **ba.arguments)
            self._trf = self._scale.get_transform()
        __init__.__signature__ = bound_init_signature.replace(parameters=[inspect.Parameter('self', inspect.Parameter.POSITIONAL_OR_KEYWORD), *bound_init_signature.parameters.values()])

        def __call__(self, value, clip=None):
            (value, is_scalar) = self.process_value(value)
            if self.vmin is None or self.vmax is None:
                self.autoscale_None(value)
            if self.vmin > self.vmax:
                raise ValueError('vmin must be less or equal to vmax')
            if self.vmin == self.vmax:
                return np.full_like(value, 0)
            if clip is None:
                clip = self.clip
            if clip:
                value = np.clip(value, self.vmin, self.vmax)
            t_value = self._trf.transform(value).reshape(np.shape(value))
            (t_vmin, t_vmax) = self._trf.transform([self.vmin, self.vmax])
            if not np.isfinite([t_vmin, t_vmax]).all():
                raise ValueError('Invalid vmin or vmax')
            t_value -= t_vmin
            t_value /= t_vmax - t_vmin
            t_value = np.ma.masked_invalid(t_value, copy=False)
            return t_value[0] if is_scalar else t_value

        def inverse(self, value):
            if not self.scaled():
                raise ValueError('Not invertible until scaled')
            if self.vmin > self.vmax:
                raise ValueError('vmin must be less or equal to vmax')
            (t_vmin, t_vmax) = self._trf.transform([self.vmin, self.vmax])
            if not np.isfinite([t_vmin, t_vmax]).all():
                raise ValueError('Invalid vmin or vmax')
            (value, is_scalar) = self.process_value(value)
            rescaled = value * (t_vmax - t_vmin)
            rescaled += t_vmin
            value = self._trf.inverted().transform(rescaled).reshape(np.shape(value))
            return value[0] if is_scalar else value

        def autoscale_None(self, A):
            in_trf_domain = np.extract(np.isfinite(self._trf.transform(A)), A)
            if in_trf_domain.size == 0:
                in_trf_domain = np.ma.masked
            return super().autoscale_None(in_trf_domain)
    if base_norm_cls is Normalize:
        Norm.__name__ = f'{scale_cls.__name__}Norm'
        Norm.__qualname__ = f'{scale_cls.__qualname__}Norm'
    else:
        Norm.__name__ = base_norm_cls.__name__
        Norm.__qualname__ = base_norm_cls.__qualname__
    Norm.__module__ = base_norm_cls.__module__
    Norm.__doc__ = base_norm_cls.__doc__
    return Norm

def _create_empty_object_of_class(cls):
    return cls.__new__(cls)

def _picklable_norm_constructor(*args):
    return _create_empty_object_of_class(_make_norm_from_scale(*args))

@make_norm_from_scale(scale.FuncScale, init=lambda functions, vmin=None, vmax=None, clip=False: None)
class FuncNorm(Normalize):
LogNorm = make_norm_from_scale(functools.partial(scale.LogScale, nonpositive='mask'))(Normalize)
LogNorm.__name__ = LogNorm.__qualname__ = 'LogNorm'
LogNorm.__doc__ = 'Normalize a given value to the 0-1 range on a log scale.'

@make_norm_from_scale(scale.SymmetricalLogScale, init=lambda linthresh, linscale=1.0, vmin=None, vmax=None, clip=False, *, base=10: None)
class SymLogNorm(Normalize):

    @property
    def linthresh(self):
        return self._scale.linthresh

    @linthresh.setter
    def linthresh(self, value):
        self._scale.linthresh = value

@make_norm_from_scale(scale.AsinhScale, init=lambda linear_width=1, vmin=None, vmax=None, clip=False: None)
class AsinhNorm(Normalize):

    @property
    def linear_width(self):
        return self._scale.linear_width

    @linear_width.setter
    def linear_width(self, value):
        self._scale.linear_width = value

class PowerNorm(Normalize):

    def __init__(self, gamma, vmin=None, vmax=None, clip=False):
        super().__init__(vmin, vmax, clip)
        self.gamma = gamma

    def __call__(self, value, clip=None):
        if clip is None:
            clip = self.clip
        (result, is_scalar) = self.process_value(value)
        self.autoscale_None(result)
        gamma = self.gamma
        (vmin, vmax) = (self.vmin, self.vmax)
        if vmin > vmax:
            raise ValueError('minvalue must be less than or equal to maxvalue')
        elif vmin == vmax:
            result.fill(0)
        else:
            if clip:
                mask = np.ma.getmask(result)
                result = np.ma.array(np.clip(result.filled(vmax), vmin, vmax), mask=mask)
            resdat = result.data
            resdat -= vmin
            resdat /= vmax - vmin
            resdat[resdat > 0] = np.power(resdat[resdat > 0], gamma)
            result = np.ma.array(resdat, mask=result.mask, copy=False)
        if is_scalar:
            result = result[0]
        return result

    def inverse(self, value):
        if not self.scaled():
            raise ValueError('Not invertible until scaled')
        (result, is_scalar) = self.process_value(value)
        gamma = self.gamma
        (vmin, vmax) = (self.vmin, self.vmax)
        resdat = result.data
        resdat[resdat > 0] = np.power(resdat[resdat > 0], 1 / gamma)
        resdat *= vmax - vmin
        resdat += vmin
        result = np.ma.array(resdat, mask=result.mask, copy=False)
        if is_scalar:
            result = result[0]
        return result

class BoundaryNorm(Normalize):

    def __init__(self, boundaries, ncolors, clip=False, *, extend='neither'):
        if clip and extend != 'neither':
            raise ValueError("'clip=True' is not compatible with 'extend'")
        super().__init__(vmin=boundaries[0], vmax=boundaries[-1], clip=clip)
        self.boundaries = np.asarray(boundaries)
        self.N = len(self.boundaries)
        if self.N < 2:
            raise ValueError(f'You must provide at least 2 boundaries (1 region) but you passed in {boundaries!r}')
        self.Ncmap = ncolors
        self.extend = extend
        self._scale = None
        self._n_regions = self.N - 1
        self._offset = 0
        if extend in ('min', 'both'):
            self._n_regions += 1
            self._offset = 1
        if extend in ('max', 'both'):
            self._n_regions += 1
        if self._n_regions > self.Ncmap:
            raise ValueError(f'There are {self._n_regions} color bins including extensions, but ncolors = {ncolors}; ncolors must equal or exceed the number of bins')

    def __call__(self, value, clip=None):
        if clip is None:
            clip = self.clip
        (xx, is_scalar) = self.process_value(value)
        mask = np.ma.getmaskarray(xx)
        xx = np.atleast_1d(xx.filled(self.vmax + 1))
        if clip:
            np.clip(xx, self.vmin, self.vmax, out=xx)
            max_col = self.Ncmap - 1
        else:
            max_col = self.Ncmap
        iret = np.digitize(xx, self.boundaries) - 1 + self._offset
        if self.Ncmap > self._n_regions:
            if self._n_regions == 1:
                iret[iret == 0] = (self.Ncmap - 1) // 2
            else:
                iret = (self.Ncmap - 1) / (self._n_regions - 1) * iret
        iret = iret.astype(np.int16)
        iret[xx < self.vmin] = -1
        iret[xx >= self.vmax] = max_col
        ret = np.ma.array(iret, mask=mask)
        if is_scalar:
            ret = int(ret[0])
        return ret

    def inverse(self, value):
        raise ValueError('BoundaryNorm is not invertible')

class NoNorm(Normalize):

    def __call__(self, value, clip=None):
        if np.iterable(value):
            return np.ma.array(value)
        return value

    def inverse(self, value):
        if np.iterable(value):
            return np.ma.array(value)
        return value

def rgb_to_hsv(arr):
    arr = np.asarray(arr)
    if arr.shape[-1] != 3:
        raise ValueError(f'Last dimension of input array must be 3; shape {arr.shape} was found.')
    in_shape = arr.shape
    arr = np.array(arr, copy=False, dtype=np.promote_types(arr.dtype, np.float32), ndmin=2)
    out = np.zeros_like(arr)
    arr_max = arr.max(-1)
    ipos = arr_max > 0
    delta = np.ptp(arr, -1)
    s = np.zeros_like(delta)
    s[ipos] = delta[ipos] / arr_max[ipos]
    ipos = delta > 0
    idx = (arr[..., 0] == arr_max) & ipos
    out[idx, 0] = (arr[idx, 1] - arr[idx, 2]) / delta[idx]
    idx = (arr[..., 1] == arr_max) & ipos
    out[idx, 0] = 2.0 + (arr[idx, 2] - arr[idx, 0]) / delta[idx]
    idx = (arr[..., 2] == arr_max) & ipos
    out[idx, 0] = 4.0 + (arr[idx, 0] - arr[idx, 1]) / delta[idx]
    out[..., 0] = out[..., 0] / 6.0 % 1.0
    out[..., 1] = s
    out[..., 2] = arr_max
    return out.reshape(in_shape)

def hsv_to_rgb(hsv):
    hsv = np.asarray(hsv)
    if hsv.shape[-1] != 3:
        raise ValueError(f'Last dimension of input array must be 3; shape {hsv.shape} was found.')
    in_shape = hsv.shape
    hsv = np.array(hsv, copy=False, dtype=np.promote_types(hsv.dtype, np.float32), ndmin=2)
    h = hsv[..., 0]
    s = hsv[..., 1]
    v = hsv[..., 2]
    r = np.empty_like(h)
    g = np.empty_like(h)
    b = np.empty_like(h)
    i = (h * 6.0).astype(int)
    f = h * 6.0 - i
    p = v * (1.0 - s)
    q = v * (1.0 - s * f)
    t = v * (1.0 - s * (1.0 - f))
    idx = i % 6 == 0
    r[idx] = v[idx]
    g[idx] = t[idx]
    b[idx] = p[idx]
    idx = i == 1
    r[idx] = q[idx]
    g[idx] = v[idx]
    b[idx] = p[idx]
    idx = i == 2
    r[idx] = p[idx]
    g[idx] = v[idx]
    b[idx] = t[idx]
    idx = i == 3
    r[idx] = p[idx]
    g[idx] = q[idx]
    b[idx] = v[idx]
    idx = i == 4
    r[idx] = t[idx]
    g[idx] = p[idx]
    b[idx] = v[idx]
    idx = i == 5
    r[idx] = v[idx]
    g[idx] = p[idx]
    b[idx] = q[idx]
    idx = s == 0
    r[idx] = v[idx]
    g[idx] = v[idx]
    b[idx] = v[idx]
    rgb = np.stack([r, g, b], axis=-1)
    return rgb.reshape(in_shape)

def _vector_magnitude(arr):
    sum_sq = 0
    for i in range(arr.shape[-1]):
        sum_sq += arr[..., i, np.newaxis] ** 2
    return np.sqrt(sum_sq)

class LightSource:

    def __init__(self, azdeg=315, altdeg=45, hsv_min_val=0, hsv_max_val=1, hsv_min_sat=1, hsv_max_sat=0):
        self.azdeg = azdeg
        self.altdeg = altdeg
        self.hsv_min_val = hsv_min_val
        self.hsv_max_val = hsv_max_val
        self.hsv_min_sat = hsv_min_sat
        self.hsv_max_sat = hsv_max_sat

    @property
    def direction(self):
        az = np.radians(90 - self.azdeg)
        alt = np.radians(self.altdeg)
        return np.array([np.cos(az) * np.cos(alt), np.sin(az) * np.cos(alt), np.sin(alt)])

    def hillshade(self, elevation, vert_exag=1, dx=1, dy=1, fraction=1.0):
        dy = -dy
        (e_dy, e_dx) = np.gradient(vert_exag * elevation, dy, dx)
        normal = np.empty(elevation.shape + (3,)).view(type(elevation))
        normal[..., 0] = -e_dx
        normal[..., 1] = -e_dy
        normal[..., 2] = 1
        normal /= _vector_magnitude(normal)
        return self.shade_normals(normal, fraction)

    def shade_normals(self, normals, fraction=1.0):
        intensity = normals.dot(self.direction)
        (imin, imax) = (intensity.min(), intensity.max())
        intensity *= fraction
        if imax - imin > 1e-06:
            intensity -= imin
            intensity /= imax - imin
        intensity = np.clip(intensity, 0, 1)
        return intensity

    def shade(self, data, cmap, norm=None, blend_mode='overlay', vmin=None, vmax=None, vert_exag=1, dx=1, dy=1, fraction=1, **kwargs):
        if vmin is None:
            vmin = data.min()
        if vmax is None:
            vmax = data.max()
        if norm is None:
            norm = Normalize(vmin=vmin, vmax=vmax)
        rgb0 = cmap(norm(data))
        rgb1 = self.shade_rgb(rgb0, elevation=data, blend_mode=blend_mode, vert_exag=vert_exag, dx=dx, dy=dy, fraction=fraction, **kwargs)
        rgb0[..., :3] = rgb1[..., :3]
        return rgb0

    def shade_rgb(self, rgb, elevation, fraction=1.0, blend_mode='hsv', vert_exag=1, dx=1, dy=1, **kwargs):
        intensity = self.hillshade(elevation, vert_exag, dx, dy, fraction)
        intensity = intensity[..., np.newaxis]
        lookup = {'hsv': self.blend_hsv, 'soft': self.blend_soft_light, 'overlay': self.blend_overlay}
        if blend_mode in lookup:
            blend = lookup[blend_mode](rgb, intensity, **kwargs)
        else:
            try:
                blend = blend_mode(rgb, intensity, **kwargs)
            except TypeError as err:
                raise ValueError(f'"blend_mode" must be callable or one of {lookup.keys}') from err
        if np.ma.is_masked(intensity):
            mask = intensity.mask[..., 0]
            for i in range(3):
                blend[..., i][mask] = rgb[..., i][mask]
        return blend

    def blend_hsv(self, rgb, intensity, hsv_max_sat=None, hsv_max_val=None, hsv_min_val=None, hsv_min_sat=None):
        if hsv_max_sat is None:
            hsv_max_sat = self.hsv_max_sat
        if hsv_max_val is None:
            hsv_max_val = self.hsv_max_val
        if hsv_min_sat is None:
            hsv_min_sat = self.hsv_min_sat
        if hsv_min_val is None:
            hsv_min_val = self.hsv_min_val
        intensity = intensity[..., 0]
        intensity = 2 * intensity - 1
        hsv = rgb_to_hsv(rgb[:, :, 0:3])
        (hue, sat, val) = np.moveaxis(hsv, -1, 0)
        np.putmask(sat, (np.abs(sat) > 1e-10) & (intensity > 0), (1 - intensity) * sat + intensity * hsv_max_sat)
        np.putmask(sat, (np.abs(sat) > 1e-10) & (intensity < 0), (1 + intensity) * sat - intensity * hsv_min_sat)
        np.putmask(val, intensity > 0, (1 - intensity) * val + intensity * hsv_max_val)
        np.putmask(val, intensity < 0, (1 + intensity) * val - intensity * hsv_min_val)
        np.clip(hsv[:, :, 1:], 0, 1, out=hsv[:, :, 1:])
        return hsv_to_rgb(hsv)

    def blend_soft_light(self, rgb, intensity):
        return 2 * intensity * rgb + (1 - 2 * intensity) * rgb ** 2

    def blend_overlay(self, rgb, intensity):
        low = 2 * intensity * rgb
        high = 1 - 2 * (1 - intensity) * (1 - rgb)
        return np.where(rgb <= 0.5, low, high)

def from_levels_and_colors(levels, colors, extend='neither'):
    slice_map = {'both': slice(1, -1), 'min': slice(1, None), 'max': slice(0, -1), 'neither': slice(0, None)}
    _api.check_in_list(slice_map, extend=extend)
    color_slice = slice_map[extend]
    n_data_colors = len(levels) - 1
    n_expected = n_data_colors + color_slice.start - (color_slice.stop or 0)
    if len(colors) != n_expected:
        raise ValueError(f'With extend == {extend!r} and {len(levels)} levels, expected {n_expected} colors, but got {len(colors)}')
    cmap = ListedColormap(colors[color_slice], N=n_data_colors)
    if extend in ['min', 'both']:
        cmap.set_under(colors[0])
    else:
        cmap.set_under('none')
    if extend in ['max', 'both']:
        cmap.set_over(colors[-1])
    else:
        cmap.set_over('none')
    cmap.colorbar_extend = extend
    norm = BoundaryNorm(levels, ncolors=n_data_colors)
    return (cmap, norm)

# File: matplotlib-main/lib/matplotlib/container.py
from matplotlib import cbook
from matplotlib.artist import Artist

class Container(tuple):

    def __repr__(self):
        return f'<{type(self).__name__} object of {len(self)} artists>'

    def __new__(cls, *args, **kwargs):
        return tuple.__new__(cls, args[0])

    def __init__(self, kl, label=None):
        self._callbacks = cbook.CallbackRegistry(signals=['pchanged'])
        self._remove_method = None
        self._label = str(label) if label is not None else None

    def remove(self):
        for c in cbook.flatten(self, scalarp=lambda x: isinstance(x, Artist)):
            if c is not None:
                c.remove()
        if self._remove_method:
            self._remove_method(self)

    def get_children(self):
        return [child for child in cbook.flatten(self) if child is not None]
    get_label = Artist.get_label
    set_label = Artist.set_label
    add_callback = Artist.add_callback
    remove_callback = Artist.remove_callback
    pchanged = Artist.pchanged

class BarContainer(Container):

    def __init__(self, patches, errorbar=None, *, datavalues=None, orientation=None, **kwargs):
        self.patches = patches
        self.errorbar = errorbar
        self.datavalues = datavalues
        self.orientation = orientation
        super().__init__(patches, **kwargs)

class ErrorbarContainer(Container):

    def __init__(self, lines, has_xerr=False, has_yerr=False, **kwargs):
        self.lines = lines
        self.has_xerr = has_xerr
        self.has_yerr = has_yerr
        super().__init__(lines, **kwargs)

class StemContainer(Container):

    def __init__(self, markerline_stemlines_baseline, **kwargs):
        (markerline, stemlines, baseline) = markerline_stemlines_baseline
        self.markerline = markerline
        self.stemlines = stemlines
        self.baseline = baseline
        super().__init__(markerline_stemlines_baseline, **kwargs)

# File: matplotlib-main/lib/matplotlib/contour.py
""""""
from contextlib import ExitStack
import functools
import math
from numbers import Integral
import numpy as np
from numpy import ma
import matplotlib as mpl
from matplotlib import _api, _docstring
from matplotlib.backend_bases import MouseButton
from matplotlib.lines import Line2D
from matplotlib.path import Path
from matplotlib.text import Text
import matplotlib.ticker as ticker
import matplotlib.cm as cm
import matplotlib.colors as mcolors
import matplotlib.collections as mcoll
import matplotlib.font_manager as font_manager
import matplotlib.cbook as cbook
import matplotlib.patches as mpatches
import matplotlib.transforms as mtransforms

def _contour_labeler_event_handler(cs, inline, inline_spacing, event):
    canvas = cs.axes.get_figure(root=True).canvas
    is_button = event.name == 'button_press_event'
    is_key = event.name == 'key_press_event'
    if is_button and event.button == MouseButton.MIDDLE or (is_key and event.key in ['escape', 'enter']):
        canvas.stop_event_loop()
    elif is_button and event.button == MouseButton.RIGHT or (is_key and event.key in ['backspace', 'delete']):
        if not inline:
            cs.pop_label()
            canvas.draw()
    elif is_button and event.button == MouseButton.LEFT or (is_key and event.key is not None):
        if cs.axes.contains(event)[0]:
            cs.add_label_near(event.x, event.y, transform=False, inline=inline, inline_spacing=inline_spacing)
            canvas.draw()

class ContourLabeler:

    def clabel(self, levels=None, *, fontsize=None, inline=True, inline_spacing=5, fmt=None, colors=None, use_clabeltext=False, manual=False, rightside_up=True, zorder=None):
        if fmt is None:
            fmt = ticker.ScalarFormatter(useOffset=False)
            fmt.create_dummy_axis()
        self.labelFmt = fmt
        self._use_clabeltext = use_clabeltext
        self.labelManual = manual
        self.rightside_up = rightside_up
        self._clabel_zorder = 2 + self.get_zorder() if zorder is None else zorder
        if levels is None:
            levels = self.levels
            indices = list(range(len(self.cvalues)))
        else:
            levlabs = list(levels)
            (indices, levels) = ([], [])
            for (i, lev) in enumerate(self.levels):
                if lev in levlabs:
                    indices.append(i)
                    levels.append(lev)
            if len(levels) < len(levlabs):
                raise ValueError(f"Specified levels {levlabs} don't match available levels {self.levels}")
        self.labelLevelList = levels
        self.labelIndiceList = indices
        self._label_font_props = font_manager.FontProperties(size=fontsize)
        if colors is None:
            self.labelMappable = self
            self.labelCValueList = np.take(self.cvalues, self.labelIndiceList)
        else:
            cmap = mcolors.ListedColormap(colors, N=len(self.labelLevelList))
            self.labelCValueList = list(range(len(self.labelLevelList)))
            self.labelMappable = cm.ScalarMappable(cmap=cmap, norm=mcolors.NoNorm())
        self.labelXYs = []
        if np.iterable(manual):
            for (x, y) in manual:
                self.add_label_near(x, y, inline, inline_spacing)
        elif manual:
            print('Select label locations manually using first mouse button.')
            print('End manual selection with second mouse button.')
            if not inline:
                print('Remove last label by clicking third mouse button.')
            mpl._blocking_input.blocking_input_loop(self.axes.get_figure(root=True), ['button_press_event', 'key_press_event'], timeout=-1, handler=functools.partial(_contour_labeler_event_handler, self, inline, inline_spacing))
        else:
            self.labels(inline, inline_spacing)
        return cbook.silent_list('text.Text', self.labelTexts)

    def print_label(self, linecontour, labelwidth):
        return len(linecontour) > 10 * labelwidth or (len(linecontour) and (np.ptp(linecontour, axis=0) > 1.2 * labelwidth).any())

    def too_close(self, x, y, lw):
        thresh = (1.2 * lw) ** 2
        return any(((x - loc[0]) ** 2 + (y - loc[1]) ** 2 < thresh for loc in self.labelXYs))

    def _get_nth_label_width(self, nth):
        fig = self.axes.get_figure(root=False)
        renderer = fig.get_figure(root=True)._get_renderer()
        return Text(0, 0, self.get_text(self.labelLevelList[nth], self.labelFmt), figure=fig, fontproperties=self._label_font_props).get_window_extent(renderer).width

    def get_text(self, lev, fmt):
        if isinstance(lev, str):
            return lev
        elif isinstance(fmt, dict):
            return fmt.get(lev, '%1.3f')
        elif callable(getattr(fmt, 'format_ticks', None)):
            return fmt.format_ticks([*self.labelLevelList, lev])[-1]
        elif callable(fmt):
            return fmt(lev)
        else:
            return fmt % lev

    def locate_label(self, linecontour, labelwidth):
        ctr_size = len(linecontour)
        n_blocks = int(np.ceil(ctr_size / labelwidth)) if labelwidth > 1 else 1
        block_size = ctr_size if n_blocks == 1 else int(labelwidth)
        xx = np.resize(linecontour[:, 0], (n_blocks, block_size))
        yy = np.resize(linecontour[:, 1], (n_blocks, block_size))
        yfirst = yy[:, :1]
        ylast = yy[:, -1:]
        xfirst = xx[:, :1]
        xlast = xx[:, -1:]
        s = (yfirst - yy) * (xlast - xfirst) - (xfirst - xx) * (ylast - yfirst)
        l = np.hypot(xlast - xfirst, ylast - yfirst)
        with np.errstate(divide='ignore', invalid='ignore'):
            distances = (abs(s) / l).sum(axis=-1)
        hbsize = block_size // 2
        adist = np.argsort(distances)
        for idx in np.append(adist, adist[0]):
            (x, y) = (xx[idx, hbsize], yy[idx, hbsize])
            if not self.too_close(x, y, labelwidth):
                break
        return (x, y, (idx * block_size + hbsize) % ctr_size)

    def _split_path_and_get_label_rotation(self, path, idx, screen_pos, lw, spacing=5):
        xys = path.vertices
        codes = path.codes
        pos = self.get_transform().inverted().transform(screen_pos)
        if not np.allclose(pos, xys[idx]):
            xys = np.insert(xys, idx, pos, axis=0)
            codes = np.insert(codes, idx, Path.LINETO)
        movetos = (codes == Path.MOVETO).nonzero()[0]
        start = movetos[movetos <= idx][-1]
        try:
            stop = movetos[movetos > idx][0]
        except IndexError:
            stop = len(codes)
        cc_xys = xys[start:stop]
        idx -= start
        is_closed_path = codes[stop - 1] == Path.CLOSEPOLY
        if is_closed_path:
            cc_xys = np.concatenate([cc_xys[idx:-1], cc_xys[:idx + 1]])
            idx = 0

        def interp_vec(x, xp, fp):
            return [np.interp(x, xp, col) for col in fp.T]
        screen_xys = self.get_transform().transform(cc_xys)
        path_cpls = np.insert(np.cumsum(np.hypot(*np.diff(screen_xys, axis=0).T)), 0, 0)
        path_cpls -= path_cpls[idx]
        target_cpls = np.array([-lw / 2, lw / 2])
        if is_closed_path:
            target_cpls[0] += path_cpls[-1] - path_cpls[0]
        ((sx0, sx1), (sy0, sy1)) = interp_vec(target_cpls, path_cpls, screen_xys)
        angle = np.rad2deg(np.arctan2(sy1 - sy0, sx1 - sx0))
        if self.rightside_up:
            angle = (angle + 90) % 180 - 90
        target_cpls += [-spacing, +spacing]
        (i0, i1) = np.interp(target_cpls, path_cpls, range(len(path_cpls)), left=-1, right=-1)
        i0 = math.floor(i0)
        i1 = math.ceil(i1)
        ((x0, x1), (y0, y1)) = interp_vec(target_cpls, path_cpls, cc_xys)
        new_xy_blocks = []
        new_code_blocks = []
        if is_closed_path:
            if i0 != -1 and i1 != -1:
                points = cc_xys[i1:i0 + 1]
                new_xy_blocks.extend([[(x1, y1)], points, [(x0, y0)]])
                nlines = len(points) + 1
                new_code_blocks.extend([[Path.MOVETO], [Path.LINETO] * nlines])
        else:
            if i0 != -1:
                new_xy_blocks.extend([cc_xys[:i0 + 1], [(x0, y0)]])
                new_code_blocks.extend([[Path.MOVETO], [Path.LINETO] * (i0 + 1)])
            if i1 != -1:
                new_xy_blocks.extend([[(x1, y1)], cc_xys[i1:]])
                new_code_blocks.extend([[Path.MOVETO], [Path.LINETO] * (len(cc_xys) - i1)])
        xys = np.concatenate([xys[:start], *new_xy_blocks, xys[stop:]])
        codes = np.concatenate([codes[:start], *new_code_blocks, codes[stop:]])
        return (angle, Path(xys, codes))

    def add_label(self, x, y, rotation, lev, cvalue):
        (data_x, data_y) = self.axes.transData.inverted().transform((x, y))
        t = Text(data_x, data_y, text=self.get_text(lev, self.labelFmt), rotation=rotation, horizontalalignment='center', verticalalignment='center', zorder=self._clabel_zorder, color=self.labelMappable.to_rgba(cvalue, alpha=self.get_alpha()), fontproperties=self._label_font_props, clip_box=self.axes.bbox)
        if self._use_clabeltext:
            (data_rotation,) = self.axes.transData.inverted().transform_angles([rotation], [[x, y]])
            t.set(rotation=data_rotation, transform_rotates_text=True)
        self.labelTexts.append(t)
        self.labelCValues.append(cvalue)
        self.labelXYs.append((x, y))
        self.axes.add_artist(t)

    def add_label_near(self, x, y, inline=True, inline_spacing=5, transform=None):
        if transform is None:
            transform = self.axes.transData
        if transform:
            (x, y) = transform.transform((x, y))
        (idx_level_min, idx_vtx_min, proj) = self._find_nearest_contour((x, y), self.labelIndiceList)
        path = self._paths[idx_level_min]
        level = self.labelIndiceList.index(idx_level_min)
        label_width = self._get_nth_label_width(level)
        (rotation, path) = self._split_path_and_get_label_rotation(path, idx_vtx_min, proj, label_width, inline_spacing)
        self.add_label(*proj, rotation, self.labelLevelList[idx_level_min], self.labelCValueList[idx_level_min])
        if inline:
            self._paths[idx_level_min] = path

    def pop_label(self, index=-1):
        self.labelCValues.pop(index)
        t = self.labelTexts.pop(index)
        t.remove()

    def labels(self, inline, inline_spacing):
        for (idx, (icon, lev, cvalue)) in enumerate(zip(self.labelIndiceList, self.labelLevelList, self.labelCValueList)):
            trans = self.get_transform()
            label_width = self._get_nth_label_width(idx)
            additions = []
            for subpath in self._paths[icon]._iter_connected_components():
                screen_xys = trans.transform(subpath.vertices)
                if self.print_label(screen_xys, label_width):
                    (x, y, idx) = self.locate_label(screen_xys, label_width)
                    (rotation, path) = self._split_path_and_get_label_rotation(subpath, idx, (x, y), label_width, inline_spacing)
                    self.add_label(x, y, rotation, lev, cvalue)
                    if inline:
                        additions.append(path)
                else:
                    additions.append(subpath)
            if inline:
                self._paths[icon] = Path.make_compound_path(*additions)

    def remove(self):
        super().remove()
        for text in self.labelTexts:
            text.remove()

def _find_closest_point_on_path(xys, p):
    if len(xys) == 1:
        return (((p - xys[0]) ** 2).sum(), xys[0], (0, 0))
    dxys = xys[1:] - xys[:-1]
    norms = (dxys ** 2).sum(axis=1)
    norms[norms == 0] = 1
    rel_projs = np.clip(((p - xys[:-1]) * dxys).sum(axis=1) / norms, 0, 1)[:, None]
    projs = xys[:-1] + rel_projs * dxys
    d2s = ((projs - p) ** 2).sum(axis=1)
    imin = np.argmin(d2s)
    return (d2s[imin], projs[imin], (imin, imin + 1))
_docstring.interpd.update(contour_set_attributes='\nAttributes\n----------\nax : `~matplotlib.axes.Axes`\n    The Axes object in which the contours are drawn.\n\ncollections : `.silent_list` of `.PathCollection`\\s\n    The `.Artist`\\s representing the contour. This is a list of\n    `.PathCollection`\\s for both line and filled contours.\n\nlevels : array\n    The values of the contour levels.\n\nlayers : array\n    Same as levels for line contours; half-way between\n    levels for filled contours.  See ``ContourSet._process_colors``.\n')

@_docstring.dedent_interpd
class ContourSet(ContourLabeler, mcoll.Collection):

    def __init__(self, ax, *args, levels=None, filled=False, linewidths=None, linestyles=None, hatches=(None,), alpha=None, origin=None, extent=None, cmap=None, colors=None, norm=None, vmin=None, vmax=None, extend='neither', antialiased=None, nchunk=0, locator=None, transform=None, negative_linestyles=None, clip_path=None, **kwargs):
        if antialiased is None and filled:
            antialiased = False
        super().__init__(antialiaseds=antialiased, alpha=alpha, clip_path=clip_path, transform=transform)
        self.axes = ax
        self.levels = levels
        self.filled = filled
        self.hatches = hatches
        self.origin = origin
        self.extent = extent
        self.colors = colors
        self.extend = extend
        self.nchunk = nchunk
        self.locator = locator
        if isinstance(norm, mcolors.LogNorm) or isinstance(self.locator, ticker.LogLocator):
            self.logscale = True
            if norm is None:
                norm = mcolors.LogNorm()
        else:
            self.logscale = False
        _api.check_in_list([None, 'lower', 'upper', 'image'], origin=origin)
        if self.extent is not None and len(self.extent) != 4:
            raise ValueError("If given, 'extent' must be None or (x0, x1, y0, y1)")
        if self.colors is not None and cmap is not None:
            raise ValueError('Either colors or cmap must be None')
        if self.origin == 'image':
            self.origin = mpl.rcParams['image.origin']
        self._orig_linestyles = linestyles
        self.negative_linestyles = negative_linestyles
        if self.negative_linestyles is None:
            self.negative_linestyles = mpl.rcParams['contour.negative_linestyle']
        kwargs = self._process_args(*args, **kwargs)
        self._process_levels()
        self._extend_min = self.extend in ['min', 'both']
        self._extend_max = self.extend in ['max', 'both']
        if self.colors is not None:
            if mcolors.is_color_like(self.colors):
                color_sequence = [self.colors]
            else:
                color_sequence = self.colors
            ncolors = len(self.levels)
            if self.filled:
                ncolors -= 1
            i0 = 0
            use_set_under_over = False
            total_levels = ncolors + int(self._extend_min) + int(self._extend_max)
            if len(color_sequence) == total_levels and (self._extend_min or self._extend_max):
                use_set_under_over = True
                if self._extend_min:
                    i0 = 1
            cmap = mcolors.ListedColormap(color_sequence[i0:None], N=ncolors)
            if use_set_under_over:
                if self._extend_min:
                    cmap.set_under(color_sequence[0])
                if self._extend_max:
                    cmap.set_over(color_sequence[-1])
        self.labelTexts = []
        self.labelCValues = []
        self.set_cmap(cmap)
        if norm is not None:
            self.set_norm(norm)
        with self.norm.callbacks.blocked(signal='changed'):
            if vmin is not None:
                self.norm.vmin = vmin
            if vmax is not None:
                self.norm.vmax = vmax
        self.norm._changed()
        self._process_colors()
        if self._paths is None:
            self._paths = self._make_paths_from_contour_generator()
        if self.filled:
            if linewidths is not None:
                _api.warn_external('linewidths is ignored by contourf')
            (lowers, uppers) = self._get_lowers_and_uppers()
            self.set(edgecolor='none', zorder=kwargs.pop('zorder', 1))
        else:
            self.set(facecolor='none', linewidths=self._process_linewidths(linewidths), linestyle=self._process_linestyles(linestyles), zorder=kwargs.pop('zorder', 2), label='_nolegend_')
        self.axes.add_collection(self, autolim=False)
        self.sticky_edges.x[:] = [self._mins[0], self._maxs[0]]
        self.sticky_edges.y[:] = [self._mins[1], self._maxs[1]]
        self.axes.update_datalim([self._mins, self._maxs])
        self.axes.autoscale_view(tight=True)
        self.changed()
        if kwargs:
            _api.warn_external('The following kwargs were not used by contour: ' + ', '.join(map(repr, kwargs)))
    allsegs = property(lambda self: [[subp.vertices for subp in p._iter_connected_components()] for p in self.get_paths()])
    allkinds = property(lambda self: [[subp.codes for subp in p._iter_connected_components()] for p in self.get_paths()])
    alpha = property(lambda self: self.get_alpha())
    linestyles = property(lambda self: self._orig_linestyles)

    def get_transform(self):
        if self._transform is None:
            self._transform = self.axes.transData
        elif not isinstance(self._transform, mtransforms.Transform) and hasattr(self._transform, '_as_mpl_transform'):
            self._transform = self._transform._as_mpl_transform(self.axes)
        return self._transform

    def __getstate__(self):
        state = self.__dict__.copy()
        state['_contour_generator'] = None
        return state

    def legend_elements(self, variable_name='x', str_format=str):
        artists = []
        labels = []
        if self.filled:
            (lowers, uppers) = self._get_lowers_and_uppers()
            n_levels = len(self._paths)
            for idx in range(n_levels):
                artists.append(mpatches.Rectangle((0, 0), 1, 1, facecolor=self.get_facecolor()[idx], hatch=self.hatches[idx % len(self.hatches)]))
                lower = str_format(lowers[idx])
                upper = str_format(uppers[idx])
                if idx == 0 and self.extend in ('min', 'both'):
                    labels.append(f'${variable_name} \\leq {lower}s$')
                elif idx == n_levels - 1 and self.extend in ('max', 'both'):
                    labels.append(f'${variable_name} > {upper}s$')
                else:
                    labels.append(f'${lower} < {variable_name} \\leq {upper}$')
        else:
            for (idx, level) in enumerate(self.levels):
                artists.append(Line2D([], [], color=self.get_edgecolor()[idx], linewidth=self.get_linewidths()[idx], linestyle=self.get_linestyles()[idx]))
                labels.append(f'${variable_name} = {str_format(level)}$')
        return (artists, labels)

    def _process_args(self, *args, **kwargs):
        self.levels = args[0]
        allsegs = args[1]
        allkinds = args[2] if len(args) > 2 else None
        self.zmax = np.max(self.levels)
        self.zmin = np.min(self.levels)
        if allkinds is None:
            allkinds = [[None] * len(segs) for segs in allsegs]
        if self.filled:
            if len(allsegs) != len(self.levels) - 1:
                raise ValueError('must be one less number of segments as levels')
        elif len(allsegs) != len(self.levels):
            raise ValueError('must be same number of segments as levels')
        if len(allkinds) != len(allsegs):
            raise ValueError('allkinds has different length to allsegs')
        flatseglist = [s for seg in allsegs for s in seg]
        points = np.concatenate(flatseglist, axis=0)
        self._mins = points.min(axis=0)
        self._maxs = points.max(axis=0)
        self._paths = [Path.make_compound_path(*map(Path, segs, kinds)) for (segs, kinds) in zip(allsegs, allkinds)]
        return kwargs

    def _make_paths_from_contour_generator(self):
        if self._paths is not None:
            return self._paths
        cg = self._contour_generator
        empty_path = Path(np.empty((0, 2)))
        vertices_and_codes = map(cg.create_filled_contour, *self._get_lowers_and_uppers()) if self.filled else map(cg.create_contour, self.levels)
        return [Path(np.concatenate(vs), np.concatenate(cs)) if len(vs) else empty_path for (vs, cs) in vertices_and_codes]

    def _get_lowers_and_uppers(self):
        lowers = self._levels[:-1]
        if self.zmin == lowers[0]:
            lowers = lowers.copy()
            if self.logscale:
                lowers[0] = 0.99 * self.zmin
            else:
                lowers[0] -= 1
        uppers = self._levels[1:]
        return (lowers, uppers)

    def changed(self):
        if not hasattr(self, 'cvalues'):
            self._process_colors()
        self.norm.autoscale_None(self.levels)
        self.set_array(self.cvalues)
        self.update_scalarmappable()
        alphas = np.broadcast_to(self.get_alpha(), len(self.cvalues))
        for (label, cv, alpha) in zip(self.labelTexts, self.labelCValues, alphas):
            label.set_alpha(alpha)
            label.set_color(self.labelMappable.to_rgba(cv))
        super().changed()

    def _autolev(self, N):
        if self.locator is None:
            if self.logscale:
                self.locator = ticker.LogLocator()
            else:
                self.locator = ticker.MaxNLocator(N + 1, min_n_ticks=1)
        lev = self.locator.tick_values(self.zmin, self.zmax)
        try:
            if self.locator._symmetric:
                return lev
        except AttributeError:
            pass
        under = np.nonzero(lev < self.zmin)[0]
        i0 = under[-1] if len(under) else 0
        over = np.nonzero(lev > self.zmax)[0]
        i1 = over[0] + 1 if len(over) else len(lev)
        if self.extend in ('min', 'both'):
            i0 += 1
        if self.extend in ('max', 'both'):
            i1 -= 1
        if i1 - i0 < 3:
            (i0, i1) = (0, len(lev))
        return lev[i0:i1]

    def _process_contour_level_args(self, args, z_dtype):
        if self.levels is None:
            if args:
                levels_arg = args[0]
            elif np.issubdtype(z_dtype, bool):
                if self.filled:
                    levels_arg = [0, 0.5, 1]
                else:
                    levels_arg = [0.5]
            else:
                levels_arg = 7
        else:
            levels_arg = self.levels
        if isinstance(levels_arg, Integral):
            self.levels = self._autolev(levels_arg)
        else:
            self.levels = np.asarray(levels_arg, np.float64)
        if self.filled and len(self.levels) < 2:
            raise ValueError('Filled contours require at least 2 levels.')
        if len(self.levels) > 1 and np.min(np.diff(self.levels)) <= 0.0:
            raise ValueError('Contour levels must be increasing')

    def _process_levels(self):
        self._levels = list(self.levels)
        if self.logscale:
            (lower, upper) = (1e-250, 1e+250)
        else:
            (lower, upper) = (-1e+250, 1e+250)
        if self.extend in ('both', 'min'):
            self._levels.insert(0, lower)
        if self.extend in ('both', 'max'):
            self._levels.append(upper)
        self._levels = np.asarray(self._levels)
        if not self.filled:
            self.layers = self.levels
            return
        if self.logscale:
            self.layers = np.sqrt(self._levels[:-1]) * np.sqrt(self._levels[1:])
        else:
            self.layers = 0.5 * (self._levels[:-1] + self._levels[1:])

    def _process_colors(self):
        self.monochrome = self.cmap.monochrome
        if self.colors is not None:
            (i0, i1) = (0, len(self.levels))
            if self.filled:
                i1 -= 1
                if self.extend in ('both', 'min'):
                    i0 -= 1
                if self.extend in ('both', 'max'):
                    i1 += 1
            self.cvalues = list(range(i0, i1))
            self.set_norm(mcolors.NoNorm())
        else:
            self.cvalues = self.layers
        self.norm.autoscale_None(self.levels)
        self.set_array(self.cvalues)
        self.update_scalarmappable()
        if self.extend in ('both', 'max', 'min'):
            self.norm.clip = False

    def _process_linewidths(self, linewidths):
        Nlev = len(self.levels)
        if linewidths is None:
            default_linewidth = mpl.rcParams['contour.linewidth']
            if default_linewidth is None:
                default_linewidth = mpl.rcParams['lines.linewidth']
            return [default_linewidth] * Nlev
        elif not np.iterable(linewidths):
            return [linewidths] * Nlev
        else:
            linewidths = list(linewidths)
            return (linewidths * math.ceil(Nlev / len(linewidths)))[:Nlev]

    def _process_linestyles(self, linestyles):
        Nlev = len(self.levels)
        if linestyles is None:
            tlinestyles = ['solid'] * Nlev
            if self.monochrome:
                eps = -(self.zmax - self.zmin) * 1e-15
                for (i, lev) in enumerate(self.levels):
                    if lev < eps:
                        tlinestyles[i] = self.negative_linestyles
        elif isinstance(linestyles, str):
            tlinestyles = [linestyles] * Nlev
        elif np.iterable(linestyles):
            tlinestyles = list(linestyles)
            if len(tlinestyles) < Nlev:
                nreps = int(np.ceil(Nlev / len(linestyles)))
                tlinestyles = tlinestyles * nreps
            if len(tlinestyles) > Nlev:
                tlinestyles = tlinestyles[:Nlev]
        else:
            raise ValueError('Unrecognized type for linestyles kwarg')
        return tlinestyles

    def _find_nearest_contour(self, xy, indices=None):
        if self.filled:
            raise ValueError('Method does not support filled contours')
        if indices is None:
            indices = range(len(self._paths))
        d2min = np.inf
        idx_level_min = idx_vtx_min = proj_min = None
        for idx_level in indices:
            path = self._paths[idx_level]
            idx_vtx_start = 0
            for subpath in path._iter_connected_components():
                if not len(subpath.vertices):
                    continue
                lc = self.get_transform().transform(subpath.vertices)
                (d2, proj, leg) = _find_closest_point_on_path(lc, xy)
                if d2 < d2min:
                    d2min = d2
                    idx_level_min = idx_level
                    idx_vtx_min = leg[1] + idx_vtx_start
                    proj_min = proj
                idx_vtx_start += len(subpath)
        return (idx_level_min, idx_vtx_min, proj_min)

    def find_nearest_contour(self, x, y, indices=None, pixel=True):
        segment = index = d2 = None
        with ExitStack() as stack:
            if not pixel:
                stack.enter_context(self._cm_set(transform=mtransforms.IdentityTransform()))
            (i_level, i_vtx, (xmin, ymin)) = self._find_nearest_contour((x, y), indices)
        if i_level is not None:
            cc_cumlens = np.cumsum([*map(len, self._paths[i_level]._iter_connected_components())])
            segment = cc_cumlens.searchsorted(i_vtx, 'right')
            index = i_vtx if segment == 0 else i_vtx - cc_cumlens[segment - 1]
            d2 = (xmin - x) ** 2 + (ymin - y) ** 2
        return (i_level, segment, index, xmin, ymin, d2)

    def draw(self, renderer):
        paths = self._paths
        n_paths = len(paths)
        if not self.filled or all((hatch is None for hatch in self.hatches)):
            super().draw(renderer)
            return
        for idx in range(n_paths):
            with cbook._setattr_cm(self, _paths=[paths[idx]]), self._cm_set(hatch=self.hatches[idx % len(self.hatches)], array=[self.get_array()[idx]], linewidths=[self.get_linewidths()[idx % len(self.get_linewidths())]], linestyles=[self.get_linestyles()[idx % len(self.get_linestyles())]]):
                super().draw(renderer)

@_docstring.dedent_interpd
class QuadContourSet(ContourSet):

    def _process_args(self, *args, corner_mask=None, algorithm=None, **kwargs):
        if args and isinstance(args[0], QuadContourSet):
            if self.levels is None:
                self.levels = args[0].levels
            self.zmin = args[0].zmin
            self.zmax = args[0].zmax
            self._corner_mask = args[0]._corner_mask
            contour_generator = args[0]._contour_generator
            self._mins = args[0]._mins
            self._maxs = args[0]._maxs
            self._algorithm = args[0]._algorithm
        else:
            import contourpy
            if algorithm is None:
                algorithm = mpl.rcParams['contour.algorithm']
            mpl.rcParams.validate['contour.algorithm'](algorithm)
            self._algorithm = algorithm
            if corner_mask is None:
                if self._algorithm == 'mpl2005':
                    corner_mask = False
                else:
                    corner_mask = mpl.rcParams['contour.corner_mask']
            self._corner_mask = corner_mask
            (x, y, z) = self._contour_args(args, kwargs)
            contour_generator = contourpy.contour_generator(x, y, z, name=self._algorithm, corner_mask=self._corner_mask, line_type=contourpy.LineType.SeparateCode, fill_type=contourpy.FillType.OuterCode, chunk_size=self.nchunk)
            t = self.get_transform()
            if t != self.axes.transData and any(t.contains_branch_seperately(self.axes.transData)):
                trans_to_data = t - self.axes.transData
                pts = np.vstack([x.flat, y.flat]).T
                transformed_pts = trans_to_data.transform(pts)
                x = transformed_pts[..., 0]
                y = transformed_pts[..., 1]
            self._mins = [ma.min(x), ma.min(y)]
            self._maxs = [ma.max(x), ma.max(y)]
        self._contour_generator = contour_generator
        return kwargs

    def _contour_args(self, args, kwargs):
        if self.filled:
            fn = 'contourf'
        else:
            fn = 'contour'
        nargs = len(args)
        if 0 < nargs <= 2:
            (z, *args) = args
            z = ma.asarray(z)
            (x, y) = self._initialize_x_y(z)
        elif 2 < nargs <= 4:
            (x, y, z_orig, *args) = args
            (x, y, z) = self._check_xyz(x, y, z_orig, kwargs)
        else:
            raise _api.nargs_error(fn, takes='from 1 to 4', given=nargs)
        z = ma.masked_invalid(z, copy=False)
        self.zmax = z.max().astype(float)
        self.zmin = z.min().astype(float)
        if self.logscale and self.zmin <= 0:
            z = ma.masked_where(z <= 0, z)
            _api.warn_external('Log scale: values of z <= 0 have been masked')
            self.zmin = z.min().astype(float)
        self._process_contour_level_args(args, z.dtype)
        return (x, y, z)

    def _check_xyz(self, x, y, z, kwargs):
        (x, y) = self.axes._process_unit_info([('x', x), ('y', y)], kwargs)
        x = np.asarray(x, dtype=np.float64)
        y = np.asarray(y, dtype=np.float64)
        z = ma.asarray(z)
        if z.ndim != 2:
            raise TypeError(f'Input z must be 2D, not {z.ndim}D')
        if z.shape[0] < 2 or z.shape[1] < 2:
            raise TypeError(f'Input z must be at least a (2, 2) shaped array, but has shape {z.shape}')
        (Ny, Nx) = z.shape
        if x.ndim != y.ndim:
            raise TypeError(f'Number of dimensions of x ({x.ndim}) and y ({y.ndim}) do not match')
        if x.ndim == 1:
            (nx,) = x.shape
            (ny,) = y.shape
            if nx != Nx:
                raise TypeError(f'Length of x ({nx}) must match number of columns in z ({Nx})')
            if ny != Ny:
                raise TypeError(f'Length of y ({ny}) must match number of rows in z ({Ny})')
            (x, y) = np.meshgrid(x, y)
        elif x.ndim == 2:
            if x.shape != z.shape:
                raise TypeError(f'Shapes of x {x.shape} and z {z.shape} do not match')
            if y.shape != z.shape:
                raise TypeError(f'Shapes of y {y.shape} and z {z.shape} do not match')
        else:
            raise TypeError(f'Inputs x and y must be 1D or 2D, not {x.ndim}D')
        return (x, y, z)

    def _initialize_x_y(self, z):
        if z.ndim != 2:
            raise TypeError(f'Input z must be 2D, not {z.ndim}D')
        elif z.shape[0] < 2 or z.shape[1] < 2:
            raise TypeError(f'Input z must be at least a (2, 2) shaped array, but has shape {z.shape}')
        else:
            (Ny, Nx) = z.shape
        if self.origin is None:
            if self.extent is None:
                return np.meshgrid(np.arange(Nx), np.arange(Ny))
            else:
                (x0, x1, y0, y1) = self.extent
                x = np.linspace(x0, x1, Nx)
                y = np.linspace(y0, y1, Ny)
                return np.meshgrid(x, y)
        if self.extent is None:
            (x0, x1, y0, y1) = (0, Nx, 0, Ny)
        else:
            (x0, x1, y0, y1) = self.extent
        dx = (x1 - x0) / Nx
        dy = (y1 - y0) / Ny
        x = x0 + (np.arange(Nx) + 0.5) * dx
        y = y0 + (np.arange(Ny) + 0.5) * dy
        if self.origin == 'upper':
            y = y[::-1]
        return np.meshgrid(x, y)
_docstring.interpd.update(contour_doc='\n`.contour` and `.contourf` draw contour lines and filled contours,\nrespectively.  Except as noted, function signatures and return values\nare the same for both versions.\n\nParameters\n----------\nX, Y : array-like, optional\n    The coordinates of the values in *Z*.\n\n    *X* and *Y* must both be 2D with the same shape as *Z* (e.g.\n    created via `numpy.meshgrid`), or they must both be 1-D such\n    that ``len(X) == N`` is the number of columns in *Z* and\n    ``len(Y) == M`` is the number of rows in *Z*.\n\n    *X* and *Y* must both be ordered monotonically.\n\n    If not given, they are assumed to be integer indices, i.e.\n    ``X = range(N)``, ``Y = range(M)``.\n\nZ : (M, N) array-like\n    The height values over which the contour is drawn.  Color-mapping is\n    controlled by *cmap*, *norm*, *vmin*, and *vmax*.\n\nlevels : int or array-like, optional\n    Determines the number and positions of the contour lines / regions.\n\n    If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries\n    to automatically choose no more than *n+1* "nice" contour levels\n    between minimum and maximum numeric values of *Z*.\n\n    If array-like, draw contour lines at the specified levels.\n    The values must be in increasing order.\n\nReturns\n-------\n`~.contour.QuadContourSet`\n\nOther Parameters\n----------------\ncorner_mask : bool, default: :rc:`contour.corner_mask`\n    Enable/disable corner masking, which only has an effect if *Z* is\n    a masked array.  If ``False``, any quad touching a masked point is\n    masked out.  If ``True``, only the triangular corners of quads\n    nearest those points are always masked out, other triangular\n    corners comprising three unmasked points are contoured as usual.\n\ncolors : :mpltype:`color` or list of :mpltype:`color`, optional\n    The colors of the levels, i.e. the lines for `.contour` and the\n    areas for `.contourf`.\n\n    The sequence is cycled for the levels in ascending order. If the\n    sequence is shorter than the number of levels, it\'s repeated.\n\n    As a shortcut, a single color may be used in place of one-element lists, i.e.\n    ``\'red\'`` instead of ``[\'red\']`` to color all levels with the same color.\n\n    .. versionchanged:: 3.10\n        Previously a single color had to be expressed as a string, but now any\n        valid color format may be passed.\n\n    By default (value *None*), the colormap specified by *cmap*\n    will be used.\n\nalpha : float, default: 1\n    The alpha blending value, between 0 (transparent) and 1 (opaque).\n\n%(cmap_doc)s\n\n    This parameter is ignored if *colors* is set.\n\n%(norm_doc)s\n\n    This parameter is ignored if *colors* is set.\n\n%(vmin_vmax_doc)s\n\n    If *vmin* or *vmax* are not given, the default color scaling is based on\n    *levels*.\n\n    This parameter is ignored if *colors* is set.\n\norigin : {*None*, \'upper\', \'lower\', \'image\'}, default: None\n    Determines the orientation and exact position of *Z* by specifying\n    the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*\n    are not given.\n\n    - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n    - \'lower\': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n    - \'upper\': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left\n      corner.\n    - \'image\': Use the value from :rc:`image.origin`.\n\nextent : (x0, x1, y0, y1), optional\n    If *origin* is not *None*, then *extent* is interpreted as in\n    `.imshow`: it gives the outer pixel boundaries. In this case, the\n    position of Z[0, 0] is the center of the pixel, not a corner. If\n    *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],\n    and (*x1*, *y1*) is the position of Z[-1, -1].\n\n    This argument is ignored if *X* and *Y* are specified in the call\n    to contour.\n\nlocator : ticker.Locator subclass, optional\n    The locator is used to determine the contour levels if they\n    are not given explicitly via *levels*.\n    Defaults to `~.ticker.MaxNLocator`.\n\nextend : {\'neither\', \'both\', \'min\', \'max\'}, default: \'neither\'\n    Determines the ``contourf``-coloring of values that are outside the\n    *levels* range.\n\n    If \'neither\', values outside the *levels* range are not colored.\n    If \'min\', \'max\' or \'both\', color the values below, above or below\n    and above the *levels* range.\n\n    Values below ``min(levels)`` and above ``max(levels)`` are mapped\n    to the under/over values of the `.Colormap`. Note that most\n    colormaps do not have dedicated colors for these by default, so\n    that the over and under values are the edge values of the colormap.\n    You may want to set these values explicitly using\n    `.Colormap.set_under` and `.Colormap.set_over`.\n\n    .. note::\n\n        An existing `.QuadContourSet` does not get notified if\n        properties of its colormap are changed. Therefore, an explicit\n        call ``QuadContourSet.changed()`` is needed after modifying the\n        colormap. The explicit call can be left out, if a colorbar is\n        assigned to the `.QuadContourSet` because it internally calls\n        ``QuadContourSet.changed()``.\n\n    Example::\n\n        x = np.arange(1, 10)\n        y = x.reshape(-1, 1)\n        h = x * y\n\n        cs = plt.contourf(h, levels=[10, 30, 50],\n            colors=[\'#808080\', \'#A0A0A0\', \'#C0C0C0\'], extend=\'both\')\n        cs.cmap.set_over(\'red\')\n        cs.cmap.set_under(\'blue\')\n        cs.changed()\n\nxunits, yunits : registered units, optional\n    Override axis units by specifying an instance of a\n    :class:`matplotlib.units.ConversionInterface`.\n\nantialiased : bool, optional\n    Enable antialiasing, overriding the defaults.  For\n    filled contours, the default is *False*.  For line contours,\n    it is taken from :rc:`lines.antialiased`.\n\nnchunk : int >= 0, optional\n    If 0, no subdivision of the domain.  Specify a positive integer to\n    divide the domain into subdomains of *nchunk* by *nchunk* quads.\n    Chunking reduces the maximum length of polygons generated by the\n    contouring algorithm which reduces the rendering workload passed\n    on to the backend and also requires slightly less RAM.  It can\n    however introduce rendering artifacts at chunk boundaries depending\n    on the backend, the *antialiased* flag and value of *alpha*.\n\nlinewidths : float or array-like, default: :rc:`contour.linewidth`\n    *Only applies to* `.contour`.\n\n    The line width of the contour lines.\n\n    If a number, all levels will be plotted with this linewidth.\n\n    If a sequence, the levels in ascending order will be plotted with\n    the linewidths in the order specified.\n\n    If None, this falls back to :rc:`lines.linewidth`.\n\nlinestyles : {*None*, \'solid\', \'dashed\', \'dashdot\', \'dotted\'}, optional\n    *Only applies to* `.contour`.\n\n    If *linestyles* is *None*, the default is \'solid\' unless the lines are\n    monochrome. In that case, negative contours will instead take their\n    linestyle from the *negative_linestyles* argument.\n\n    *linestyles* can also be an iterable of the above strings specifying a set\n    of linestyles to be used. If this iterable is shorter than the number of\n    contour levels it will be repeated as necessary.\n\nnegative_linestyles : {*None*, \'solid\', \'dashed\', \'dashdot\', \'dotted\'},                        optional\n    *Only applies to* `.contour`.\n\n    If *linestyles* is *None* and the lines are monochrome, this argument\n    specifies the line style for negative contours.\n\n    If *negative_linestyles* is *None*, the default is taken from\n    :rc:`contour.negative_linestyles`.\n\n    *negative_linestyles* can also be an iterable of the above strings\n    specifying a set of linestyles to be used. If this iterable is shorter than\n    the number of contour levels it will be repeated as necessary.\n\nhatches : list[str], optional\n    *Only applies to* `.contourf`.\n\n    A list of cross hatch patterns to use on the filled areas.\n    If None, no hatching will be added to the contour.\n\nalgorithm : {\'mpl2005\', \'mpl2014\', \'serial\', \'threaded\'}, optional\n    Which contouring algorithm to use to calculate the contour lines and\n    polygons. The algorithms are implemented in\n    `ContourPy <https://github.com/contourpy/contourpy>`_, consult the\n    `ContourPy documentation <https://contourpy.readthedocs.io>`_ for\n    further information.\n\n    The default is taken from :rc:`contour.algorithm`.\n\nclip_path : `~matplotlib.patches.Patch` or `.Path` or `.TransformedPath`\n    Set the clip path.  See `~matplotlib.artist.Artist.set_clip_path`.\n\n    .. versionadded:: 3.8\n\ndata : indexable object, optional\n    DATA_PARAMETER_PLACEHOLDER\n\nNotes\n-----\n1. `.contourf` differs from the MATLAB version in that it does not draw\n   the polygon edges. To draw edges, add line contours with calls to\n   `.contour`.\n\n2. `.contourf` fills intervals that are closed at the top; that is, for\n   boundaries *z1* and *z2*, the filled region is::\n\n      z1 < Z <= z2\n\n   except for the lowest interval, which is closed on both sides (i.e.\n   it includes the lowest value).\n\n3. `.contour` and `.contourf` use a `marching squares\n   <https://en.wikipedia.org/wiki/Marching_squares>`_ algorithm to\n   compute contour locations.  More information can be found in\n   `ContourPy documentation <https://contourpy.readthedocs.io>`_.\n' % _docstring.interpd.params)

# File: matplotlib-main/lib/matplotlib/dates.py
""""""
import datetime
import functools
import logging
import re
from dateutil.rrule import rrule, MO, TU, WE, TH, FR, SA, SU, YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY
from dateutil.relativedelta import relativedelta
import dateutil.parser
import dateutil.tz
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, ticker, units
__all__ = ('datestr2num', 'date2num', 'num2date', 'num2timedelta', 'drange', 'set_epoch', 'get_epoch', 'DateFormatter', 'ConciseDateFormatter', 'AutoDateFormatter', 'DateLocator', 'RRuleLocator', 'AutoDateLocator', 'YearLocator', 'MonthLocator', 'WeekdayLocator', 'DayLocator', 'HourLocator', 'MinuteLocator', 'SecondLocator', 'MicrosecondLocator', 'rrule', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU', 'YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY', 'HOURLY', 'MINUTELY', 'SECONDLY', 'MICROSECONDLY', 'relativedelta', 'DateConverter', 'ConciseDateConverter', 'rrulewrapper')
_log = logging.getLogger(__name__)
UTC = datetime.timezone.utc

def _get_tzinfo(tz=None):
    tz = mpl._val_or_rc(tz, 'timezone')
    if tz == 'UTC':
        return UTC
    if isinstance(tz, str):
        tzinfo = dateutil.tz.gettz(tz)
        if tzinfo is None:
            raise ValueError(f'{tz} is not a valid timezone as parsed by dateutil.tz.gettz.')
        return tzinfo
    if isinstance(tz, datetime.tzinfo):
        return tz
    raise TypeError(f'tz must be string or tzinfo subclass, not {tz!r}.')
EPOCH_OFFSET = float(datetime.datetime(1970, 1, 1).toordinal())
MICROSECONDLY = SECONDLY + 1
HOURS_PER_DAY = 24.0
MIN_PER_HOUR = 60.0
SEC_PER_MIN = 60.0
MONTHS_PER_YEAR = 12.0
DAYS_PER_WEEK = 7.0
DAYS_PER_MONTH = 30.0
DAYS_PER_YEAR = 365.0
MINUTES_PER_DAY = MIN_PER_HOUR * HOURS_PER_DAY
SEC_PER_HOUR = SEC_PER_MIN * MIN_PER_HOUR
SEC_PER_DAY = SEC_PER_HOUR * HOURS_PER_DAY
SEC_PER_WEEK = SEC_PER_DAY * DAYS_PER_WEEK
MUSECONDS_PER_DAY = 1000000.0 * SEC_PER_DAY
(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = (MO, TU, WE, TH, FR, SA, SU)
WEEKDAYS = (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY)
_epoch = None

def _reset_epoch_test_example():
    global _epoch
    _epoch = None

def set_epoch(epoch):
    global _epoch
    if _epoch is not None:
        raise RuntimeError('set_epoch must be called before dates plotted.')
    _epoch = epoch

def get_epoch():
    global _epoch
    _epoch = mpl._val_or_rc(_epoch, 'date.epoch')
    return _epoch

def _dt64_to_ordinalf(d):
    dseconds = d.astype('datetime64[s]')
    extra = (d - dseconds).astype('timedelta64[ns]')
    t0 = np.datetime64(get_epoch(), 's')
    dt = (dseconds - t0).astype(np.float64)
    dt += extra.astype(np.float64) / 1000000000.0
    dt = dt / SEC_PER_DAY
    NaT_int = np.datetime64('NaT').astype(np.int64)
    d_int = d.astype(np.int64)
    dt[d_int == NaT_int] = np.nan
    return dt

def _from_ordinalf(x, tz=None):
    tz = _get_tzinfo(tz)
    dt = np.datetime64(get_epoch()) + np.timedelta64(int(np.round(x * MUSECONDS_PER_DAY)), 'us')
    if dt < np.datetime64('0001-01-01') or dt >= np.datetime64('10000-01-01'):
        raise ValueError(f'Date ordinal {x} converts to {dt} (using epoch {get_epoch()}), but Matplotlib dates must be between year 0001 and 9999.')
    dt = dt.tolist()
    dt = dt.replace(tzinfo=dateutil.tz.gettz('UTC'))
    dt = dt.astimezone(tz)
    if np.abs(x) > 70 * 365:
        ms = round(dt.microsecond / 20) * 20
        if ms == 1000000:
            dt = dt.replace(microsecond=0) + datetime.timedelta(seconds=1)
        else:
            dt = dt.replace(microsecond=ms)
    return dt
_from_ordinalf_np_vectorized = np.vectorize(_from_ordinalf, otypes='O')
_dateutil_parser_parse_np_vectorized = np.vectorize(dateutil.parser.parse)

def datestr2num(d, default=None):
    if isinstance(d, str):
        dt = dateutil.parser.parse(d, default=default)
        return date2num(dt)
    else:
        if default is not None:
            d = [date2num(dateutil.parser.parse(s, default=default)) for s in d]
            return np.asarray(d)
        d = np.asarray(d)
        if not d.size:
            return d
        return date2num(_dateutil_parser_parse_np_vectorized(d))

def date2num(d):
    d = cbook._unpack_to_numpy(d)
    iterable = np.iterable(d)
    if not iterable:
        d = [d]
    masked = np.ma.is_masked(d)
    mask = np.ma.getmask(d)
    d = np.asarray(d)
    if not np.issubdtype(d.dtype, np.datetime64):
        if not d.size:
            return d
        tzi = getattr(d[0], 'tzinfo', None)
        if tzi is not None:
            d = [dt.astimezone(UTC).replace(tzinfo=None) for dt in d]
            d = np.asarray(d)
        d = d.astype('datetime64[us]')
    d = np.ma.masked_array(d, mask=mask) if masked else d
    d = _dt64_to_ordinalf(d)
    return d if iterable else d[0]

def num2date(x, tz=None):
    tz = _get_tzinfo(tz)
    return _from_ordinalf_np_vectorized(x, tz).tolist()
_ordinalf_to_timedelta_np_vectorized = np.vectorize(lambda x: datetime.timedelta(days=x), otypes='O')

def num2timedelta(x):
    return _ordinalf_to_timedelta_np_vectorized(x).tolist()

def drange(dstart, dend, delta):
    f1 = date2num(dstart)
    f2 = date2num(dend)
    step = delta.total_seconds() / SEC_PER_DAY
    num = int(np.ceil((f2 - f1) / step))
    dinterval_end = dstart + num * delta
    if dinterval_end >= dend:
        dinterval_end -= delta
        num -= 1
    f2 = date2num(dinterval_end)
    return np.linspace(f1, f2, num + 1)

def _wrap_in_tex(text):
    p = '([a-zA-Z]+)'
    ret_text = re.sub(p, '}$\\1$\\\\mathdefault{', text)
    ret_text = ret_text.replace('-', '{-}').replace(':', '{:}')
    ret_text = ret_text.replace(' ', '\\;')
    ret_text = '$\\mathdefault{' + ret_text + '}$'
    ret_text = ret_text.replace('$\\mathdefault{}$', '')
    return ret_text

class DateFormatter(ticker.Formatter):

    def __init__(self, fmt, tz=None, *, usetex=None):
        self.tz = _get_tzinfo(tz)
        self.fmt = fmt
        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')

    def __call__(self, x, pos=0):
        result = num2date(x, self.tz).strftime(self.fmt)
        return _wrap_in_tex(result) if self._usetex else result

    def set_tzinfo(self, tz):
        self.tz = _get_tzinfo(tz)

class ConciseDateFormatter(ticker.Formatter):

    def __init__(self, locator, tz=None, formats=None, offset_formats=None, zero_formats=None, show_offset=True, *, usetex=None):
        self._locator = locator
        self._tz = tz
        self.defaultfmt = '%Y'
        if formats:
            if len(formats) != 6:
                raise ValueError('formats argument must be a list of 6 format strings (or None)')
            self.formats = formats
        else:
            self.formats = ['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']
        if zero_formats:
            if len(zero_formats) != 6:
                raise ValueError('zero_formats argument must be a list of 6 format strings (or None)')
            self.zero_formats = zero_formats
        elif formats:
            self.zero_formats = [''] + self.formats[:-1]
        else:
            self.zero_formats = [''] + self.formats[:-1]
            self.zero_formats[3] = '%b-%d'
        if offset_formats:
            if len(offset_formats) != 6:
                raise ValueError('offset_formats argument must be a list of 6 format strings (or None)')
            self.offset_formats = offset_formats
        else:
            self.offset_formats = ['', '%Y', '%Y-%b', '%Y-%b-%d', '%Y-%b-%d', '%Y-%b-%d %H:%M']
        self.offset_string = ''
        self.show_offset = show_offset
        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')

    def __call__(self, x, pos=None):
        formatter = DateFormatter(self.defaultfmt, self._tz, usetex=self._usetex)
        return formatter(x, pos=pos)

    def format_ticks(self, values):
        tickdatetime = [num2date(value, tz=self._tz) for value in values]
        tickdate = np.array([tdt.timetuple()[:6] for tdt in tickdatetime])
        fmts = self.formats
        zerofmts = self.zero_formats
        offsetfmts = self.offset_formats
        show_offset = self.show_offset
        for level in range(5, -1, -1):
            unique = np.unique(tickdate[:, level])
            if len(unique) > 1:
                if level < 2 and np.any(unique == 1):
                    show_offset = False
                break
            elif level == 0:
                level = 5
        zerovals = [0, 1, 1, 0, 0, 0, 0]
        labels = [''] * len(tickdate)
        for nn in range(len(tickdate)):
            if level < 5:
                if tickdate[nn][level] == zerovals[level]:
                    fmt = zerofmts[level]
                else:
                    fmt = fmts[level]
            elif tickdatetime[nn].second == tickdatetime[nn].microsecond == 0:
                fmt = zerofmts[level]
            else:
                fmt = fmts[level]
            labels[nn] = tickdatetime[nn].strftime(fmt)
        if level >= 5:
            trailing_zeros = min((len(s) - len(s.rstrip('0')) for s in labels if '.' in s), default=None)
            if trailing_zeros:
                for nn in range(len(labels)):
                    if '.' in labels[nn]:
                        labels[nn] = labels[nn][:-trailing_zeros].rstrip('.')
        if show_offset:
            if self._locator.axis and self._locator.axis.__name__ in ('xaxis', 'yaxis') and self._locator.axis.get_inverted():
                self.offset_string = tickdatetime[0].strftime(offsetfmts[level])
            else:
                self.offset_string = tickdatetime[-1].strftime(offsetfmts[level])
            if self._usetex:
                self.offset_string = _wrap_in_tex(self.offset_string)
        else:
            self.offset_string = ''
        if self._usetex:
            return [_wrap_in_tex(l) for l in labels]
        else:
            return labels

    def get_offset(self):
        return self.offset_string

    def format_data_short(self, value):
        return num2date(value, tz=self._tz).strftime('%Y-%m-%d %H:%M:%S')

class AutoDateFormatter(ticker.Formatter):

    def __init__(self, locator, tz=None, defaultfmt='%Y-%m-%d', *, usetex=None):
        self._locator = locator
        self._tz = tz
        self.defaultfmt = defaultfmt
        self._formatter = DateFormatter(self.defaultfmt, tz)
        rcParams = mpl.rcParams
        self._usetex = mpl._val_or_rc(usetex, 'text.usetex')
        self.scaled = {DAYS_PER_YEAR: rcParams['date.autoformatter.year'], DAYS_PER_MONTH: rcParams['date.autoformatter.month'], 1: rcParams['date.autoformatter.day'], 1 / HOURS_PER_DAY: rcParams['date.autoformatter.hour'], 1 / MINUTES_PER_DAY: rcParams['date.autoformatter.minute'], 1 / SEC_PER_DAY: rcParams['date.autoformatter.second'], 1 / MUSECONDS_PER_DAY: rcParams['date.autoformatter.microsecond']}

    def _set_locator(self, locator):
        self._locator = locator

    def __call__(self, x, pos=None):
        try:
            locator_unit_scale = float(self._locator._get_unit())
        except AttributeError:
            locator_unit_scale = 1
        fmt = next((fmt for (scale, fmt) in sorted(self.scaled.items()) if scale >= locator_unit_scale), self.defaultfmt)
        if isinstance(fmt, str):
            self._formatter = DateFormatter(fmt, self._tz, usetex=self._usetex)
            result = self._formatter(x, pos)
        elif callable(fmt):
            result = fmt(x, pos)
        else:
            raise TypeError(f'Unexpected type passed to {self!r}.')
        return result

class rrulewrapper:

    def __init__(self, freq, tzinfo=None, **kwargs):
        kwargs['freq'] = freq
        self._base_tzinfo = tzinfo
        self._update_rrule(**kwargs)

    def set(self, **kwargs):
        self._construct.update(kwargs)
        self._update_rrule(**self._construct)

    def _update_rrule(self, **kwargs):
        tzinfo = self._base_tzinfo
        if 'dtstart' in kwargs:
            dtstart = kwargs['dtstart']
            if dtstart.tzinfo is not None:
                if tzinfo is None:
                    tzinfo = dtstart.tzinfo
                else:
                    dtstart = dtstart.astimezone(tzinfo)
                kwargs['dtstart'] = dtstart.replace(tzinfo=None)
        if 'until' in kwargs:
            until = kwargs['until']
            if until.tzinfo is not None:
                if tzinfo is not None:
                    until = until.astimezone(tzinfo)
                else:
                    raise ValueError('until cannot be aware if dtstart is naive and tzinfo is None')
                kwargs['until'] = until.replace(tzinfo=None)
        self._construct = kwargs.copy()
        self._tzinfo = tzinfo
        self._rrule = rrule(**self._construct)

    def _attach_tzinfo(self, dt, tzinfo):
        if hasattr(tzinfo, 'localize'):
            return tzinfo.localize(dt, is_dst=True)
        return dt.replace(tzinfo=tzinfo)

    def _aware_return_wrapper(self, f, returns_list=False):
        if self._tzinfo is None:
            return f

        def normalize_arg(arg):
            if isinstance(arg, datetime.datetime) and arg.tzinfo is not None:
                if arg.tzinfo is not self._tzinfo:
                    arg = arg.astimezone(self._tzinfo)
                return arg.replace(tzinfo=None)
            return arg

        def normalize_args(args, kwargs):
            args = tuple((normalize_arg(arg) for arg in args))
            kwargs = {kw: normalize_arg(arg) for (kw, arg) in kwargs.items()}
            return (args, kwargs)
        if not returns_list:

            def inner_func(*args, **kwargs):
                (args, kwargs) = normalize_args(args, kwargs)
                dt = f(*args, **kwargs)
                return self._attach_tzinfo(dt, self._tzinfo)
        else:

            def inner_func(*args, **kwargs):
                (args, kwargs) = normalize_args(args, kwargs)
                dts = f(*args, **kwargs)
                return [self._attach_tzinfo(dt, self._tzinfo) for dt in dts]
        return functools.wraps(f)(inner_func)

    def __getattr__(self, name):
        if name in self.__dict__:
            return self.__dict__[name]
        f = getattr(self._rrule, name)
        if name in {'after', 'before'}:
            return self._aware_return_wrapper(f)
        elif name in {'xafter', 'xbefore', 'between'}:
            return self._aware_return_wrapper(f, returns_list=True)
        else:
            return f

    def __setstate__(self, state):
        self.__dict__.update(state)

class DateLocator(ticker.Locator):
    hms0d = {'byhour': 0, 'byminute': 0, 'bysecond': 0}

    def __init__(self, tz=None):
        self.tz = _get_tzinfo(tz)

    def set_tzinfo(self, tz):
        self.tz = _get_tzinfo(tz)

    def datalim_to_dt(self):
        (dmin, dmax) = self.axis.get_data_interval()
        if dmin > dmax:
            (dmin, dmax) = (dmax, dmin)
        return (num2date(dmin, self.tz), num2date(dmax, self.tz))

    def viewlim_to_dt(self):
        (vmin, vmax) = self.axis.get_view_interval()
        if vmin > vmax:
            (vmin, vmax) = (vmax, vmin)
        return (num2date(vmin, self.tz), num2date(vmax, self.tz))

    def _get_unit(self):
        return 1

    def _get_interval(self):
        return 1

    def nonsingular(self, vmin, vmax):
        if not np.isfinite(vmin) or not np.isfinite(vmax):
            return (date2num(datetime.date(1970, 1, 1)), date2num(datetime.date(1970, 1, 2)))
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        unit = self._get_unit()
        interval = self._get_interval()
        if abs(vmax - vmin) < 1e-06:
            vmin -= 2 * unit * interval
            vmax += 2 * unit * interval
        return (vmin, vmax)

class RRuleLocator(DateLocator):

    def __init__(self, o, tz=None):
        super().__init__(tz)
        self.rule = o

    def __call__(self):
        try:
            (dmin, dmax) = self.viewlim_to_dt()
        except ValueError:
            return []
        return self.tick_values(dmin, dmax)

    def tick_values(self, vmin, vmax):
        (start, stop) = self._create_rrule(vmin, vmax)
        dates = self.rule.between(start, stop, True)
        if len(dates) == 0:
            return date2num([vmin, vmax])
        return self.raise_if_exceeds(date2num(dates))

    def _create_rrule(self, vmin, vmax):
        delta = relativedelta(vmax, vmin)
        try:
            start = vmin - delta
        except (ValueError, OverflowError):
            start = datetime.datetime(1, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
        try:
            stop = vmax + delta
        except (ValueError, OverflowError):
            stop = datetime.datetime(9999, 12, 31, 23, 59, 59, tzinfo=datetime.timezone.utc)
        self.rule.set(dtstart=start, until=stop)
        return (vmin, vmax)

    def _get_unit(self):
        freq = self.rule._rrule._freq
        return self.get_unit_generic(freq)

    @staticmethod
    def get_unit_generic(freq):
        if freq == YEARLY:
            return DAYS_PER_YEAR
        elif freq == MONTHLY:
            return DAYS_PER_MONTH
        elif freq == WEEKLY:
            return DAYS_PER_WEEK
        elif freq == DAILY:
            return 1.0
        elif freq == HOURLY:
            return 1.0 / HOURS_PER_DAY
        elif freq == MINUTELY:
            return 1.0 / MINUTES_PER_DAY
        elif freq == SECONDLY:
            return 1.0 / SEC_PER_DAY
        else:
            return -1

    def _get_interval(self):
        return self.rule._rrule._interval

class AutoDateLocator(DateLocator):

    def __init__(self, tz=None, minticks=5, maxticks=None, interval_multiples=True):
        super().__init__(tz=tz)
        self._freq = YEARLY
        self._freqs = [YEARLY, MONTHLY, DAILY, HOURLY, MINUTELY, SECONDLY, MICROSECONDLY]
        self.minticks = minticks
        self.maxticks = {YEARLY: 11, MONTHLY: 12, DAILY: 11, HOURLY: 12, MINUTELY: 11, SECONDLY: 11, MICROSECONDLY: 8}
        if maxticks is not None:
            try:
                self.maxticks.update(maxticks)
            except TypeError:
                self.maxticks = dict.fromkeys(self._freqs, maxticks)
        self.interval_multiples = interval_multiples
        self.intervald = {YEARLY: [1, 2, 4, 5, 10, 20, 40, 50, 100, 200, 400, 500, 1000, 2000, 4000, 5000, 10000], MONTHLY: [1, 2, 3, 4, 6], DAILY: [1, 2, 3, 7, 14, 21], HOURLY: [1, 2, 3, 4, 6, 12], MINUTELY: [1, 5, 10, 15, 30], SECONDLY: [1, 5, 10, 15, 30], MICROSECONDLY: [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000]}
        if interval_multiples:
            self.intervald[DAILY] = [1, 2, 4, 7, 14]
        self._byranges = [None, range(1, 13), range(1, 32), range(0, 24), range(0, 60), range(0, 60), None]

    def __call__(self):
        (dmin, dmax) = self.viewlim_to_dt()
        locator = self.get_locator(dmin, dmax)
        return locator()

    def tick_values(self, vmin, vmax):
        return self.get_locator(vmin, vmax).tick_values(vmin, vmax)

    def nonsingular(self, vmin, vmax):
        if not np.isfinite(vmin) or not np.isfinite(vmax):
            return (date2num(datetime.date(1970, 1, 1)), date2num(datetime.date(1970, 1, 2)))
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        if vmin == vmax:
            vmin = vmin - DAYS_PER_YEAR * 2
            vmax = vmax + DAYS_PER_YEAR * 2
        return (vmin, vmax)

    def _get_unit(self):
        if self._freq in [MICROSECONDLY]:
            return 1.0 / MUSECONDS_PER_DAY
        else:
            return RRuleLocator.get_unit_generic(self._freq)

    def get_locator(self, dmin, dmax):
        delta = relativedelta(dmax, dmin)
        tdelta = dmax - dmin
        if dmin > dmax:
            delta = -delta
            tdelta = -tdelta
        numYears = float(delta.years)
        numMonths = numYears * MONTHS_PER_YEAR + delta.months
        numDays = tdelta.days
        numHours = numDays * HOURS_PER_DAY + delta.hours
        numMinutes = numHours * MIN_PER_HOUR + delta.minutes
        numSeconds = np.floor(tdelta.total_seconds())
        numMicroseconds = np.floor(tdelta.total_seconds() * 1000000.0)
        nums = [numYears, numMonths, numDays, numHours, numMinutes, numSeconds, numMicroseconds]
        use_rrule_locator = [True] * 6 + [False]
        byranges = [None, 1, 1, 0, 0, 0, None]
        for (i, (freq, num)) in enumerate(zip(self._freqs, nums)):
            if num < self.minticks:
                byranges[i] = None
                continue
            for interval in self.intervald[freq]:
                if num <= interval * (self.maxticks[freq] - 1):
                    break
            else:
                if not (self.interval_multiples and freq == DAILY):
                    _api.warn_external(f"AutoDateLocator was unable to pick an appropriate interval for this date range. It may be necessary to add an interval value to the AutoDateLocator's intervald dictionary. Defaulting to {interval}.")
            self._freq = freq
            if self._byranges[i] and self.interval_multiples:
                byranges[i] = self._byranges[i][::interval]
                if i in (DAILY, WEEKLY):
                    if interval == 14:
                        byranges[i] = [1, 15]
                    elif interval == 7:
                        byranges[i] = [1, 8, 15, 22]
                interval = 1
            else:
                byranges[i] = self._byranges[i]
            break
        else:
            interval = 1
        if freq == YEARLY and self.interval_multiples:
            locator = YearLocator(interval, tz=self.tz)
        elif use_rrule_locator[i]:
            (_, bymonth, bymonthday, byhour, byminute, bysecond, _) = byranges
            rrule = rrulewrapper(self._freq, interval=interval, dtstart=dmin, until=dmax, bymonth=bymonth, bymonthday=bymonthday, byhour=byhour, byminute=byminute, bysecond=bysecond)
            locator = RRuleLocator(rrule, tz=self.tz)
        else:
            locator = MicrosecondLocator(interval, tz=self.tz)
            if date2num(dmin) > 70 * 365 and interval < 1000:
                _api.warn_external(f'Plotting microsecond time intervals for dates far from the epoch (time origin: {get_epoch()}) is not well-supported. See matplotlib.dates.set_epoch to change the epoch.')
        locator.set_axis(self.axis)
        return locator

class YearLocator(RRuleLocator):

    def __init__(self, base=1, month=1, day=1, tz=None):
        rule = rrulewrapper(YEARLY, interval=base, bymonth=month, bymonthday=day, **self.hms0d)
        super().__init__(rule, tz=tz)
        self.base = ticker._Edge_integer(base, 0)

    def _create_rrule(self, vmin, vmax):
        ymin = max(self.base.le(vmin.year) * self.base.step, 1)
        ymax = min(self.base.ge(vmax.year) * self.base.step, 9999)
        c = self.rule._construct
        replace = {'year': ymin, 'month': c.get('bymonth', 1), 'day': c.get('bymonthday', 1), 'hour': 0, 'minute': 0, 'second': 0}
        start = vmin.replace(**replace)
        stop = start.replace(year=ymax)
        self.rule.set(dtstart=start, until=stop)
        return (start, stop)

class MonthLocator(RRuleLocator):

    def __init__(self, bymonth=None, bymonthday=1, interval=1, tz=None):
        if bymonth is None:
            bymonth = range(1, 13)
        rule = rrulewrapper(MONTHLY, bymonth=bymonth, bymonthday=bymonthday, interval=interval, **self.hms0d)
        super().__init__(rule, tz=tz)

class WeekdayLocator(RRuleLocator):

    def __init__(self, byweekday=1, interval=1, tz=None):
        rule = rrulewrapper(DAILY, byweekday=byweekday, interval=interval, **self.hms0d)
        super().__init__(rule, tz=tz)

class DayLocator(RRuleLocator):

    def __init__(self, bymonthday=None, interval=1, tz=None):
        if interval != int(interval) or interval < 1:
            raise ValueError('interval must be an integer greater than 0')
        if bymonthday is None:
            bymonthday = range(1, 32)
        rule = rrulewrapper(DAILY, bymonthday=bymonthday, interval=interval, **self.hms0d)
        super().__init__(rule, tz=tz)

class HourLocator(RRuleLocator):

    def __init__(self, byhour=None, interval=1, tz=None):
        if byhour is None:
            byhour = range(24)
        rule = rrulewrapper(HOURLY, byhour=byhour, interval=interval, byminute=0, bysecond=0)
        super().__init__(rule, tz=tz)

class MinuteLocator(RRuleLocator):

    def __init__(self, byminute=None, interval=1, tz=None):
        if byminute is None:
            byminute = range(60)
        rule = rrulewrapper(MINUTELY, byminute=byminute, interval=interval, bysecond=0)
        super().__init__(rule, tz=tz)

class SecondLocator(RRuleLocator):

    def __init__(self, bysecond=None, interval=1, tz=None):
        if bysecond is None:
            bysecond = range(60)
        rule = rrulewrapper(SECONDLY, bysecond=bysecond, interval=interval)
        super().__init__(rule, tz=tz)

class MicrosecondLocator(DateLocator):

    def __init__(self, interval=1, tz=None):
        super().__init__(tz=tz)
        self._interval = interval
        self._wrapped_locator = ticker.MultipleLocator(interval)

    def set_axis(self, axis):
        self._wrapped_locator.set_axis(axis)
        return super().set_axis(axis)

    def __call__(self):
        try:
            (dmin, dmax) = self.viewlim_to_dt()
        except ValueError:
            return []
        return self.tick_values(dmin, dmax)

    def tick_values(self, vmin, vmax):
        (nmin, nmax) = date2num((vmin, vmax))
        t0 = np.floor(nmin)
        nmax = nmax - t0
        nmin = nmin - t0
        nmin *= MUSECONDS_PER_DAY
        nmax *= MUSECONDS_PER_DAY
        ticks = self._wrapped_locator.tick_values(nmin, nmax)
        ticks = ticks / MUSECONDS_PER_DAY + t0
        return ticks

    def _get_unit(self):
        return 1.0 / MUSECONDS_PER_DAY

    def _get_interval(self):
        return self._interval

class DateConverter(units.ConversionInterface):

    def __init__(self, *, interval_multiples=True):
        self._interval_multiples = interval_multiples
        super().__init__()

    def axisinfo(self, unit, axis):
        tz = unit
        majloc = AutoDateLocator(tz=tz, interval_multiples=self._interval_multiples)
        majfmt = AutoDateFormatter(majloc, tz=tz)
        datemin = datetime.date(1970, 1, 1)
        datemax = datetime.date(1970, 1, 2)
        return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='', default_limits=(datemin, datemax))

    @staticmethod
    def convert(value, unit, axis):
        return date2num(value)

    @staticmethod
    def default_units(x, axis):
        if isinstance(x, np.ndarray):
            x = x.ravel()
        try:
            x = cbook._safe_first_finite(x)
        except (TypeError, StopIteration):
            pass
        try:
            return x.tzinfo
        except AttributeError:
            pass
        return None

class ConciseDateConverter(DateConverter):

    def __init__(self, formats=None, zero_formats=None, offset_formats=None, show_offset=True, *, interval_multiples=True):
        self._formats = formats
        self._zero_formats = zero_formats
        self._offset_formats = offset_formats
        self._show_offset = show_offset
        self._interval_multiples = interval_multiples
        super().__init__()

    def axisinfo(self, unit, axis):
        tz = unit
        majloc = AutoDateLocator(tz=tz, interval_multiples=self._interval_multiples)
        majfmt = ConciseDateFormatter(majloc, tz=tz, formats=self._formats, zero_formats=self._zero_formats, offset_formats=self._offset_formats, show_offset=self._show_offset)
        datemin = datetime.date(1970, 1, 1)
        datemax = datetime.date(1970, 1, 2)
        return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='', default_limits=(datemin, datemax))

class _SwitchableDateConverter:

    @staticmethod
    def _get_converter():
        converter_cls = {'concise': ConciseDateConverter, 'auto': DateConverter}[mpl.rcParams['date.converter']]
        interval_multiples = mpl.rcParams['date.interval_multiples']
        return converter_cls(interval_multiples=interval_multiples)

    def axisinfo(self, *args, **kwargs):
        return self._get_converter().axisinfo(*args, **kwargs)

    def default_units(self, *args, **kwargs):
        return self._get_converter().default_units(*args, **kwargs)

    def convert(self, *args, **kwargs):
        return self._get_converter().convert(*args, **kwargs)
units.registry[np.datetime64] = units.registry[datetime.date] = units.registry[datetime.datetime] = _SwitchableDateConverter()

# File: matplotlib-main/lib/matplotlib/dviread.py
""""""
from collections import namedtuple
import enum
from functools import lru_cache, partial, wraps
import logging
import os
from pathlib import Path
import re
import struct
import subprocess
import sys
import numpy as np
from matplotlib import _api, cbook
_log = logging.getLogger(__name__)
_dvistate = enum.Enum('DviState', 'pre outer inpage post_post finale')
Page = namedtuple('Page', 'text boxes height width descent')
Box = namedtuple('Box', 'x y height width')

class Text(namedtuple('Text', 'x y font glyph width')):

    def _get_pdftexmap_entry(self):
        return PsfontsMap(find_tex_file('pdftex.map'))[self.font.texname]

    @property
    def font_path(self):
        psfont = self._get_pdftexmap_entry()
        if psfont.filename is None:
            raise ValueError('No usable font file found for {} ({}); the font may lack a Type-1 version'.format(psfont.psname.decode('ascii'), psfont.texname.decode('ascii')))
        return Path(psfont.filename)

    @property
    def font_size(self):
        return self.font.size

    @property
    def font_effects(self):
        return self._get_pdftexmap_entry().effects

    @property
    def glyph_name_or_index(self):
        entry = self._get_pdftexmap_entry()
        return _parse_enc(entry.encoding)[self.glyph] if entry.encoding is not None else self.glyph
_arg_mapping = dict(raw=lambda dvi, delta: delta, u1=lambda dvi, delta: dvi._read_arg(1, signed=False), u4=lambda dvi, delta: dvi._read_arg(4, signed=False), s4=lambda dvi, delta: dvi._read_arg(4, signed=True), slen=lambda dvi, delta: dvi._read_arg(delta, signed=True) if delta else None, slen1=lambda dvi, delta: dvi._read_arg(delta + 1, signed=True), ulen1=lambda dvi, delta: dvi._read_arg(delta + 1, signed=False), olen1=lambda dvi, delta: dvi._read_arg(delta + 1, signed=delta == 3))

def _dispatch(table, min, max=None, state=None, args=('raw',)):

    def decorate(method):
        get_args = [_arg_mapping[x] for x in args]

        @wraps(method)
        def wrapper(self, byte):
            if state is not None and self.state != state:
                raise ValueError('state precondition failed')
            return method(self, *[f(self, byte - min) for f in get_args])
        if max is None:
            table[min] = wrapper
        else:
            for i in range(min, max + 1):
                assert table[i] is None
                table[i] = wrapper
        return wrapper
    return decorate

class Dvi:
    _dtable = [None] * 256
    _dispatch = partial(_dispatch, _dtable)

    def __init__(self, filename, dpi):
        _log.debug('Dvi: %s', filename)
        self.file = open(filename, 'rb')
        self.dpi = dpi
        self.fonts = {}
        self.state = _dvistate.pre
        self._missing_font = None

    def __enter__(self):
        return self

    def __exit__(self, etype, evalue, etrace):
        self.close()

    def __iter__(self):
        while self._read():
            yield self._output()

    def close(self):
        if not self.file.closed:
            self.file.close()

    def _output(self):
        minx = miny = np.inf
        maxx = maxy = -np.inf
        maxy_pure = -np.inf
        for elt in self.text + self.boxes:
            if isinstance(elt, Box):
                (x, y, h, w) = elt
                e = 0
            else:
                (x, y, font, g, w) = elt
                (h, e) = font._height_depth_of(g)
            minx = min(minx, x)
            miny = min(miny, y - h)
            maxx = max(maxx, x + w)
            maxy = max(maxy, y + e)
            maxy_pure = max(maxy_pure, y)
        if self._baseline_v is not None:
            maxy_pure = self._baseline_v
            self._baseline_v = None
        if not self.text and (not self.boxes):
            return Page(text=[], boxes=[], width=0, height=0, descent=0)
        if self.dpi is None:
            return Page(text=self.text, boxes=self.boxes, width=maxx - minx, height=maxy_pure - miny, descent=maxy - maxy_pure)
        d = self.dpi / (72.27 * 2 ** 16)
        descent = (maxy - maxy_pure) * d
        text = [Text((x - minx) * d, (maxy - y) * d - descent, f, g, w * d) for (x, y, f, g, w) in self.text]
        boxes = [Box((x - minx) * d, (maxy - y) * d - descent, h * d, w * d) for (x, y, h, w) in self.boxes]
        return Page(text=text, boxes=boxes, width=(maxx - minx) * d, height=(maxy_pure - miny) * d, descent=descent)

    def _read(self):
        down_stack = [0]
        self._baseline_v = None
        while True:
            byte = self.file.read(1)[0]
            self._dtable[byte](self, byte)
            if self._missing_font:
                raise self._missing_font
            name = self._dtable[byte].__name__
            if name == '_push':
                down_stack.append(down_stack[-1])
            elif name == '_pop':
                down_stack.pop()
            elif name == '_down':
                down_stack[-1] += 1
            if self._baseline_v is None and len(getattr(self, 'stack', [])) == 3 and (down_stack[-1] >= 4):
                self._baseline_v = self.v
            if byte == 140:
                return True
            if self.state is _dvistate.post_post:
                self.close()
                return False

    def _read_arg(self, nbytes, signed=False):
        return int.from_bytes(self.file.read(nbytes), 'big', signed=signed)

    @_dispatch(min=0, max=127, state=_dvistate.inpage)
    def _set_char_immediate(self, char):
        self._put_char_real(char)
        if isinstance(self.fonts[self.f], FileNotFoundError):
            return
        self.h += self.fonts[self.f]._width_of(char)

    @_dispatch(min=128, max=131, state=_dvistate.inpage, args=('olen1',))
    def _set_char(self, char):
        self._put_char_real(char)
        if isinstance(self.fonts[self.f], FileNotFoundError):
            return
        self.h += self.fonts[self.f]._width_of(char)

    @_dispatch(132, state=_dvistate.inpage, args=('s4', 's4'))
    def _set_rule(self, a, b):
        self._put_rule_real(a, b)
        self.h += b

    @_dispatch(min=133, max=136, state=_dvistate.inpage, args=('olen1',))
    def _put_char(self, char):
        self._put_char_real(char)

    def _put_char_real(self, char):
        font = self.fonts[self.f]
        if isinstance(font, FileNotFoundError):
            self._missing_font = font
        elif font._vf is None:
            self.text.append(Text(self.h, self.v, font, char, font._width_of(char)))
        else:
            scale = font._scale
            for (x, y, f, g, w) in font._vf[char].text:
                newf = DviFont(scale=_mul2012(scale, f._scale), tfm=f._tfm, texname=f.texname, vf=f._vf)
                self.text.append(Text(self.h + _mul2012(x, scale), self.v + _mul2012(y, scale), newf, g, newf._width_of(g)))
            self.boxes.extend([Box(self.h + _mul2012(x, scale), self.v + _mul2012(y, scale), _mul2012(a, scale), _mul2012(b, scale)) for (x, y, a, b) in font._vf[char].boxes])

    @_dispatch(137, state=_dvistate.inpage, args=('s4', 's4'))
    def _put_rule(self, a, b):
        self._put_rule_real(a, b)

    def _put_rule_real(self, a, b):
        if a > 0 and b > 0:
            self.boxes.append(Box(self.h, self.v, a, b))

    @_dispatch(138)
    def _nop(self, _):
        pass

    @_dispatch(139, state=_dvistate.outer, args=('s4',) * 11)
    def _bop(self, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, p):
        self.state = _dvistate.inpage
        self.h = self.v = self.w = self.x = self.y = self.z = 0
        self.stack = []
        self.text = []
        self.boxes = []

    @_dispatch(140, state=_dvistate.inpage)
    def _eop(self, _):
        self.state = _dvistate.outer
        del self.h, self.v, self.w, self.x, self.y, self.z, self.stack

    @_dispatch(141, state=_dvistate.inpage)
    def _push(self, _):
        self.stack.append((self.h, self.v, self.w, self.x, self.y, self.z))

    @_dispatch(142, state=_dvistate.inpage)
    def _pop(self, _):
        (self.h, self.v, self.w, self.x, self.y, self.z) = self.stack.pop()

    @_dispatch(min=143, max=146, state=_dvistate.inpage, args=('slen1',))
    def _right(self, b):
        self.h += b

    @_dispatch(min=147, max=151, state=_dvistate.inpage, args=('slen',))
    def _right_w(self, new_w):
        if new_w is not None:
            self.w = new_w
        self.h += self.w

    @_dispatch(min=152, max=156, state=_dvistate.inpage, args=('slen',))
    def _right_x(self, new_x):
        if new_x is not None:
            self.x = new_x
        self.h += self.x

    @_dispatch(min=157, max=160, state=_dvistate.inpage, args=('slen1',))
    def _down(self, a):
        self.v += a

    @_dispatch(min=161, max=165, state=_dvistate.inpage, args=('slen',))
    def _down_y(self, new_y):
        if new_y is not None:
            self.y = new_y
        self.v += self.y

    @_dispatch(min=166, max=170, state=_dvistate.inpage, args=('slen',))
    def _down_z(self, new_z):
        if new_z is not None:
            self.z = new_z
        self.v += self.z

    @_dispatch(min=171, max=234, state=_dvistate.inpage)
    def _fnt_num_immediate(self, k):
        self.f = k

    @_dispatch(min=235, max=238, state=_dvistate.inpage, args=('olen1',))
    def _fnt_num(self, new_f):
        self.f = new_f

    @_dispatch(min=239, max=242, args=('ulen1',))
    def _xxx(self, datalen):
        special = self.file.read(datalen)
        _log.debug('Dvi._xxx: encountered special: %s', ''.join([chr(ch) if 32 <= ch < 127 else '<%02x>' % ch for ch in special]))

    @_dispatch(min=243, max=246, args=('olen1', 'u4', 'u4', 'u4', 'u1', 'u1'))
    def _fnt_def(self, k, c, s, d, a, l):
        self._fnt_def_real(k, c, s, d, a, l)

    def _fnt_def_real(self, k, c, s, d, a, l):
        n = self.file.read(a + l)
        fontname = n[-l:].decode('ascii')
        try:
            tfm = _tfmfile(fontname)
        except FileNotFoundError as exc:
            self.fonts[k] = exc
            return
        if c != 0 and tfm.checksum != 0 and (c != tfm.checksum):
            raise ValueError(f'tfm checksum mismatch: {n}')
        try:
            vf = _vffile(fontname)
        except FileNotFoundError:
            vf = None
        self.fonts[k] = DviFont(scale=s, tfm=tfm, texname=n, vf=vf)

    @_dispatch(247, state=_dvistate.pre, args=('u1', 'u4', 'u4', 'u4', 'u1'))
    def _pre(self, i, num, den, mag, k):
        self.file.read(k)
        if i != 2:
            raise ValueError(f'Unknown dvi format {i}')
        if num != 25400000 or den != 7227 * 2 ** 16:
            raise ValueError('Nonstandard units in dvi file')
        if mag != 1000:
            raise ValueError('Nonstandard magnification in dvi file')
        self.state = _dvistate.outer

    @_dispatch(248, state=_dvistate.outer)
    def _post(self, _):
        self.state = _dvistate.post_post

    @_dispatch(249)
    def _post_post(self, _):
        raise NotImplementedError

    @_dispatch(min=250, max=255)
    def _malformed(self, offset):
        raise ValueError(f'unknown command: byte {250 + offset}')

class DviFont:
    __slots__ = ('texname', 'size', 'widths', '_scale', '_vf', '_tfm')

    def __init__(self, scale, tfm, texname, vf):
        _api.check_isinstance(bytes, texname=texname)
        self._scale = scale
        self._tfm = tfm
        self.texname = texname
        self._vf = vf
        self.size = scale * (72.0 / (72.27 * 2 ** 16))
        try:
            nchars = max(tfm.width) + 1
        except ValueError:
            nchars = 0
        self.widths = [1000 * tfm.width.get(char, 0) >> 20 for char in range(nchars)]

    def __eq__(self, other):
        return type(self) is type(other) and self.texname == other.texname and (self.size == other.size)

    def __ne__(self, other):
        return not self.__eq__(other)

    def __repr__(self):
        return f'<{type(self).__name__}: {self.texname}>'

    def _width_of(self, char):
        width = self._tfm.width.get(char, None)
        if width is not None:
            return _mul2012(width, self._scale)
        _log.debug('No width for char %d in font %s.', char, self.texname)
        return 0

    def _height_depth_of(self, char):
        result = []
        for (metric, name) in ((self._tfm.height, 'height'), (self._tfm.depth, 'depth')):
            value = metric.get(char, None)
            if value is None:
                _log.debug('No %s for char %d in font %s', name, char, self.texname)
                result.append(0)
            else:
                result.append(_mul2012(value, self._scale))
        if re.match(b'^cmsy\\d+$', self.texname) and char == 0:
            result[-1] = 0
        return result

class Vf(Dvi):

    def __init__(self, filename):
        super().__init__(filename, 0)
        try:
            self._first_font = None
            self._chars = {}
            self._read()
        finally:
            self.close()

    def __getitem__(self, code):
        return self._chars[code]

    def _read(self):
        packet_char = packet_ends = None
        packet_len = packet_width = None
        while True:
            byte = self.file.read(1)[0]
            if self.state is _dvistate.inpage:
                byte_at = self.file.tell() - 1
                if byte_at == packet_ends:
                    self._finalize_packet(packet_char, packet_width)
                    packet_len = packet_char = packet_width = None
                elif byte_at > packet_ends:
                    raise ValueError('Packet length mismatch in vf file')
                else:
                    if byte in (139, 140) or byte >= 243:
                        raise ValueError(f'Inappropriate opcode {byte} in vf file')
                    Dvi._dtable[byte](self, byte)
                    continue
            if byte < 242:
                packet_len = byte
                packet_char = self._read_arg(1)
                packet_width = self._read_arg(3)
                packet_ends = self._init_packet(byte)
                self.state = _dvistate.inpage
            elif byte == 242:
                packet_len = self._read_arg(4)
                packet_char = self._read_arg(4)
                packet_width = self._read_arg(4)
                self._init_packet(packet_len)
            elif 243 <= byte <= 246:
                k = self._read_arg(byte - 242, byte == 246)
                c = self._read_arg(4)
                s = self._read_arg(4)
                d = self._read_arg(4)
                a = self._read_arg(1)
                l = self._read_arg(1)
                self._fnt_def_real(k, c, s, d, a, l)
                if self._first_font is None:
                    self._first_font = k
            elif byte == 247:
                i = self._read_arg(1)
                k = self._read_arg(1)
                x = self.file.read(k)
                cs = self._read_arg(4)
                ds = self._read_arg(4)
                self._pre(i, x, cs, ds)
            elif byte == 248:
                break
            else:
                raise ValueError(f'Unknown vf opcode {byte}')

    def _init_packet(self, pl):
        if self.state != _dvistate.outer:
            raise ValueError('Misplaced packet in vf file')
        self.h = self.v = self.w = self.x = self.y = self.z = 0
        self.stack = []
        self.text = []
        self.boxes = []
        self.f = self._first_font
        self._missing_font = None
        return self.file.tell() + pl

    def _finalize_packet(self, packet_char, packet_width):
        if not self._missing_font:
            self._chars[packet_char] = Page(text=self.text, boxes=self.boxes, width=packet_width, height=None, descent=None)
        self.state = _dvistate.outer

    def _pre(self, i, x, cs, ds):
        if self.state is not _dvistate.pre:
            raise ValueError('pre command in middle of vf file')
        if i != 202:
            raise ValueError(f'Unknown vf format {i}')
        if len(x):
            _log.debug('vf file comment: %s', x)
        self.state = _dvistate.outer

def _mul2012(num1, num2):
    return num1 * num2 >> 20

class Tfm:
    __slots__ = ('checksum', 'design_size', 'width', 'height', 'depth')

    def __init__(self, filename):
        _log.debug('opening tfm file %s', filename)
        with open(filename, 'rb') as file:
            header1 = file.read(24)
            (lh, bc, ec, nw, nh, nd) = struct.unpack('!6H', header1[2:14])
            _log.debug('lh=%d, bc=%d, ec=%d, nw=%d, nh=%d, nd=%d', lh, bc, ec, nw, nh, nd)
            header2 = file.read(4 * lh)
            (self.checksum, self.design_size) = struct.unpack('!2I', header2[:8])
            char_info = file.read(4 * (ec - bc + 1))
            widths = struct.unpack(f'!{nw}i', file.read(4 * nw))
            heights = struct.unpack(f'!{nh}i', file.read(4 * nh))
            depths = struct.unpack(f'!{nd}i', file.read(4 * nd))
        self.width = {}
        self.height = {}
        self.depth = {}
        for (idx, char) in enumerate(range(bc, ec + 1)):
            byte0 = char_info[4 * idx]
            byte1 = char_info[4 * idx + 1]
            self.width[char] = widths[byte0]
            self.height[char] = heights[byte1 >> 4]
            self.depth[char] = depths[byte1 & 15]
PsFont = namedtuple('PsFont', 'texname psname effects encoding filename')

class PsfontsMap:
    __slots__ = ('_filename', '_unparsed', '_parsed')

    @lru_cache
    def __new__(cls, filename):
        self = object.__new__(cls)
        self._filename = os.fsdecode(filename)
        with open(filename, 'rb') as file:
            self._unparsed = {}
            for line in file:
                tfmname = line.split(b' ', 1)[0]
                self._unparsed.setdefault(tfmname, []).append(line)
        self._parsed = {}
        return self

    def __getitem__(self, texname):
        assert isinstance(texname, bytes)
        if texname in self._unparsed:
            for line in self._unparsed.pop(texname):
                if self._parse_and_cache_line(line):
                    break
        try:
            return self._parsed[texname]
        except KeyError:
            raise LookupError(f"An associated PostScript font (required by Matplotlib) could not be found for TeX font {texname.decode('ascii')!r} in {self._filename!r}; this problem can often be solved by installing a suitable PostScript font package in your TeX package manager") from None

    def _parse_and_cache_line(self, line):
        if not line or line.startswith((b' ', b'%', b'*', b';', b'#')):
            return
        tfmname = basename = special = encodingfile = fontfile = None
        is_subsetted = is_t1 = is_truetype = False
        matches = re.finditer(b'"([^"]*)(?:"|$)|(\\S+)', line)
        for match in matches:
            (quoted, unquoted) = match.groups()
            if unquoted:
                if unquoted.startswith(b'<<'):
                    fontfile = unquoted[2:]
                elif unquoted.startswith(b'<['):
                    encodingfile = unquoted[2:]
                elif unquoted.startswith(b'<'):
                    word = unquoted[1:] or next(filter(None, next(matches).groups()))
                    if word.endswith(b'.enc'):
                        encodingfile = word
                    else:
                        fontfile = word
                        is_subsetted = True
                elif tfmname is None:
                    tfmname = unquoted
                elif basename is None:
                    basename = unquoted
            elif quoted:
                special = quoted
        effects = {}
        if special:
            words = reversed(special.split())
            for word in words:
                if word == b'SlantFont':
                    effects['slant'] = float(next(words))
                elif word == b'ExtendFont':
                    effects['extend'] = float(next(words))
        if fontfile is not None:
            if fontfile.endswith((b'.ttf', b'.ttc')):
                is_truetype = True
            elif not fontfile.endswith(b'.otf'):
                is_t1 = True
        elif basename is not None:
            is_t1 = True
        if is_truetype and is_subsetted and (encodingfile is None):
            return
        if not is_t1 and ('slant' in effects or 'extend' in effects):
            return
        if abs(effects.get('slant', 0)) > 1:
            return
        if abs(effects.get('extend', 0)) > 2:
            return
        if basename is None:
            basename = tfmname
        if encodingfile is not None:
            encodingfile = find_tex_file(encodingfile)
        if fontfile is not None:
            fontfile = find_tex_file(fontfile)
        self._parsed[tfmname] = PsFont(texname=tfmname, psname=basename, effects=effects, encoding=encodingfile, filename=fontfile)
        return True

def _parse_enc(path):
    no_comments = re.sub('%.*', '', Path(path).read_text(encoding='ascii'))
    array = re.search('(?s)\\[(.*)\\]', no_comments).group(1)
    lines = [line for line in array.split() if line]
    if all((line.startswith('/') for line in lines)):
        return [line[1:] for line in lines]
    else:
        raise ValueError(f'Failed to parse {path} as Postscript encoding')

class _LuatexKpsewhich:

    @lru_cache
    def __new__(cls):
        self = object.__new__(cls)
        self._proc = self._new_proc()
        return self

    def _new_proc(self):
        return subprocess.Popen(['luatex', '--luaonly', str(cbook._get_data_path('kpsewhich.lua'))], stdin=subprocess.PIPE, stdout=subprocess.PIPE)

    def search(self, filename):
        if self._proc.poll() is not None:
            self._proc = self._new_proc()
        self._proc.stdin.write(os.fsencode(filename) + b'\n')
        self._proc.stdin.flush()
        out = self._proc.stdout.readline().rstrip()
        return None if out == b'nil' else os.fsdecode(out)

@lru_cache
def find_tex_file(filename):
    if isinstance(filename, bytes):
        filename = filename.decode('utf-8', errors='replace')
    try:
        lk = _LuatexKpsewhich()
    except FileNotFoundError:
        lk = None
    if lk:
        path = lk.search(filename)
    else:
        if sys.platform == 'win32':
            kwargs = {'env': {**os.environ, 'command_line_encoding': 'utf-8'}, 'encoding': 'utf-8'}
        else:
            kwargs = {'encoding': sys.getfilesystemencoding(), 'errors': 'surrogateescape'}
        try:
            path = cbook._check_and_log_subprocess(['kpsewhich', filename], _log, **kwargs).rstrip('\n')
        except (FileNotFoundError, RuntimeError):
            path = None
    if path:
        return path
    else:
        raise FileNotFoundError(f"Matplotlib's TeX implementation searched for a file named {filename!r} in your texmf tree, but could not find it")

@lru_cache
def _fontfile(cls, suffix, texname):
    return cls(find_tex_file(texname + suffix))
_tfmfile = partial(_fontfile, Tfm, '.tfm')
_vffile = partial(_fontfile, Vf, '.vf')
if __name__ == '__main__':
    from argparse import ArgumentParser
    import itertools
    parser = ArgumentParser()
    parser.add_argument('filename')
    parser.add_argument('dpi', nargs='?', type=float, default=None)
    args = parser.parse_args()
    with Dvi(args.filename, args.dpi) as dvi:
        fontmap = PsfontsMap(find_tex_file('pdftex.map'))
        for page in dvi:
            print(f'=== new page === (w: {page.width}, h: {page.height}, d: {page.descent})')
            for (font, group) in itertools.groupby(page.text, lambda text: text.font):
                print(f"font: {font.texname.decode('latin-1')!r}\tscale: {font._scale / 2 ** 20}")
                print('x', 'y', 'glyph', 'chr', 'w', '(glyphs)', sep='\t')
                for text in group:
                    print(text.x, text.y, text.glyph, chr(text.glyph) if chr(text.glyph).isprintable() else '.', text.width, sep='\t')
            if page.boxes:
                print('x', 'y', 'h', 'w', '', '(boxes)', sep='\t')
                for box in page.boxes:
                    print(box.x, box.y, box.height, box.width, sep='\t')

# File: matplotlib-main/lib/matplotlib/figure.py
""""""
from contextlib import ExitStack
import inspect
import itertools
import functools
import logging
from numbers import Integral
import threading
import numpy as np
import matplotlib as mpl
from matplotlib import _blocking_input, backend_bases, _docstring, projections
from matplotlib.artist import Artist, allow_rasterization, _finalize_rasterization
from matplotlib.backend_bases import DrawEvent, FigureCanvasBase, NonGuiException, MouseButton, _get_renderer
import matplotlib._api as _api
import matplotlib.cbook as cbook
import matplotlib.colorbar as cbar
import matplotlib.image as mimage
from matplotlib.axes import Axes
from matplotlib.gridspec import GridSpec, SubplotParams
from matplotlib.layout_engine import ConstrainedLayoutEngine, TightLayoutEngine, LayoutEngine, PlaceHolderLayoutEngine
import matplotlib.legend as mlegend
from matplotlib.patches import Rectangle
from matplotlib.text import Text
from matplotlib.transforms import Affine2D, Bbox, BboxTransformTo, TransformedBbox
_log = logging.getLogger(__name__)

def _stale_figure_callback(self, val):
    if (fig := self.get_figure(root=False)) is not None:
        fig.stale = val

class _AxesStack:

    def __init__(self):
        self._axes = {}
        self._counter = itertools.count()

    def as_list(self):
        return [*self._axes]

    def remove(self, a):
        self._axes.pop(a)

    def bubble(self, a):
        if a not in self._axes:
            raise ValueError('Axes has not been added yet')
        self._axes[a] = next(self._counter)

    def add(self, a):
        if a not in self._axes:
            self._axes[a] = next(self._counter)

    def current(self):
        return max(self._axes, key=self._axes.__getitem__, default=None)

    def __getstate__(self):
        return {**vars(self), '_counter': max(self._axes.values(), default=0)}

    def __setstate__(self, state):
        next_counter = state.pop('_counter')
        vars(self).update(state)
        self._counter = itertools.count(next_counter)

class FigureBase(Artist):

    def __init__(self, **kwargs):
        super().__init__()
        del self._axes
        self._suptitle = None
        self._supxlabel = None
        self._supylabel = None
        self._align_label_groups = {'x': cbook.Grouper(), 'y': cbook.Grouper(), 'title': cbook.Grouper()}
        self._localaxes = []
        self.artists = []
        self.lines = []
        self.patches = []
        self.texts = []
        self.images = []
        self.legends = []
        self.subfigs = []
        self.stale = True
        self.suppressComposite = None
        self.set(**kwargs)

    def _get_draw_artists(self, renderer):
        artists = self.get_children()
        artists.remove(self.patch)
        artists = sorted((artist for artist in artists if not artist.get_animated()), key=lambda artist: artist.get_zorder())
        for ax in self._localaxes:
            locator = ax.get_axes_locator()
            ax.apply_aspect(locator(ax, renderer) if locator else None)
            for child in ax.get_children():
                if hasattr(child, 'apply_aspect'):
                    locator = child.get_axes_locator()
                    child.apply_aspect(locator(child, renderer) if locator else None)
        return artists

    def autofmt_xdate(self, bottom=0.2, rotation=30, ha='right', which='major'):
        _api.check_in_list(['major', 'minor', 'both'], which=which)
        allsubplots = all((ax.get_subplotspec() for ax in self.axes))
        if len(self.axes) == 1:
            for label in self.axes[0].get_xticklabels(which=which):
                label.set_ha(ha)
                label.set_rotation(rotation)
        elif allsubplots:
            for ax in self.get_axes():
                if ax.get_subplotspec().is_last_row():
                    for label in ax.get_xticklabels(which=which):
                        label.set_ha(ha)
                        label.set_rotation(rotation)
                else:
                    for label in ax.get_xticklabels(which=which):
                        label.set_visible(False)
                    ax.set_xlabel('')
        if allsubplots:
            self.subplots_adjust(bottom=bottom)
        self.stale = True

    def get_children(self):
        return [self.patch, *self.artists, *self._localaxes, *self.lines, *self.patches, *self.texts, *self.images, *self.legends, *self.subfigs]

    def get_figure(self, root=None):
        if self._root_figure is self:
            return self
        if self._parent is self._root_figure:
            return self._parent
        if root is None:
            message = 'From Matplotlib 3.12 SubFigure.get_figure will by default return the direct parent figure, which may be a SubFigure. To suppress this warning, pass the root parameter.  Pass `True` to maintain the old behavior and `False` to opt-in to the future behavior.'
            _api.warn_deprecated('3.10', message=message)
            root = True
        if root:
            return self._root_figure
        return self._parent

    def set_figure(self, fig):
        no_switch = 'The parent and root figures of a (Sub)Figure are set at instantiation and cannot be changed.'
        if fig is self._root_figure:
            _api.warn_deprecated('3.10', message=f'{no_switch} From Matplotlib 3.12 this operation will raise an exception.')
            return
        raise ValueError(no_switch)
    figure = property(functools.partial(get_figure, root=True), set_figure, doc='The root `Figure`.  To get the parent of a `SubFigure`, use the `get_figure` method.')

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        inside = self.bbox.contains(mouseevent.x, mouseevent.y)
        return (inside, {})

    def get_window_extent(self, renderer=None):
        return self.bbox

    def _suplabels(self, t, info, **kwargs):
        x = kwargs.pop('x', None)
        y = kwargs.pop('y', None)
        if info['name'] in ['_supxlabel', '_suptitle']:
            autopos = y is None
        elif info['name'] == '_supylabel':
            autopos = x is None
        if x is None:
            x = info['x0']
        if y is None:
            y = info['y0']
        kwargs = cbook.normalize_kwargs(kwargs, Text)
        kwargs.setdefault('horizontalalignment', info['ha'])
        kwargs.setdefault('verticalalignment', info['va'])
        kwargs.setdefault('rotation', info['rotation'])
        if 'fontproperties' not in kwargs:
            kwargs.setdefault('fontsize', mpl.rcParams[info['size']])
            kwargs.setdefault('fontweight', mpl.rcParams[info['weight']])
        suplab = getattr(self, info['name'])
        if suplab is not None:
            suplab.set_text(t)
            suplab.set_position((x, y))
            suplab.set(**kwargs)
        else:
            suplab = self.text(x, y, t, **kwargs)
            setattr(self, info['name'], suplab)
        suplab._autopos = autopos
        self.stale = True
        return suplab

    @_docstring.Substitution(x0=0.5, y0=0.98, name='suptitle', ha='center', va='top', rc='title')
    @_docstring.copy(_suplabels)
    def suptitle(self, t, **kwargs):
        info = {'name': '_suptitle', 'x0': 0.5, 'y0': 0.98, 'ha': 'center', 'va': 'top', 'rotation': 0, 'size': 'figure.titlesize', 'weight': 'figure.titleweight'}
        return self._suplabels(t, info, **kwargs)

    def get_suptitle(self):
        text_obj = self._suptitle
        return '' if text_obj is None else text_obj.get_text()

    @_docstring.Substitution(x0=0.5, y0=0.01, name='supxlabel', ha='center', va='bottom', rc='label')
    @_docstring.copy(_suplabels)
    def supxlabel(self, t, **kwargs):
        info = {'name': '_supxlabel', 'x0': 0.5, 'y0': 0.01, 'ha': 'center', 'va': 'bottom', 'rotation': 0, 'size': 'figure.labelsize', 'weight': 'figure.labelweight'}
        return self._suplabels(t, info, **kwargs)

    def get_supxlabel(self):
        text_obj = self._supxlabel
        return '' if text_obj is None else text_obj.get_text()

    @_docstring.Substitution(x0=0.02, y0=0.5, name='supylabel', ha='left', va='center', rc='label')
    @_docstring.copy(_suplabels)
    def supylabel(self, t, **kwargs):
        info = {'name': '_supylabel', 'x0': 0.02, 'y0': 0.5, 'ha': 'left', 'va': 'center', 'rotation': 'vertical', 'rotation_mode': 'anchor', 'size': 'figure.labelsize', 'weight': 'figure.labelweight'}
        return self._suplabels(t, info, **kwargs)

    def get_supylabel(self):
        text_obj = self._supylabel
        return '' if text_obj is None else text_obj.get_text()

    def get_edgecolor(self):
        return self.patch.get_edgecolor()

    def get_facecolor(self):
        return self.patch.get_facecolor()

    def get_frameon(self):
        return self.patch.get_visible()

    def set_linewidth(self, linewidth):
        self.patch.set_linewidth(linewidth)

    def get_linewidth(self):
        return self.patch.get_linewidth()

    def set_edgecolor(self, color):
        self.patch.set_edgecolor(color)

    def set_facecolor(self, color):
        self.patch.set_facecolor(color)

    def set_frameon(self, b):
        self.patch.set_visible(b)
        self.stale = True
    frameon = property(get_frameon, set_frameon)

    def add_artist(self, artist, clip=False):
        artist.set_figure(self)
        self.artists.append(artist)
        artist._remove_method = self.artists.remove
        if not artist.is_transform_set():
            artist.set_transform(self.transSubfigure)
        if clip and artist.get_clip_path() is None:
            artist.set_clip_path(self.patch)
        self.stale = True
        return artist

    @_docstring.dedent_interpd
    def add_axes(self, *args, **kwargs):
        if not len(args) and 'rect' not in kwargs:
            raise TypeError("add_axes() missing 1 required positional argument: 'rect'")
        elif 'rect' in kwargs:
            if len(args):
                raise TypeError("add_axes() got multiple values for argument 'rect'")
            args = (kwargs.pop('rect'),)
        if isinstance(args[0], Axes):
            (a, *extra_args) = args
            key = a._projection_init
            if a.get_figure(root=False) is not self:
                raise ValueError('The Axes must have been created in the present figure')
        else:
            (rect, *extra_args) = args
            if not np.isfinite(rect).all():
                raise ValueError(f'all entries in rect must be finite not {rect}')
            (projection_class, pkw) = self._process_projection_requirements(**kwargs)
            a = projection_class(self, rect, **pkw)
            key = (projection_class, pkw)
        if extra_args:
            _api.warn_deprecated('3.8', name='Passing more than one positional argument to Figure.add_axes', addendum='Any additional positional arguments are currently ignored.')
        return self._add_axes_internal(a, key)

    @_docstring.dedent_interpd
    def add_subplot(self, *args, **kwargs):
        if 'figure' in kwargs:
            raise _api.kwarg_error('add_subplot', 'figure')
        if len(args) == 1 and isinstance(args[0], mpl.axes._base._AxesBase) and args[0].get_subplotspec():
            ax = args[0]
            key = ax._projection_init
            if ax.get_figure(root=False) is not self:
                raise ValueError('The Axes must have been created in the present figure')
        else:
            if not args:
                args = (1, 1, 1)
            if len(args) == 1 and isinstance(args[0], Integral) and (100 <= args[0] <= 999):
                args = tuple(map(int, str(args[0])))
            (projection_class, pkw) = self._process_projection_requirements(**kwargs)
            ax = projection_class(self, *args, **pkw)
            key = (projection_class, pkw)
        return self._add_axes_internal(ax, key)

    def _add_axes_internal(self, ax, key):
        self._axstack.add(ax)
        if ax not in self._localaxes:
            self._localaxes.append(ax)
        self.sca(ax)
        ax._remove_method = self.delaxes
        ax._projection_init = key
        self.stale = True
        ax.stale_callback = _stale_figure_callback
        return ax

    def subplots(self, nrows=1, ncols=1, *, sharex=False, sharey=False, squeeze=True, width_ratios=None, height_ratios=None, subplot_kw=None, gridspec_kw=None):
        gridspec_kw = dict(gridspec_kw or {})
        if height_ratios is not None:
            if 'height_ratios' in gridspec_kw:
                raise ValueError("'height_ratios' must not be defined both as parameter and as key in 'gridspec_kw'")
            gridspec_kw['height_ratios'] = height_ratios
        if width_ratios is not None:
            if 'width_ratios' in gridspec_kw:
                raise ValueError("'width_ratios' must not be defined both as parameter and as key in 'gridspec_kw'")
            gridspec_kw['width_ratios'] = width_ratios
        gs = self.add_gridspec(nrows, ncols, figure=self, **gridspec_kw)
        axs = gs.subplots(sharex=sharex, sharey=sharey, squeeze=squeeze, subplot_kw=subplot_kw)
        return axs

    def delaxes(self, ax):
        self._remove_axes(ax, owners=[self._axstack, self._localaxes])

    def _remove_axes(self, ax, owners):
        for owner in owners:
            owner.remove(ax)
        self._axobservers.process('_axes_change_event', self)
        self.stale = True
        self._root_figure.canvas.release_mouse(ax)
        for name in ax._axis_names:
            grouper = ax._shared_axes[name]
            siblings = [other for other in grouper.get_siblings(ax) if other is not ax]
            if not siblings:
                continue
            grouper.remove(ax)
            remaining_axis = siblings[0]._axis_map[name]
            remaining_axis.get_major_formatter().set_axis(remaining_axis)
            remaining_axis.get_major_locator().set_axis(remaining_axis)
            remaining_axis.get_minor_formatter().set_axis(remaining_axis)
            remaining_axis.get_minor_locator().set_axis(remaining_axis)
        ax._twinned_axes.remove(ax)

    def clear(self, keep_observers=False):
        self.suppressComposite = None
        for subfig in self.subfigs:
            subfig.clear(keep_observers=keep_observers)
        self.subfigs = []
        for ax in tuple(self.axes):
            ax.clear()
            self.delaxes(ax)
        self.artists = []
        self.lines = []
        self.patches = []
        self.texts = []
        self.images = []
        self.legends = []
        if not keep_observers:
            self._axobservers = cbook.CallbackRegistry()
        self._suptitle = None
        self._supxlabel = None
        self._supylabel = None
        self.stale = True

    def clf(self, keep_observers=False):
        return self.clear(keep_observers=keep_observers)

    @_docstring.dedent_interpd
    def legend(self, *args, **kwargs):
        (handles, labels, kwargs) = mlegend._parse_legend_args(self.axes, *args, **kwargs)
        kwargs.setdefault('bbox_transform', self.transSubfigure)
        l = mlegend.Legend(self, handles, labels, **kwargs)
        self.legends.append(l)
        l._remove_method = self.legends.remove
        self.stale = True
        return l

    @_docstring.dedent_interpd
    def text(self, x, y, s, fontdict=None, **kwargs):
        effective_kwargs = {'transform': self.transSubfigure, **(fontdict if fontdict is not None else {}), **kwargs}
        text = Text(x=x, y=y, text=s, **effective_kwargs)
        text.set_figure(self)
        text.stale_callback = _stale_figure_callback
        self.texts.append(text)
        text._remove_method = self.texts.remove
        self.stale = True
        return text

    @_docstring.dedent_interpd
    def colorbar(self, mappable, cax=None, ax=None, use_gridspec=True, **kwargs):
        if ax is None:
            ax = getattr(mappable, 'axes', None)
        if cax is None:
            if ax is None:
                raise ValueError('Unable to determine Axes to steal space for Colorbar. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.')
            fig = ([*ax.flat] if isinstance(ax, np.ndarray) else [*ax] if np.iterable(ax) else [ax])[0].get_figure(root=False)
            current_ax = fig.gca()
            if fig.get_layout_engine() is not None and (not fig.get_layout_engine().colorbar_gridspec):
                use_gridspec = False
            if use_gridspec and isinstance(ax, mpl.axes._base._AxesBase) and ax.get_subplotspec():
                (cax, kwargs) = cbar.make_axes_gridspec(ax, **kwargs)
            else:
                (cax, kwargs) = cbar.make_axes(ax, **kwargs)
            fig.sca(current_ax)
            cax.grid(visible=False, which='both', axis='both')
        if hasattr(mappable, 'get_figure') and (mappable_host_fig := mappable.get_figure(root=True)) is not None:
            if mappable_host_fig is not self._root_figure:
                _api.warn_external(f'Adding colorbar to a different Figure {repr(mappable_host_fig)} than {repr(self._root_figure)} which fig.colorbar is called on.')
        NON_COLORBAR_KEYS = ['fraction', 'pad', 'shrink', 'aspect', 'anchor', 'panchor']
        cb = cbar.Colorbar(cax, mappable, **{k: v for (k, v) in kwargs.items() if k not in NON_COLORBAR_KEYS})
        cax.get_figure(root=False).stale = True
        return cb

    def subplots_adjust(self, left=None, bottom=None, right=None, top=None, wspace=None, hspace=None):
        if self.get_layout_engine() is not None and (not self.get_layout_engine().adjust_compatible):
            _api.warn_external('This figure was using a layout engine that is incompatible with subplots_adjust and/or tight_layout; not calling subplots_adjust.')
            return
        self.subplotpars.update(left, bottom, right, top, wspace, hspace)
        for ax in self.axes:
            if ax.get_subplotspec() is not None:
                ax._set_position(ax.get_subplotspec().get_position(self))
        self.stale = True

    def align_xlabels(self, axs=None):
        if axs is None:
            axs = self.axes
        axs = [ax for ax in np.ravel(axs) if ax.get_subplotspec() is not None]
        for ax in axs:
            _log.debug(' Working on: %s', ax.get_xlabel())
            rowspan = ax.get_subplotspec().rowspan
            pos = ax.xaxis.get_label_position()
            for axc in axs:
                if axc.xaxis.get_label_position() == pos:
                    rowspanc = axc.get_subplotspec().rowspan
                    if pos == 'top' and rowspan.start == rowspanc.start or (pos == 'bottom' and rowspan.stop == rowspanc.stop):
                        self._align_label_groups['x'].join(ax, axc)

    def align_ylabels(self, axs=None):
        if axs is None:
            axs = self.axes
        axs = [ax for ax in np.ravel(axs) if ax.get_subplotspec() is not None]
        for ax in axs:
            _log.debug(' Working on: %s', ax.get_ylabel())
            colspan = ax.get_subplotspec().colspan
            pos = ax.yaxis.get_label_position()
            for axc in axs:
                if axc.yaxis.get_label_position() == pos:
                    colspanc = axc.get_subplotspec().colspan
                    if pos == 'left' and colspan.start == colspanc.start or (pos == 'right' and colspan.stop == colspanc.stop):
                        self._align_label_groups['y'].join(ax, axc)

    def align_titles(self, axs=None):
        if axs is None:
            axs = self.axes
        axs = [ax for ax in np.ravel(axs) if ax.get_subplotspec() is not None]
        for ax in axs:
            _log.debug(' Working on: %s', ax.get_title())
            rowspan = ax.get_subplotspec().rowspan
            for axc in axs:
                rowspanc = axc.get_subplotspec().rowspan
                if rowspan.start == rowspanc.start:
                    self._align_label_groups['title'].join(ax, axc)

    def align_labels(self, axs=None):
        self.align_xlabels(axs=axs)
        self.align_ylabels(axs=axs)

    def add_gridspec(self, nrows=1, ncols=1, **kwargs):
        _ = kwargs.pop('figure', None)
        gs = GridSpec(nrows=nrows, ncols=ncols, figure=self, **kwargs)
        return gs

    def subfigures(self, nrows=1, ncols=1, squeeze=True, wspace=None, hspace=None, width_ratios=None, height_ratios=None, **kwargs):
        gs = GridSpec(nrows=nrows, ncols=ncols, figure=self, wspace=wspace, hspace=hspace, width_ratios=width_ratios, height_ratios=height_ratios, left=0, right=1, bottom=0, top=1)
        sfarr = np.empty((nrows, ncols), dtype=object)
        for i in range(nrows):
            for j in range(ncols):
                sfarr[i, j] = self.add_subfigure(gs[i, j], **kwargs)
        if self.get_layout_engine() is None and (wspace is not None or hspace is not None):
            (bottoms, tops, lefts, rights) = gs.get_grid_positions(self)
            for (sfrow, bottom, top) in zip(sfarr, bottoms, tops):
                for (sf, left, right) in zip(sfrow, lefts, rights):
                    bbox = Bbox.from_extents(left, bottom, right, top)
                    sf._redo_transform_rel_fig(bbox=bbox)
        if squeeze:
            return sfarr.item() if sfarr.size == 1 else sfarr.squeeze()
        else:
            return sfarr

    def add_subfigure(self, subplotspec, **kwargs):
        sf = SubFigure(self, subplotspec, **kwargs)
        self.subfigs += [sf]
        sf._remove_method = self.subfigs.remove
        sf.stale_callback = _stale_figure_callback
        self.stale = True
        return sf

    def sca(self, a):
        self._axstack.bubble(a)
        self._axobservers.process('_axes_change_event', self)
        return a

    def gca(self):
        ax = self._axstack.current()
        return ax if ax is not None else self.add_subplot()

    def _gci(self):
        ax = self._axstack.current()
        if ax is None:
            return None
        im = ax._gci()
        if im is not None:
            return im
        for ax in reversed(self.axes):
            im = ax._gci()
            if im is not None:
                return im
        return None

    def _process_projection_requirements(self, *, axes_class=None, polar=False, projection=None, **kwargs):
        if axes_class is not None:
            if polar or projection is not None:
                raise ValueError("Cannot combine 'axes_class' and 'projection' or 'polar'")
            projection_class = axes_class
        else:
            if polar:
                if projection is not None and projection != 'polar':
                    raise ValueError(f'polar={polar}, yet projection={projection!r}. Only one of these arguments should be supplied.')
                projection = 'polar'
            if isinstance(projection, str) or projection is None:
                projection_class = projections.get_projection_class(projection)
            elif hasattr(projection, '_as_mpl_axes'):
                (projection_class, extra_kwargs) = projection._as_mpl_axes()
                kwargs.update(**extra_kwargs)
            else:
                raise TypeError(f'projection must be a string, None or implement a _as_mpl_axes method, not {projection!r}')
        return (projection_class, kwargs)

    def get_default_bbox_extra_artists(self):
        bbox_artists = [artist for artist in self.get_children() if artist.get_visible() and artist.get_in_layout()]
        for ax in self.axes:
            if ax.get_visible():
                bbox_artists.extend(ax.get_default_bbox_extra_artists())
        return bbox_artists

    def get_tightbbox(self, renderer=None, *, bbox_extra_artists=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        bb = []
        if bbox_extra_artists is None:
            artists = [artist for artist in self.get_children() if artist not in self.axes and artist.get_visible() and artist.get_in_layout()]
        else:
            artists = bbox_extra_artists
        for a in artists:
            bbox = a.get_tightbbox(renderer)
            if bbox is not None:
                bb.append(bbox)
        for ax in self.axes:
            if ax.get_visible():
                try:
                    bbox = ax.get_tightbbox(renderer, bbox_extra_artists=bbox_extra_artists)
                except TypeError:
                    bbox = ax.get_tightbbox(renderer)
                bb.append(bbox)
        bb = [b for b in bb if np.isfinite(b.width) and np.isfinite(b.height) and (b.width != 0 or b.height != 0)]
        isfigure = hasattr(self, 'bbox_inches')
        if len(bb) == 0:
            if isfigure:
                return self.bbox_inches
            else:
                bb = [self.bbox]
        _bbox = Bbox.union(bb)
        if isfigure:
            _bbox = TransformedBbox(_bbox, self.dpi_scale_trans.inverted())
        return _bbox

    @staticmethod
    def _norm_per_subplot_kw(per_subplot_kw):
        expanded = {}
        for (k, v) in per_subplot_kw.items():
            if isinstance(k, tuple):
                for sub_key in k:
                    if sub_key in expanded:
                        raise ValueError(f'The key {sub_key!r} appears multiple times.')
                    expanded[sub_key] = v
            else:
                if k in expanded:
                    raise ValueError(f'The key {k!r} appears multiple times.')
                expanded[k] = v
        return expanded

    @staticmethod
    def _normalize_grid_string(layout):
        if '\n' not in layout:
            return [list(ln) for ln in layout.split(';')]
        else:
            layout = inspect.cleandoc(layout)
            return [list(ln) for ln in layout.strip('\n').split('\n')]

    def subplot_mosaic(self, mosaic, *, sharex=False, sharey=False, width_ratios=None, height_ratios=None, empty_sentinel='.', subplot_kw=None, per_subplot_kw=None, gridspec_kw=None):
        subplot_kw = subplot_kw or {}
        gridspec_kw = dict(gridspec_kw or {})
        per_subplot_kw = per_subplot_kw or {}
        if height_ratios is not None:
            if 'height_ratios' in gridspec_kw:
                raise ValueError("'height_ratios' must not be defined both as parameter and as key in 'gridspec_kw'")
            gridspec_kw['height_ratios'] = height_ratios
        if width_ratios is not None:
            if 'width_ratios' in gridspec_kw:
                raise ValueError("'width_ratios' must not be defined both as parameter and as key in 'gridspec_kw'")
            gridspec_kw['width_ratios'] = width_ratios
        if isinstance(mosaic, str):
            mosaic = self._normalize_grid_string(mosaic)
            per_subplot_kw = {tuple(k): v for (k, v) in per_subplot_kw.items()}
        per_subplot_kw = self._norm_per_subplot_kw(per_subplot_kw)
        _api.check_isinstance(bool, sharex=sharex, sharey=sharey)

        def _make_array(inp):
            (r0, *rest) = inp
            if isinstance(r0, str):
                raise ValueError('List mosaic specification must be 2D')
            for (j, r) in enumerate(rest, start=1):
                if isinstance(r, str):
                    raise ValueError('List mosaic specification must be 2D')
                if len(r0) != len(r):
                    raise ValueError(f'All of the rows must be the same length, however the first row ({r0!r}) has length {len(r0)} and row {j} ({r!r}) has length {len(r)}.')
            out = np.zeros((len(inp), len(r0)), dtype=object)
            for (j, r) in enumerate(inp):
                for (k, v) in enumerate(r):
                    out[j, k] = v
            return out

        def _identify_keys_and_nested(mosaic):
            unique_ids = cbook._OrderedSet()
            nested = {}
            for (j, row) in enumerate(mosaic):
                for (k, v) in enumerate(row):
                    if v == empty_sentinel:
                        continue
                    elif not cbook.is_scalar_or_string(v):
                        nested[j, k] = _make_array(v)
                    else:
                        unique_ids.add(v)
            return (tuple(unique_ids), nested)

        def _do_layout(gs, mosaic, unique_ids, nested):
            output = dict()
            this_level = dict()
            for name in unique_ids:
                indx = np.argwhere(mosaic == name)
                (start_row, start_col) = np.min(indx, axis=0)
                (end_row, end_col) = np.max(indx, axis=0) + 1
                slc = (slice(start_row, end_row), slice(start_col, end_col))
                if (mosaic[slc] != name).any():
                    raise ValueError(f'While trying to layout\n{mosaic!r}\nwe found that the label {name!r} specifies a non-rectangular or non-contiguous area.')
                this_level[start_row, start_col] = (name, slc, 'axes')
            for ((j, k), nested_mosaic) in nested.items():
                this_level[j, k] = (None, nested_mosaic, 'nested')
            for key in sorted(this_level):
                (name, arg, method) = this_level[key]
                if method == 'axes':
                    slc = arg
                    if name in output:
                        raise ValueError(f'There are duplicate keys {name} in the layout\n{mosaic!r}')
                    ax = self.add_subplot(gs[slc], **{'label': str(name), **subplot_kw, **per_subplot_kw.get(name, {})})
                    output[name] = ax
                elif method == 'nested':
                    nested_mosaic = arg
                    (j, k) = key
                    (rows, cols) = nested_mosaic.shape
                    nested_output = _do_layout(gs[j, k].subgridspec(rows, cols), nested_mosaic, *_identify_keys_and_nested(nested_mosaic))
                    overlap = set(output) & set(nested_output)
                    if overlap:
                        raise ValueError(f'There are duplicate keys {overlap} between the outer layout\n{mosaic!r}\nand the nested layout\n{nested_mosaic}')
                    output.update(nested_output)
                else:
                    raise RuntimeError('This should never happen')
            return output
        mosaic = _make_array(mosaic)
        (rows, cols) = mosaic.shape
        gs = self.add_gridspec(rows, cols, **gridspec_kw)
        ret = _do_layout(gs, mosaic, *_identify_keys_and_nested(mosaic))
        ax0 = next(iter(ret.values()))
        for ax in ret.values():
            if sharex:
                ax.sharex(ax0)
                ax._label_outer_xaxis(skip_non_rectangular_axes=True)
            if sharey:
                ax.sharey(ax0)
                ax._label_outer_yaxis(skip_non_rectangular_axes=True)
        if (extra := (set(per_subplot_kw) - set(ret))):
            raise ValueError(f'The keys {extra} are in *per_subplot_kw* but not in the mosaic.')
        return ret

    def _set_artist_props(self, a):
        if a != self:
            a.set_figure(self)
        a.stale_callback = _stale_figure_callback
        a.set_transform(self.transSubfigure)

@_docstring.interpd
class SubFigure(FigureBase):

    def __init__(self, parent, subplotspec, *, facecolor=None, edgecolor=None, linewidth=0.0, frameon=None, **kwargs):
        super().__init__(**kwargs)
        if facecolor is None:
            facecolor = 'none'
        if edgecolor is None:
            edgecolor = mpl.rcParams['figure.edgecolor']
        if frameon is None:
            frameon = mpl.rcParams['figure.frameon']
        self._subplotspec = subplotspec
        self._parent = parent
        self._root_figure = parent._root_figure
        self._axstack = parent._axstack
        self.subplotpars = parent.subplotpars
        self.dpi_scale_trans = parent.dpi_scale_trans
        self._axobservers = parent._axobservers
        self.transFigure = parent.transFigure
        self.bbox_relative = Bbox.null()
        self._redo_transform_rel_fig()
        self.figbbox = self._parent.figbbox
        self.bbox = TransformedBbox(self.bbox_relative, self._parent.transSubfigure)
        self.transSubfigure = BboxTransformTo(self.bbox)
        self.patch = Rectangle(xy=(0, 0), width=1, height=1, visible=frameon, facecolor=facecolor, edgecolor=edgecolor, linewidth=linewidth, in_layout=False, transform=self.transSubfigure)
        self._set_artist_props(self.patch)
        self.patch.set_antialiased(False)

    @property
    def canvas(self):
        return self._parent.canvas

    @property
    def dpi(self):
        return self._parent.dpi

    @dpi.setter
    def dpi(self, value):
        self._parent.dpi = value

    def get_dpi(self):
        return self._parent.dpi

    def set_dpi(self, val):
        self._parent.dpi = val
        self.stale = True

    def _get_renderer(self):
        return self._parent._get_renderer()

    def _redo_transform_rel_fig(self, bbox=None):
        if bbox is not None:
            self.bbox_relative.p0 = bbox.p0
            self.bbox_relative.p1 = bbox.p1
            return
        gs = self._subplotspec.get_gridspec()
        wr = np.asarray(gs.get_width_ratios())
        hr = np.asarray(gs.get_height_ratios())
        dx = wr[self._subplotspec.colspan].sum() / wr.sum()
        dy = hr[self._subplotspec.rowspan].sum() / hr.sum()
        x0 = wr[:self._subplotspec.colspan.start].sum() / wr.sum()
        y0 = 1 - hr[:self._subplotspec.rowspan.stop].sum() / hr.sum()
        self.bbox_relative.p0 = (x0, y0)
        self.bbox_relative.p1 = (x0 + dx, y0 + dy)

    def get_constrained_layout(self):
        return self._parent.get_constrained_layout()

    def get_constrained_layout_pads(self, relative=False):
        return self._parent.get_constrained_layout_pads(relative=relative)

    def get_layout_engine(self):
        return self._parent.get_layout_engine()

    @property
    def axes(self):
        return self._localaxes[:]
    get_axes = axes.fget

    def draw(self, renderer):
        if not self.get_visible():
            return
        artists = self._get_draw_artists(renderer)
        try:
            renderer.open_group('subfigure', gid=self.get_gid())
            self.patch.draw(renderer)
            mimage._draw_list_compositing_images(renderer, self, artists, self.get_figure(root=True).suppressComposite)
            renderer.close_group('subfigure')
        finally:
            self.stale = False

@_docstring.interpd
class Figure(FigureBase):
    _render_lock = threading.RLock()

    def __str__(self):
        return 'Figure(%gx%g)' % tuple(self.bbox.size)

    def __repr__(self):
        return '<{clsname} size {h:g}x{w:g} with {naxes} Axes>'.format(clsname=self.__class__.__name__, h=self.bbox.size[0], w=self.bbox.size[1], naxes=len(self.axes))

    def __init__(self, figsize=None, dpi=None, *, facecolor=None, edgecolor=None, linewidth=0.0, frameon=None, subplotpars=None, tight_layout=None, constrained_layout=None, layout=None, **kwargs):
        super().__init__(**kwargs)
        self._root_figure = self
        self._layout_engine = None
        if layout is not None:
            if tight_layout is not None:
                _api.warn_external("The Figure parameters 'layout' and 'tight_layout' cannot be used together. Please use 'layout' only.")
            if constrained_layout is not None:
                _api.warn_external("The Figure parameters 'layout' and 'constrained_layout' cannot be used together. Please use 'layout' only.")
            self.set_layout_engine(layout=layout)
        elif tight_layout is not None:
            if constrained_layout is not None:
                _api.warn_external("The Figure parameters 'tight_layout' and 'constrained_layout' cannot be used together. Please use 'layout' parameter")
            self.set_layout_engine(layout='tight')
            if isinstance(tight_layout, dict):
                self.get_layout_engine().set(**tight_layout)
        elif constrained_layout is not None:
            if isinstance(constrained_layout, dict):
                self.set_layout_engine(layout='constrained')
                self.get_layout_engine().set(**constrained_layout)
            elif constrained_layout:
                self.set_layout_engine(layout='constrained')
        else:
            self.set_layout_engine(layout=layout)
        self._canvas_callbacks = cbook.CallbackRegistry(signals=FigureCanvasBase.events)
        connect = self._canvas_callbacks._connect_picklable
        self._mouse_key_ids = [connect('key_press_event', backend_bases._key_handler), connect('key_release_event', backend_bases._key_handler), connect('key_release_event', backend_bases._key_handler), connect('button_press_event', backend_bases._mouse_handler), connect('button_release_event', backend_bases._mouse_handler), connect('scroll_event', backend_bases._mouse_handler), connect('motion_notify_event', backend_bases._mouse_handler)]
        self._button_pick_id = connect('button_press_event', self.pick)
        self._scroll_pick_id = connect('scroll_event', self.pick)
        if figsize is None:
            figsize = mpl.rcParams['figure.figsize']
        if dpi is None:
            dpi = mpl.rcParams['figure.dpi']
        if facecolor is None:
            facecolor = mpl.rcParams['figure.facecolor']
        if edgecolor is None:
            edgecolor = mpl.rcParams['figure.edgecolor']
        if frameon is None:
            frameon = mpl.rcParams['figure.frameon']
        if not np.isfinite(figsize).all() or (np.array(figsize) < 0).any():
            raise ValueError(f'figure size must be positive finite not {figsize}')
        self.bbox_inches = Bbox.from_bounds(0, 0, *figsize)
        self.dpi_scale_trans = Affine2D().scale(dpi)
        self._dpi = dpi
        self.bbox = TransformedBbox(self.bbox_inches, self.dpi_scale_trans)
        self.figbbox = self.bbox
        self.transFigure = BboxTransformTo(self.bbox)
        self.transSubfigure = self.transFigure
        self.patch = Rectangle(xy=(0, 0), width=1, height=1, visible=frameon, facecolor=facecolor, edgecolor=edgecolor, linewidth=linewidth, in_layout=False)
        self._set_artist_props(self.patch)
        self.patch.set_antialiased(False)
        FigureCanvasBase(self)
        if subplotpars is None:
            subplotpars = SubplotParams()
        self.subplotpars = subplotpars
        self._axstack = _AxesStack()
        self.clear()

    def pick(self, mouseevent):
        if not self.canvas.widgetlock.locked():
            super().pick(mouseevent)

    def _check_layout_engines_compat(self, old, new):
        if old is None or new is None:
            return True
        if old.colorbar_gridspec == new.colorbar_gridspec:
            return True
        for ax in self.axes:
            if hasattr(ax, '_colorbar'):
                return False
        return True

    def set_layout_engine(self, layout=None, **kwargs):
        if layout is None:
            if mpl.rcParams['figure.autolayout']:
                layout = 'tight'
            elif mpl.rcParams['figure.constrained_layout.use']:
                layout = 'constrained'
            else:
                self._layout_engine = None
                return
        if layout == 'tight':
            new_layout_engine = TightLayoutEngine(**kwargs)
        elif layout == 'constrained':
            new_layout_engine = ConstrainedLayoutEngine(**kwargs)
        elif layout == 'compressed':
            new_layout_engine = ConstrainedLayoutEngine(compress=True, **kwargs)
        elif layout == 'none':
            if self._layout_engine is not None:
                new_layout_engine = PlaceHolderLayoutEngine(self._layout_engine.adjust_compatible, self._layout_engine.colorbar_gridspec)
            else:
                new_layout_engine = None
        elif isinstance(layout, LayoutEngine):
            new_layout_engine = layout
        else:
            raise ValueError(f"Invalid value for 'layout': {layout!r}")
        if self._check_layout_engines_compat(self._layout_engine, new_layout_engine):
            self._layout_engine = new_layout_engine
        else:
            raise RuntimeError('Colorbar layout of new layout engine not compatible with old engine, and a colorbar has been created.  Engine not changed.')

    def get_layout_engine(self):
        return self._layout_engine

    def _repr_html_(self):
        if 'WebAgg' in type(self.canvas).__name__:
            from matplotlib.backends import backend_webagg
            return backend_webagg.ipython_inline_display(self)

    def show(self, warn=True):
        if self.canvas.manager is None:
            raise AttributeError('Figure.show works only for figures managed by pyplot, normally created by pyplot.figure()')
        try:
            self.canvas.manager.show()
        except NonGuiException as exc:
            if warn:
                _api.warn_external(str(exc))

    @property
    def axes(self):
        return self._axstack.as_list()
    get_axes = axes.fget

    def _get_renderer(self):
        if hasattr(self.canvas, 'get_renderer'):
            return self.canvas.get_renderer()
        else:
            return _get_renderer(self)

    def _get_dpi(self):
        return self._dpi

    def _set_dpi(self, dpi, forward=True):
        if dpi == self._dpi:
            return
        self._dpi = dpi
        self.dpi_scale_trans.clear().scale(dpi)
        (w, h) = self.get_size_inches()
        self.set_size_inches(w, h, forward=forward)
    dpi = property(_get_dpi, _set_dpi, doc='The resolution in dots per inch.')

    def get_tight_layout(self):
        return isinstance(self.get_layout_engine(), TightLayoutEngine)

    @_api.deprecated('3.6', alternative='set_layout_engine', pending=True)
    def set_tight_layout(self, tight):
        if tight is None:
            tight = mpl.rcParams['figure.autolayout']
        _tight = 'tight' if bool(tight) else 'none'
        _tight_parameters = tight if isinstance(tight, dict) else {}
        self.set_layout_engine(_tight, **_tight_parameters)
        self.stale = True

    def get_constrained_layout(self):
        return isinstance(self.get_layout_engine(), ConstrainedLayoutEngine)

    @_api.deprecated('3.6', alternative="set_layout_engine('constrained')", pending=True)
    def set_constrained_layout(self, constrained):
        if constrained is None:
            constrained = mpl.rcParams['figure.constrained_layout.use']
        _constrained = 'constrained' if bool(constrained) else 'none'
        _parameters = constrained if isinstance(constrained, dict) else {}
        self.set_layout_engine(_constrained, **_parameters)
        self.stale = True

    @_api.deprecated('3.6', alternative='figure.get_layout_engine().set()', pending=True)
    def set_constrained_layout_pads(self, **kwargs):
        if isinstance(self.get_layout_engine(), ConstrainedLayoutEngine):
            self.get_layout_engine().set(**kwargs)

    @_api.deprecated('3.6', alternative='fig.get_layout_engine().get()', pending=True)
    def get_constrained_layout_pads(self, relative=False):
        if not isinstance(self.get_layout_engine(), ConstrainedLayoutEngine):
            return (None, None, None, None)
        info = self.get_layout_engine().get()
        w_pad = info['w_pad']
        h_pad = info['h_pad']
        wspace = info['wspace']
        hspace = info['hspace']
        if relative and (w_pad is not None or h_pad is not None):
            renderer = self._get_renderer()
            dpi = renderer.dpi
            w_pad = w_pad * dpi / renderer.width
            h_pad = h_pad * dpi / renderer.height
        return (w_pad, h_pad, wspace, hspace)

    def set_canvas(self, canvas):
        self.canvas = canvas

    @_docstring.interpd
    def figimage(self, X, xo=0, yo=0, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, origin=None, resize=False, **kwargs):
        if resize:
            dpi = self.get_dpi()
            figsize = [x / dpi for x in (X.shape[1], X.shape[0])]
            self.set_size_inches(figsize, forward=True)
        im = mimage.FigureImage(self, cmap=cmap, norm=norm, offsetx=xo, offsety=yo, origin=origin, **kwargs)
        im.stale_callback = _stale_figure_callback
        im.set_array(X)
        im.set_alpha(alpha)
        if norm is None:
            im.set_clim(vmin, vmax)
        self.images.append(im)
        im._remove_method = self.images.remove
        self.stale = True
        return im

    def set_size_inches(self, w, h=None, forward=True):
        if h is None:
            (w, h) = w
        size = np.array([w, h])
        if not np.isfinite(size).all() or (size < 0).any():
            raise ValueError(f'figure size must be positive finite not {size}')
        self.bbox_inches.p1 = size
        if forward:
            manager = self.canvas.manager
            if manager is not None:
                manager.resize(*(size * self.dpi).astype(int))
        self.stale = True

    def get_size_inches(self):
        return np.array(self.bbox_inches.p1)

    def get_figwidth(self):
        return self.bbox_inches.width

    def get_figheight(self):
        return self.bbox_inches.height

    def get_dpi(self):
        return self.dpi

    def set_dpi(self, val):
        self.dpi = val
        self.stale = True

    def set_figwidth(self, val, forward=True):
        self.set_size_inches(val, self.get_figheight(), forward=forward)

    def set_figheight(self, val, forward=True):
        self.set_size_inches(self.get_figwidth(), val, forward=forward)

    def clear(self, keep_observers=False):
        super().clear(keep_observers=keep_observers)
        toolbar = self.canvas.toolbar
        if toolbar is not None:
            toolbar.update()

    @_finalize_rasterization
    @allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        with self._render_lock:
            artists = self._get_draw_artists(renderer)
            try:
                renderer.open_group('figure', gid=self.get_gid())
                if self.axes and self.get_layout_engine() is not None:
                    try:
                        self.get_layout_engine().execute(self)
                    except ValueError:
                        pass
                self.patch.draw(renderer)
                mimage._draw_list_compositing_images(renderer, self, artists, self.suppressComposite)
                renderer.close_group('figure')
            finally:
                self.stale = False
            DrawEvent('draw_event', self.canvas, renderer)._process()

    def draw_without_rendering(self):
        renderer = _get_renderer(self)
        with renderer._draw_disabled():
            self.draw(renderer)

    def draw_artist(self, a):
        a.draw(self.canvas.get_renderer())

    def __getstate__(self):
        state = super().__getstate__()
        state.pop('canvas')
        state['_dpi'] = state.get('_original_dpi', state['_dpi'])
        state['__mpl_version__'] = mpl.__version__
        from matplotlib import _pylab_helpers
        if self.canvas.manager in _pylab_helpers.Gcf.figs.values():
            state['_restore_to_pylab'] = True
        return state

    def __setstate__(self, state):
        version = state.pop('__mpl_version__')
        restore_to_pylab = state.pop('_restore_to_pylab', False)
        if version != mpl.__version__:
            _api.warn_external(f'This figure was saved with matplotlib version {version} and loaded with {mpl.__version__} so may not function correctly.')
        self.__dict__ = state
        FigureCanvasBase(self)
        if restore_to_pylab:
            import matplotlib.pyplot as plt
            import matplotlib._pylab_helpers as pylab_helpers
            allnums = plt.get_fignums()
            num = max(allnums) + 1 if allnums else 1
            backend = plt._get_backend_mod()
            mgr = backend.new_figure_manager_given_figure(num, self)
            pylab_helpers.Gcf._set_new_active_manager(mgr)
            plt.draw_if_interactive()
        self.stale = True

    def add_axobserver(self, func):
        self._axobservers.connect('_axes_change_event', lambda arg: func(arg))

    def savefig(self, fname, *, transparent=None, **kwargs):
        kwargs.setdefault('dpi', mpl.rcParams['savefig.dpi'])
        if transparent is None:
            transparent = mpl.rcParams['savefig.transparent']
        with ExitStack() as stack:
            if transparent:

                def _recursively_make_subfig_transparent(exit_stack, subfig):
                    exit_stack.enter_context(subfig.patch._cm_set(facecolor='none', edgecolor='none'))
                    for ax in subfig.axes:
                        exit_stack.enter_context(ax.patch._cm_set(facecolor='none', edgecolor='none'))
                    for sub_subfig in subfig.subfigs:
                        _recursively_make_subfig_transparent(exit_stack, sub_subfig)

                def _recursively_make_axes_transparent(exit_stack, ax):
                    exit_stack.enter_context(ax.patch._cm_set(facecolor='none', edgecolor='none'))
                    for child_ax in ax.child_axes:
                        exit_stack.enter_context(child_ax.patch._cm_set(facecolor='none', edgecolor='none'))
                    for child_childax in ax.child_axes:
                        _recursively_make_axes_transparent(exit_stack, child_childax)
                kwargs.setdefault('facecolor', 'none')
                kwargs.setdefault('edgecolor', 'none')
                for subfig in self.subfigs:
                    _recursively_make_subfig_transparent(stack, subfig)
                for ax in self.axes:
                    _recursively_make_axes_transparent(stack, ax)
            self.canvas.print_figure(fname, **kwargs)

    def ginput(self, n=1, timeout=30, show_clicks=True, mouse_add=MouseButton.LEFT, mouse_pop=MouseButton.RIGHT, mouse_stop=MouseButton.MIDDLE):
        clicks = []
        marks = []

        def handler(event):
            is_button = event.name == 'button_press_event'
            is_key = event.name == 'key_press_event'
            if is_button and event.button == mouse_stop or (is_key and event.key in ['escape', 'enter']):
                self.canvas.stop_event_loop()
            elif is_button and event.button == mouse_pop or (is_key and event.key in ['backspace', 'delete']):
                if clicks:
                    clicks.pop()
                    if show_clicks:
                        marks.pop().remove()
                        self.canvas.draw()
            elif is_button and event.button == mouse_add or (is_key and event.key is not None):
                if event.inaxes:
                    clicks.append((event.xdata, event.ydata))
                    _log.info('input %i: %f, %f', len(clicks), event.xdata, event.ydata)
                    if show_clicks:
                        line = mpl.lines.Line2D([event.xdata], [event.ydata], marker='+', color='r')
                        event.inaxes.add_line(line)
                        marks.append(line)
                        self.canvas.draw()
            if len(clicks) == n and n > 0:
                self.canvas.stop_event_loop()
        _blocking_input.blocking_input_loop(self, ['button_press_event', 'key_press_event'], timeout, handler)
        for mark in marks:
            mark.remove()
        self.canvas.draw()
        return clicks

    def waitforbuttonpress(self, timeout=-1):
        event = None

        def handler(ev):
            nonlocal event
            event = ev
            self.canvas.stop_event_loop()
        _blocking_input.blocking_input_loop(self, ['button_press_event', 'key_press_event'], timeout, handler)
        return None if event is None else event.name == 'key_press_event'

    def tight_layout(self, *, pad=1.08, h_pad=None, w_pad=None, rect=None):
        engine = TightLayoutEngine(pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
        try:
            previous_engine = self.get_layout_engine()
            self.set_layout_engine(engine)
            engine.execute(self)
            if previous_engine is not None and (not isinstance(previous_engine, (TightLayoutEngine, PlaceHolderLayoutEngine))):
                _api.warn_external('The figure layout has changed to tight')
        finally:
            self.set_layout_engine('none')

def figaspect(arg):
    isarray = hasattr(arg, 'shape') and (not np.isscalar(arg))
    figsize_min = np.array((4.0, 2.0))
    figsize_max = np.array((16.0, 16.0))
    if isarray:
        (nr, nc) = arg.shape[:2]
        arr_ratio = nr / nc
    else:
        arr_ratio = arg
    fig_height = mpl.rcParams['figure.figsize'][1]
    newsize = np.array((fig_height / arr_ratio, fig_height))
    newsize /= min(1.0, *newsize / figsize_min)
    newsize /= max(1.0, *newsize / figsize_max)
    newsize = np.clip(newsize, figsize_min, figsize_max)
    return newsize

# File: matplotlib-main/lib/matplotlib/font_manager.py
""""""
from __future__ import annotations
from base64 import b64encode
from collections import namedtuple
import copy
import dataclasses
from functools import lru_cache
from io import BytesIO
import json
import logging
from numbers import Number
import os
from pathlib import Path
import plistlib
import re
import subprocess
import sys
import threading
import matplotlib as mpl
from matplotlib import _api, _afm, cbook, ft2font
from matplotlib._fontconfig_pattern import parse_fontconfig_pattern, generate_fontconfig_pattern
from matplotlib.rcsetup import _validators
_log = logging.getLogger(__name__)
font_scalings = {'xx-small': 0.579, 'x-small': 0.694, 'small': 0.833, 'medium': 1.0, 'large': 1.2, 'x-large': 1.44, 'xx-large': 1.728, 'larger': 1.2, 'smaller': 0.833, None: 1.0}
stretch_dict = {'ultra-condensed': 100, 'extra-condensed': 200, 'condensed': 300, 'semi-condensed': 400, 'normal': 500, 'semi-expanded': 600, 'semi-extended': 600, 'expanded': 700, 'extended': 700, 'extra-expanded': 800, 'extra-extended': 800, 'ultra-expanded': 900, 'ultra-extended': 900}
weight_dict = {'ultralight': 100, 'light': 200, 'normal': 400, 'regular': 400, 'book': 400, 'medium': 500, 'roman': 500, 'semibold': 600, 'demibold': 600, 'demi': 600, 'bold': 700, 'heavy': 800, 'extra bold': 800, 'black': 900}
_weight_regexes = [('thin', 100), ('extralight', 200), ('ultralight', 200), ('demilight', 350), ('semilight', 350), ('light', 300), ('book', 380), ('regular', 400), ('normal', 400), ('medium', 500), ('demibold', 600), ('demi', 600), ('semibold', 600), ('extrabold', 800), ('superbold', 800), ('ultrabold', 800), ('bold', 700), ('ultrablack', 1000), ('superblack', 1000), ('extrablack', 1000), ('\\bultra', 1000), ('black', 900), ('heavy', 900)]
font_family_aliases = {'serif', 'sans-serif', 'sans serif', 'cursive', 'fantasy', 'monospace', 'sans'}
_ExceptionProxy = namedtuple('_ExceptionProxy', ['klass', 'message'])
try:
    _HOME = Path.home()
except Exception:
    _HOME = Path(os.devnull)
MSFolders = 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'
MSFontDirectories = ['SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts', 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts']
MSUserFontDirectories = [str(_HOME / 'AppData/Local/Microsoft/Windows/Fonts'), str(_HOME / 'AppData/Roaming/Microsoft/Windows/Fonts')]
X11FontDirectories = ['/usr/X11R6/lib/X11/fonts/TTF/', '/usr/X11/lib/X11/fonts', '/usr/share/fonts/', '/usr/local/share/fonts/', '/usr/lib/openoffice/share/fonts/truetype/', str(Path(os.environ.get('XDG_DATA_HOME') or _HOME / '.local/share') / 'fonts'), str(_HOME / '.fonts')]
OSXFontDirectories = ['/Library/Fonts/', '/Network/Library/Fonts/', '/System/Library/Fonts/', '/opt/local/share/fonts', str(_HOME / 'Library/Fonts')]

def get_fontext_synonyms(fontext):
    return {'afm': ['afm'], 'otf': ['otf', 'ttc', 'ttf'], 'ttc': ['otf', 'ttc', 'ttf'], 'ttf': ['otf', 'ttc', 'ttf']}[fontext]

def list_fonts(directory, extensions):
    extensions = ['.' + ext for ext in extensions]
    return [os.path.join(dirpath, filename) for (dirpath, _, filenames) in os.walk(directory) for filename in filenames if Path(filename).suffix.lower() in extensions]

def win32FontDirectory():
    import winreg
    try:
        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, MSFolders) as user:
            return winreg.QueryValueEx(user, 'Fonts')[0]
    except OSError:
        return os.path.join(os.environ['WINDIR'], 'Fonts')

def _get_win32_installed_fonts():
    import winreg
    items = set()
    for (domain, base_dirs) in [(winreg.HKEY_LOCAL_MACHINE, [win32FontDirectory()]), (winreg.HKEY_CURRENT_USER, MSUserFontDirectories)]:
        for base_dir in base_dirs:
            for reg_path in MSFontDirectories:
                try:
                    with winreg.OpenKey(domain, reg_path) as local:
                        for j in range(winreg.QueryInfoKey(local)[1]):
                            (key, value, tp) = winreg.EnumValue(local, j)
                            if not isinstance(value, str):
                                continue
                            try:
                                path = Path(base_dir, value).resolve()
                            except RuntimeError:
                                continue
                            items.add(path)
                except (OSError, MemoryError):
                    continue
    return items

@lru_cache
def _get_fontconfig_fonts():
    try:
        if b'--format' not in subprocess.check_output(['fc-list', '--help']):
            _log.warning('Matplotlib needs fontconfig>=2.7 to query system fonts.')
            return []
        out = subprocess.check_output(['fc-list', '--format=%{file}\\n'])
    except (OSError, subprocess.CalledProcessError):
        return []
    return [Path(os.fsdecode(fname)) for fname in out.split(b'\n')]

@lru_cache
def _get_macos_fonts():
    try:
        (d,) = plistlib.loads(subprocess.check_output(['system_profiler', '-xml', 'SPFontsDataType']))
    except (OSError, subprocess.CalledProcessError, plistlib.InvalidFileException):
        return []
    return [Path(entry['path']) for entry in d['_items']]

def findSystemFonts(fontpaths=None, fontext='ttf'):
    fontfiles = set()
    fontexts = get_fontext_synonyms(fontext)
    if fontpaths is None:
        if sys.platform == 'win32':
            installed_fonts = _get_win32_installed_fonts()
            fontpaths = []
        else:
            installed_fonts = _get_fontconfig_fonts()
            if sys.platform == 'darwin':
                installed_fonts += _get_macos_fonts()
                fontpaths = [*X11FontDirectories, *OSXFontDirectories]
            else:
                fontpaths = X11FontDirectories
        fontfiles.update((str(path) for path in installed_fonts if path.suffix.lower()[1:] in fontexts))
    elif isinstance(fontpaths, str):
        fontpaths = [fontpaths]
    for path in fontpaths:
        fontfiles.update(map(os.path.abspath, list_fonts(path, fontexts)))
    return [fname for fname in fontfiles if os.path.exists(fname)]

@dataclasses.dataclass(frozen=True)
class FontEntry:
    fname: str = ''
    name: str = ''
    style: str = 'normal'
    variant: str = 'normal'
    weight: str | int = 'normal'
    stretch: str = 'normal'
    size: str = 'medium'

    def _repr_html_(self) -> str:
        png_stream = self._repr_png_()
        png_b64 = b64encode(png_stream).decode()
        return f'<img src="data:image/png;base64, {png_b64}" />'

    def _repr_png_(self) -> bytes:
        from matplotlib.figure import Figure
        fig = Figure()
        font_path = Path(self.fname) if self.fname != '' else None
        fig.text(0, 0, self.name, font=font_path)
        with BytesIO() as buf:
            fig.savefig(buf, bbox_inches='tight', transparent=True)
            return buf.getvalue()

def ttfFontProperty(font):
    name = font.family_name
    sfnt = font.get_sfnt()
    mac_key = (1, 0, 0)
    ms_key = (3, 1, 1033)
    sfnt2 = sfnt.get((*mac_key, 2), b'').decode('latin-1').lower() or sfnt.get((*ms_key, 2), b'').decode('utf_16_be').lower()
    sfnt4 = sfnt.get((*mac_key, 4), b'').decode('latin-1').lower() or sfnt.get((*ms_key, 4), b'').decode('utf_16_be').lower()
    if sfnt4.find('oblique') >= 0:
        style = 'oblique'
    elif sfnt4.find('italic') >= 0:
        style = 'italic'
    elif sfnt2.find('regular') >= 0:
        style = 'normal'
    elif font.style_flags & ft2font.ITALIC:
        style = 'italic'
    else:
        style = 'normal'
    if name.lower() in ['capitals', 'small-caps']:
        variant = 'small-caps'
    else:
        variant = 'normal'
    wws_subfamily = 22
    typographic_subfamily = 16
    font_subfamily = 2
    styles = [sfnt.get((*mac_key, wws_subfamily), b'').decode('latin-1'), sfnt.get((*mac_key, typographic_subfamily), b'').decode('latin-1'), sfnt.get((*mac_key, font_subfamily), b'').decode('latin-1'), sfnt.get((*ms_key, wws_subfamily), b'').decode('utf-16-be'), sfnt.get((*ms_key, typographic_subfamily), b'').decode('utf-16-be'), sfnt.get((*ms_key, font_subfamily), b'').decode('utf-16-be')]
    styles = [*filter(None, styles)] or [font.style_name]

    def get_weight():
        os2 = font.get_sfnt_table('OS/2')
        if os2 and os2['version'] != 65535:
            return os2['usWeightClass']
        try:
            ps_font_info_weight = font.get_ps_font_info()['weight'].replace(' ', '') or ''
        except ValueError:
            pass
        else:
            for (regex, weight) in _weight_regexes:
                if re.fullmatch(regex, ps_font_info_weight, re.I):
                    return weight
        for style in styles:
            style = style.replace(' ', '')
            for (regex, weight) in _weight_regexes:
                if re.search(regex, style, re.I):
                    return weight
        if font.style_flags & ft2font.BOLD:
            return 700
        return 500
    weight = int(get_weight())
    if any((word in sfnt4 for word in ['narrow', 'condensed', 'cond'])):
        stretch = 'condensed'
    elif 'demi cond' in sfnt4:
        stretch = 'semi-condensed'
    elif any((word in sfnt4 for word in ['wide', 'expanded', 'extended'])):
        stretch = 'expanded'
    else:
        stretch = 'normal'
    if not font.scalable:
        raise NotImplementedError('Non-scalable fonts are not supported')
    size = 'scalable'
    return FontEntry(font.fname, name, style, variant, weight, stretch, size)

def afmFontProperty(fontpath, font):
    name = font.get_familyname()
    fontname = font.get_fontname().lower()
    if font.get_angle() != 0 or 'italic' in name.lower():
        style = 'italic'
    elif 'oblique' in name.lower():
        style = 'oblique'
    else:
        style = 'normal'
    if name.lower() in ['capitals', 'small-caps']:
        variant = 'small-caps'
    else:
        variant = 'normal'
    weight = font.get_weight().lower()
    if weight not in weight_dict:
        weight = 'normal'
    if 'demi cond' in fontname:
        stretch = 'semi-condensed'
    elif any((word in fontname for word in ['narrow', 'cond'])):
        stretch = 'condensed'
    elif any((word in fontname for word in ['wide', 'expanded', 'extended'])):
        stretch = 'expanded'
    else:
        stretch = 'normal'
    size = 'scalable'
    return FontEntry(fontpath, name, style, variant, weight, stretch, size)

class FontProperties:

    def __init__(self, family=None, style=None, variant=None, weight=None, stretch=None, size=None, fname=None, math_fontfamily=None):
        self.set_family(family)
        self.set_style(style)
        self.set_variant(variant)
        self.set_weight(weight)
        self.set_stretch(stretch)
        self.set_file(fname)
        self.set_size(size)
        self.set_math_fontfamily(math_fontfamily)
        if isinstance(family, str) and style is None and (variant is None) and (weight is None) and (stretch is None) and (size is None) and (fname is None):
            self.set_fontconfig_pattern(family)

    @classmethod
    def _from_any(cls, arg):
        if arg is None:
            return cls()
        elif isinstance(arg, cls):
            return arg
        elif isinstance(arg, os.PathLike):
            return cls(fname=arg)
        elif isinstance(arg, str):
            return cls(arg)
        else:
            return cls(**arg)

    def __hash__(self):
        l = (tuple(self.get_family()), self.get_slant(), self.get_variant(), self.get_weight(), self.get_stretch(), self.get_size(), self.get_file(), self.get_math_fontfamily())
        return hash(l)

    def __eq__(self, other):
        return hash(self) == hash(other)

    def __str__(self):
        return self.get_fontconfig_pattern()

    def get_family(self):
        return self._family

    def get_name(self):
        return get_font(findfont(self)).family_name

    def get_style(self):
        return self._slant

    def get_variant(self):
        return self._variant

    def get_weight(self):
        return self._weight

    def get_stretch(self):
        return self._stretch

    def get_size(self):
        return self._size

    def get_file(self):
        return self._file

    def get_fontconfig_pattern(self):
        return generate_fontconfig_pattern(self)

    def set_family(self, family):
        if family is None:
            family = mpl.rcParams['font.family']
        if isinstance(family, str):
            family = [family]
        self._family = family

    def set_style(self, style):
        if style is None:
            style = mpl.rcParams['font.style']
        _api.check_in_list(['normal', 'italic', 'oblique'], style=style)
        self._slant = style

    def set_variant(self, variant):
        if variant is None:
            variant = mpl.rcParams['font.variant']
        _api.check_in_list(['normal', 'small-caps'], variant=variant)
        self._variant = variant

    def set_weight(self, weight):
        if weight is None:
            weight = mpl.rcParams['font.weight']
        if weight in weight_dict:
            self._weight = weight
            return
        try:
            weight = int(weight)
        except ValueError:
            pass
        else:
            if 0 <= weight <= 1000:
                self._weight = weight
                return
        raise ValueError(f'weight={weight!r} is invalid')

    def set_stretch(self, stretch):
        if stretch is None:
            stretch = mpl.rcParams['font.stretch']
        if stretch in stretch_dict:
            self._stretch = stretch
            return
        try:
            stretch = int(stretch)
        except ValueError:
            pass
        else:
            if 0 <= stretch <= 1000:
                self._stretch = stretch
                return
        raise ValueError(f'stretch={stretch!r} is invalid')

    def set_size(self, size):
        if size is None:
            size = mpl.rcParams['font.size']
        try:
            size = float(size)
        except ValueError:
            try:
                scale = font_scalings[size]
            except KeyError as err:
                raise ValueError('Size is invalid. Valid font size are ' + ', '.join(map(str, font_scalings))) from err
            else:
                size = scale * FontManager.get_default_size()
        if size < 1.0:
            _log.info('Fontsize %1.2f < 1.0 pt not allowed by FreeType. Setting fontsize = 1 pt', size)
            size = 1.0
        self._size = size

    def set_file(self, file):
        self._file = os.fspath(file) if file is not None else None

    def set_fontconfig_pattern(self, pattern):
        for (key, val) in parse_fontconfig_pattern(pattern).items():
            if type(val) is list:
                getattr(self, 'set_' + key)(val[0])
            else:
                getattr(self, 'set_' + key)(val)

    def get_math_fontfamily(self):
        return self._math_fontfamily

    def set_math_fontfamily(self, fontfamily):
        if fontfamily is None:
            fontfamily = mpl.rcParams['mathtext.fontset']
        else:
            valid_fonts = _validators['mathtext.fontset'].valid.values()
            _api.check_in_list(valid_fonts, math_fontfamily=fontfamily)
        self._math_fontfamily = fontfamily

    def copy(self):
        return copy.copy(self)
    set_name = set_family
    get_slant = get_style
    set_slant = set_style
    get_size_in_points = get_size

class _JSONEncoder(json.JSONEncoder):

    def default(self, o):
        if isinstance(o, FontManager):
            return dict(o.__dict__, __class__='FontManager')
        elif isinstance(o, FontEntry):
            d = dict(o.__dict__, __class__='FontEntry')
            try:
                d['fname'] = str(Path(d['fname']).relative_to(mpl.get_data_path()))
            except ValueError:
                pass
            return d
        else:
            return super().default(o)

def _json_decode(o):
    cls = o.pop('__class__', None)
    if cls is None:
        return o
    elif cls == 'FontManager':
        r = FontManager.__new__(FontManager)
        r.__dict__.update(o)
        return r
    elif cls == 'FontEntry':
        if not os.path.isabs(o['fname']):
            o['fname'] = os.path.join(mpl.get_data_path(), o['fname'])
        r = FontEntry(**o)
        return r
    else:
        raise ValueError("Don't know how to deserialize __class__=%s" % cls)

def json_dump(data, filename):
    try:
        with cbook._lock_path(filename), open(filename, 'w') as fh:
            json.dump(data, fh, cls=_JSONEncoder, indent=2)
    except OSError as e:
        _log.warning('Could not save font_manager cache %s', e)

def json_load(filename):
    with open(filename) as fh:
        return json.load(fh, object_hook=_json_decode)

class FontManager:
    __version__ = 390

    def __init__(self, size=None, weight='normal'):
        self._version = self.__version__
        self.__default_weight = weight
        self.default_size = size
        paths = [cbook._get_data_path('fonts', subdir) for subdir in ['ttf', 'afm', 'pdfcorefonts']]
        _log.debug('font search path %s', paths)
        self.defaultFamily = {'ttf': 'DejaVu Sans', 'afm': 'Helvetica'}
        self.afmlist = []
        self.ttflist = []
        timer = threading.Timer(5, lambda : _log.warning('Matplotlib is building the font cache; this may take a moment.'))
        timer.start()
        try:
            for fontext in ['afm', 'ttf']:
                for path in [*findSystemFonts(paths, fontext=fontext), *findSystemFonts(fontext=fontext)]:
                    try:
                        self.addfont(path)
                    except OSError as exc:
                        _log.info('Failed to open font file %s: %s', path, exc)
                    except Exception as exc:
                        _log.info('Failed to extract font properties from %s: %s', path, exc)
        finally:
            timer.cancel()

    def addfont(self, path):
        path = os.fsdecode(path)
        if Path(path).suffix.lower() == '.afm':
            with open(path, 'rb') as fh:
                font = _afm.AFM(fh)
            prop = afmFontProperty(path, font)
            self.afmlist.append(prop)
        else:
            font = ft2font.FT2Font(path)
            prop = ttfFontProperty(font)
            self.ttflist.append(prop)
        self._findfont_cached.cache_clear()

    @property
    def defaultFont(self):
        return {ext: self.findfont(family, fontext=ext) for (ext, family) in self.defaultFamily.items()}

    def get_default_weight(self):
        return self.__default_weight

    @staticmethod
    def get_default_size():
        return mpl.rcParams['font.size']

    def set_default_weight(self, weight):
        self.__default_weight = weight

    @staticmethod
    def _expand_aliases(family):
        if family in ('sans', 'sans serif'):
            family = 'sans-serif'
        return mpl.rcParams['font.' + family]

    def score_family(self, families, family2):
        if not isinstance(families, (list, tuple)):
            families = [families]
        elif len(families) == 0:
            return 1.0
        family2 = family2.lower()
        step = 1 / len(families)
        for (i, family1) in enumerate(families):
            family1 = family1.lower()
            if family1 in font_family_aliases:
                options = [*map(str.lower, self._expand_aliases(family1))]
                if family2 in options:
                    idx = options.index(family2)
                    return (i + idx / len(options)) * step
            elif family1 == family2:
                return i * step
        return 1.0

    def score_style(self, style1, style2):
        if style1 == style2:
            return 0.0
        elif style1 in ('italic', 'oblique') and style2 in ('italic', 'oblique'):
            return 0.1
        return 1.0

    def score_variant(self, variant1, variant2):
        if variant1 == variant2:
            return 0.0
        else:
            return 1.0

    def score_stretch(self, stretch1, stretch2):
        try:
            stretchval1 = int(stretch1)
        except ValueError:
            stretchval1 = stretch_dict.get(stretch1, 500)
        try:
            stretchval2 = int(stretch2)
        except ValueError:
            stretchval2 = stretch_dict.get(stretch2, 500)
        return abs(stretchval1 - stretchval2) / 1000.0

    def score_weight(self, weight1, weight2):
        if cbook._str_equal(weight1, weight2):
            return 0.0
        w1 = weight1 if isinstance(weight1, Number) else weight_dict[weight1]
        w2 = weight2 if isinstance(weight2, Number) else weight_dict[weight2]
        return 0.95 * (abs(w1 - w2) / 1000) + 0.05

    def score_size(self, size1, size2):
        if size2 == 'scalable':
            return 0.0
        try:
            sizeval1 = float(size1)
        except ValueError:
            sizeval1 = self.default_size * font_scalings[size1]
        try:
            sizeval2 = float(size2)
        except ValueError:
            return 1.0
        return abs(sizeval1 - sizeval2) / 72

    def findfont(self, prop, fontext='ttf', directory=None, fallback_to_default=True, rebuild_if_missing=True):
        rc_params = tuple((tuple(mpl.rcParams[key]) for key in ['font.serif', 'font.sans-serif', 'font.cursive', 'font.fantasy', 'font.monospace']))
        ret = self._findfont_cached(prop, fontext, directory, fallback_to_default, rebuild_if_missing, rc_params)
        if isinstance(ret, _ExceptionProxy):
            raise ret.klass(ret.message)
        return ret

    def get_font_names(self):
        return list({font.name for font in self.ttflist})

    def _find_fonts_by_props(self, prop, fontext='ttf', directory=None, fallback_to_default=True, rebuild_if_missing=True):
        prop = FontProperties._from_any(prop)
        fpaths = []
        for family in prop.get_family():
            cprop = prop.copy()
            cprop.set_family(family)
            try:
                fpaths.append(self.findfont(cprop, fontext, directory, fallback_to_default=False, rebuild_if_missing=rebuild_if_missing))
            except ValueError:
                if family in font_family_aliases:
                    _log.warning('findfont: Generic family %r not found because none of the following families were found: %s', family, ', '.join(self._expand_aliases(family)))
                else:
                    _log.warning('findfont: Font family %r not found.', family)
        if not fpaths:
            if fallback_to_default:
                dfamily = self.defaultFamily[fontext]
                cprop = prop.copy()
                cprop.set_family(dfamily)
                fpaths.append(self.findfont(cprop, fontext, directory, fallback_to_default=True, rebuild_if_missing=rebuild_if_missing))
            else:
                raise ValueError('Failed to find any font, and fallback to the default font was disabled')
        return fpaths

    @lru_cache(1024)
    def _findfont_cached(self, prop, fontext, directory, fallback_to_default, rebuild_if_missing, rc_params):
        prop = FontProperties._from_any(prop)
        fname = prop.get_file()
        if fname is not None:
            return fname
        if fontext == 'afm':
            fontlist = self.afmlist
        else:
            fontlist = self.ttflist
        best_score = 1e+64
        best_font = None
        _log.debug('findfont: Matching %s.', prop)
        for font in fontlist:
            if directory is not None and Path(directory) not in Path(font.fname).parents:
                continue
            score = self.score_family(prop.get_family(), font.name) * 10 + self.score_style(prop.get_style(), font.style) + self.score_variant(prop.get_variant(), font.variant) + self.score_weight(prop.get_weight(), font.weight) + self.score_stretch(prop.get_stretch(), font.stretch) + self.score_size(prop.get_size(), font.size)
            _log.debug('findfont: score(%s) = %s', font, score)
            if score < best_score:
                best_score = score
                best_font = font
            if score == 0:
                break
        if best_font is None or best_score >= 10.0:
            if fallback_to_default:
                _log.warning('findfont: Font family %s not found. Falling back to %s.', prop.get_family(), self.defaultFamily[fontext])
                for family in map(str.lower, prop.get_family()):
                    if family in font_family_aliases:
                        _log.warning('findfont: Generic family %r not found because none of the following families were found: %s', family, ', '.join(self._expand_aliases(family)))
                default_prop = prop.copy()
                default_prop.set_family(self.defaultFamily[fontext])
                return self.findfont(default_prop, fontext, directory, fallback_to_default=False)
            else:
                return _ExceptionProxy(ValueError, f'Failed to find font {prop}, and fallback to the default font was disabled')
        else:
            _log.debug('findfont: Matching %s to %s (%r) with score of %f.', prop, best_font.name, best_font.fname, best_score)
            result = best_font.fname
        if not os.path.isfile(result):
            if rebuild_if_missing:
                _log.info('findfont: Found a missing font file.  Rebuilding cache.')
                new_fm = _load_fontmanager(try_read_cache=False)
                vars(self).update(vars(new_fm))
                return self.findfont(prop, fontext, directory, rebuild_if_missing=False)
            else:
                return _ExceptionProxy(ValueError, 'No valid font could be found')
        return _cached_realpath(result)

@lru_cache
def is_opentype_cff_font(filename):
    if os.path.splitext(filename)[1].lower() == '.otf':
        with open(filename, 'rb') as fd:
            return fd.read(4) == b'OTTO'
    else:
        return False

@lru_cache(64)
def _get_font(font_filepaths, hinting_factor, *, _kerning_factor, thread_id):
    (first_fontpath, *rest) = font_filepaths
    return ft2font.FT2Font(first_fontpath, hinting_factor, _fallback_list=[ft2font.FT2Font(fpath, hinting_factor, _kerning_factor=_kerning_factor) for fpath in rest], _kerning_factor=_kerning_factor)
if hasattr(os, 'register_at_fork'):
    os.register_at_fork(after_in_child=_get_font.cache_clear)

@lru_cache(64)
def _cached_realpath(path):
    return os.path.realpath(path)

def get_font(font_filepaths, hinting_factor=None):
    if isinstance(font_filepaths, (str, Path, bytes)):
        paths = (_cached_realpath(font_filepaths),)
    else:
        paths = tuple((_cached_realpath(fname) for fname in font_filepaths))
    if hinting_factor is None:
        hinting_factor = mpl.rcParams['text.hinting_factor']
    return _get_font(paths, hinting_factor, _kerning_factor=mpl.rcParams['text.kerning_factor'], thread_id=threading.get_ident())

def _load_fontmanager(*, try_read_cache=True):
    fm_path = Path(mpl.get_cachedir(), f'fontlist-v{FontManager.__version__}.json')
    if try_read_cache:
        try:
            fm = json_load(fm_path)
        except Exception:
            pass
        else:
            if getattr(fm, '_version', object()) == FontManager.__version__:
                _log.debug('Using fontManager instance from %s', fm_path)
                return fm
    fm = FontManager()
    json_dump(fm, fm_path)
    _log.info('generated new fontManager')
    return fm
fontManager = _load_fontmanager()
findfont = fontManager.findfont
get_font_names = fontManager.get_font_names

# File: matplotlib-main/lib/matplotlib/gridspec.py
""""""
import copy
import logging
from numbers import Integral
import numpy as np
import matplotlib as mpl
from matplotlib import _api, _pylab_helpers, _tight_layout
from matplotlib.transforms import Bbox
_log = logging.getLogger(__name__)

class GridSpecBase:

    def __init__(self, nrows, ncols, height_ratios=None, width_ratios=None):
        if not isinstance(nrows, Integral) or nrows <= 0:
            raise ValueError(f'Number of rows must be a positive integer, not {nrows!r}')
        if not isinstance(ncols, Integral) or ncols <= 0:
            raise ValueError(f'Number of columns must be a positive integer, not {ncols!r}')
        (self._nrows, self._ncols) = (nrows, ncols)
        self.set_height_ratios(height_ratios)
        self.set_width_ratios(width_ratios)

    def __repr__(self):
        height_arg = f', height_ratios={self._row_height_ratios!r}' if len(set(self._row_height_ratios)) != 1 else ''
        width_arg = f', width_ratios={self._col_width_ratios!r}' if len(set(self._col_width_ratios)) != 1 else ''
        return '{clsname}({nrows}, {ncols}{optionals})'.format(clsname=self.__class__.__name__, nrows=self._nrows, ncols=self._ncols, optionals=height_arg + width_arg)
    nrows = property(lambda self: self._nrows, doc='The number of rows in the grid.')
    ncols = property(lambda self: self._ncols, doc='The number of columns in the grid.')

    def get_geometry(self):
        return (self._nrows, self._ncols)

    def get_subplot_params(self, figure=None):
        pass

    def new_subplotspec(self, loc, rowspan=1, colspan=1):
        (loc1, loc2) = loc
        subplotspec = self[loc1:loc1 + rowspan, loc2:loc2 + colspan]
        return subplotspec

    def set_width_ratios(self, width_ratios):
        if width_ratios is None:
            width_ratios = [1] * self._ncols
        elif len(width_ratios) != self._ncols:
            raise ValueError('Expected the given number of width ratios to match the number of columns of the grid')
        self._col_width_ratios = width_ratios

    def get_width_ratios(self):
        return self._col_width_ratios

    def set_height_ratios(self, height_ratios):
        if height_ratios is None:
            height_ratios = [1] * self._nrows
        elif len(height_ratios) != self._nrows:
            raise ValueError('Expected the given number of height ratios to match the number of rows of the grid')
        self._row_height_ratios = height_ratios

    def get_height_ratios(self):
        return self._row_height_ratios

    def get_grid_positions(self, fig):
        (nrows, ncols) = self.get_geometry()
        subplot_params = self.get_subplot_params(fig)
        left = subplot_params.left
        right = subplot_params.right
        bottom = subplot_params.bottom
        top = subplot_params.top
        wspace = subplot_params.wspace
        hspace = subplot_params.hspace
        tot_width = right - left
        tot_height = top - bottom
        cell_h = tot_height / (nrows + hspace * (nrows - 1))
        sep_h = hspace * cell_h
        norm = cell_h * nrows / sum(self._row_height_ratios)
        cell_heights = [r * norm for r in self._row_height_ratios]
        sep_heights = [0] + [sep_h] * (nrows - 1)
        cell_hs = np.cumsum(np.column_stack([sep_heights, cell_heights]).flat)
        cell_w = tot_width / (ncols + wspace * (ncols - 1))
        sep_w = wspace * cell_w
        norm = cell_w * ncols / sum(self._col_width_ratios)
        cell_widths = [r * norm for r in self._col_width_ratios]
        sep_widths = [0] + [sep_w] * (ncols - 1)
        cell_ws = np.cumsum(np.column_stack([sep_widths, cell_widths]).flat)
        (fig_tops, fig_bottoms) = (top - cell_hs).reshape((-1, 2)).T
        (fig_lefts, fig_rights) = (left + cell_ws).reshape((-1, 2)).T
        return (fig_bottoms, fig_tops, fig_lefts, fig_rights)

    @staticmethod
    def _check_gridspec_exists(figure, nrows, ncols):
        for ax in figure.get_axes():
            gs = ax.get_gridspec()
            if gs is not None:
                if hasattr(gs, 'get_topmost_subplotspec'):
                    gs = gs.get_topmost_subplotspec().get_gridspec()
                if gs.get_geometry() == (nrows, ncols):
                    return gs
        return GridSpec(nrows, ncols, figure=figure)

    def __getitem__(self, key):
        (nrows, ncols) = self.get_geometry()

        def _normalize(key, size, axis):
            orig_key = key
            if isinstance(key, slice):
                (start, stop, _) = key.indices(size)
                if stop > start:
                    return (start, stop - 1)
                raise IndexError('GridSpec slice would result in no space allocated for subplot')
            else:
                if key < 0:
                    key = key + size
                if 0 <= key < size:
                    return (key, key)
                elif axis is not None:
                    raise IndexError(f'index {orig_key} is out of bounds for axis {axis} with size {size}')
                else:
                    raise IndexError(f'index {orig_key} is out of bounds for GridSpec with size {size}')
        if isinstance(key, tuple):
            try:
                (k1, k2) = key
            except ValueError as err:
                raise ValueError('Unrecognized subplot spec') from err
            (num1, num2) = np.ravel_multi_index([_normalize(k1, nrows, 0), _normalize(k2, ncols, 1)], (nrows, ncols))
        else:
            (num1, num2) = _normalize(key, nrows * ncols, None)
        return SubplotSpec(self, num1, num2)

    def subplots(self, *, sharex=False, sharey=False, squeeze=True, subplot_kw=None):
        figure = self.figure
        if figure is None:
            raise ValueError('GridSpec.subplots() only works for GridSpecs created with a parent figure')
        if not isinstance(sharex, str):
            sharex = 'all' if sharex else 'none'
        if not isinstance(sharey, str):
            sharey = 'all' if sharey else 'none'
        _api.check_in_list(['all', 'row', 'col', 'none', False, True], sharex=sharex, sharey=sharey)
        if subplot_kw is None:
            subplot_kw = {}
        subplot_kw = subplot_kw.copy()
        axarr = np.empty((self._nrows, self._ncols), dtype=object)
        for row in range(self._nrows):
            for col in range(self._ncols):
                shared_with = {'none': None, 'all': axarr[0, 0], 'row': axarr[row, 0], 'col': axarr[0, col]}
                subplot_kw['sharex'] = shared_with[sharex]
                subplot_kw['sharey'] = shared_with[sharey]
                axarr[row, col] = figure.add_subplot(self[row, col], **subplot_kw)
        if sharex in ['col', 'all']:
            for ax in axarr.flat:
                ax._label_outer_xaxis(skip_non_rectangular_axes=True)
        if sharey in ['row', 'all']:
            for ax in axarr.flat:
                ax._label_outer_yaxis(skip_non_rectangular_axes=True)
        if squeeze:
            return axarr.item() if axarr.size == 1 else axarr.squeeze()
        else:
            return axarr

class GridSpec(GridSpecBase):

    def __init__(self, nrows, ncols, figure=None, left=None, bottom=None, right=None, top=None, wspace=None, hspace=None, width_ratios=None, height_ratios=None):
        self.left = left
        self.bottom = bottom
        self.right = right
        self.top = top
        self.wspace = wspace
        self.hspace = hspace
        self.figure = figure
        super().__init__(nrows, ncols, width_ratios=width_ratios, height_ratios=height_ratios)
    _AllowedKeys = ['left', 'bottom', 'right', 'top', 'wspace', 'hspace']

    def update(self, **kwargs):
        for (k, v) in kwargs.items():
            if k in self._AllowedKeys:
                setattr(self, k, v)
            else:
                raise AttributeError(f'{k} is an unknown keyword')
        for figmanager in _pylab_helpers.Gcf.figs.values():
            for ax in figmanager.canvas.figure.axes:
                if ax.get_subplotspec() is not None:
                    ss = ax.get_subplotspec().get_topmost_subplotspec()
                    if ss.get_gridspec() == self:
                        fig = ax.get_figure(root=False)
                        ax._set_position(ax.get_subplotspec().get_position(fig))

    def get_subplot_params(self, figure=None):
        if figure is None:
            kw = {k: mpl.rcParams['figure.subplot.' + k] for k in self._AllowedKeys}
            subplotpars = SubplotParams(**kw)
        else:
            subplotpars = copy.copy(figure.subplotpars)
        subplotpars.update(**{k: getattr(self, k) for k in self._AllowedKeys})
        return subplotpars

    def locally_modified_subplot_params(self):
        return [k for k in self._AllowedKeys if getattr(self, k)]

    def tight_layout(self, figure, renderer=None, pad=1.08, h_pad=None, w_pad=None, rect=None):
        if renderer is None:
            renderer = figure._get_renderer()
        kwargs = _tight_layout.get_tight_layout_figure(figure, figure.axes, _tight_layout.get_subplotspec_list(figure.axes, grid_spec=self), renderer, pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
        if kwargs:
            self.update(**kwargs)

class GridSpecFromSubplotSpec(GridSpecBase):

    def __init__(self, nrows, ncols, subplot_spec, wspace=None, hspace=None, height_ratios=None, width_ratios=None):
        self._wspace = wspace
        self._hspace = hspace
        if isinstance(subplot_spec, SubplotSpec):
            self._subplot_spec = subplot_spec
        else:
            raise TypeError('subplot_spec must be type SubplotSpec, usually from GridSpec, or axes.get_subplotspec.')
        self.figure = self._subplot_spec.get_gridspec().figure
        super().__init__(nrows, ncols, width_ratios=width_ratios, height_ratios=height_ratios)

    def get_subplot_params(self, figure=None):
        hspace = self._hspace if self._hspace is not None else figure.subplotpars.hspace if figure is not None else mpl.rcParams['figure.subplot.hspace']
        wspace = self._wspace if self._wspace is not None else figure.subplotpars.wspace if figure is not None else mpl.rcParams['figure.subplot.wspace']
        figbox = self._subplot_spec.get_position(figure)
        (left, bottom, right, top) = figbox.extents
        return SubplotParams(left=left, right=right, bottom=bottom, top=top, wspace=wspace, hspace=hspace)

    def get_topmost_subplotspec(self):
        return self._subplot_spec.get_topmost_subplotspec()

class SubplotSpec:

    def __init__(self, gridspec, num1, num2=None):
        self._gridspec = gridspec
        self.num1 = num1
        self.num2 = num2

    def __repr__(self):
        return f'{self.get_gridspec()}[{self.rowspan.start}:{self.rowspan.stop}, {self.colspan.start}:{self.colspan.stop}]'

    @staticmethod
    def _from_subplot_args(figure, args):
        if len(args) == 1:
            (arg,) = args
            if isinstance(arg, SubplotSpec):
                return arg
            elif not isinstance(arg, Integral):
                raise ValueError(f'Single argument to subplot must be a three-digit integer, not {arg!r}')
            try:
                (rows, cols, num) = map(int, str(arg))
            except ValueError:
                raise ValueError(f'Single argument to subplot must be a three-digit integer, not {arg!r}') from None
        elif len(args) == 3:
            (rows, cols, num) = args
        else:
            raise _api.nargs_error('subplot', takes='1 or 3', given=len(args))
        gs = GridSpec._check_gridspec_exists(figure, rows, cols)
        if gs is None:
            gs = GridSpec(rows, cols, figure=figure)
        if isinstance(num, tuple) and len(num) == 2:
            if not all((isinstance(n, Integral) for n in num)):
                raise ValueError(f'Subplot specifier tuple must contain integers, not {num}')
            (i, j) = num
        else:
            if not isinstance(num, Integral) or num < 1 or num > rows * cols:
                raise ValueError(f'num must be an integer with 1 <= num <= {rows * cols}, not {num!r}')
            i = j = num
        return gs[i - 1:j]

    @property
    def num2(self):
        return self.num1 if self._num2 is None else self._num2

    @num2.setter
    def num2(self, value):
        self._num2 = value

    def get_gridspec(self):
        return self._gridspec

    def get_geometry(self):
        (rows, cols) = self.get_gridspec().get_geometry()
        return (rows, cols, self.num1, self.num2)

    @property
    def rowspan(self):
        ncols = self.get_gridspec().ncols
        return range(self.num1 // ncols, self.num2 // ncols + 1)

    @property
    def colspan(self):
        ncols = self.get_gridspec().ncols
        (c1, c2) = sorted([self.num1 % ncols, self.num2 % ncols])
        return range(c1, c2 + 1)

    def is_first_row(self):
        return self.rowspan.start == 0

    def is_last_row(self):
        return self.rowspan.stop == self.get_gridspec().nrows

    def is_first_col(self):
        return self.colspan.start == 0

    def is_last_col(self):
        return self.colspan.stop == self.get_gridspec().ncols

    def get_position(self, figure):
        gridspec = self.get_gridspec()
        (nrows, ncols) = gridspec.get_geometry()
        (rows, cols) = np.unravel_index([self.num1, self.num2], (nrows, ncols))
        (fig_bottoms, fig_tops, fig_lefts, fig_rights) = gridspec.get_grid_positions(figure)
        fig_bottom = fig_bottoms[rows].min()
        fig_top = fig_tops[rows].max()
        fig_left = fig_lefts[cols].min()
        fig_right = fig_rights[cols].max()
        return Bbox.from_extents(fig_left, fig_bottom, fig_right, fig_top)

    def get_topmost_subplotspec(self):
        gridspec = self.get_gridspec()
        if hasattr(gridspec, 'get_topmost_subplotspec'):
            return gridspec.get_topmost_subplotspec()
        else:
            return self

    def __eq__(self, other):
        return (self._gridspec, self.num1, self.num2) == (getattr(other, '_gridspec', object()), getattr(other, 'num1', object()), getattr(other, 'num2', object()))

    def __hash__(self):
        return hash((self._gridspec, self.num1, self.num2))

    def subgridspec(self, nrows, ncols, **kwargs):
        return GridSpecFromSubplotSpec(nrows, ncols, self, **kwargs)

class SubplotParams:

    def __init__(self, left=None, bottom=None, right=None, top=None, wspace=None, hspace=None):
        for key in ['left', 'bottom', 'right', 'top', 'wspace', 'hspace']:
            setattr(self, key, mpl.rcParams[f'figure.subplot.{key}'])
        self.update(left, bottom, right, top, wspace, hspace)

    def update(self, left=None, bottom=None, right=None, top=None, wspace=None, hspace=None):
        if (left if left is not None else self.left) >= (right if right is not None else self.right):
            raise ValueError('left cannot be >= right')
        if (bottom if bottom is not None else self.bottom) >= (top if top is not None else self.top):
            raise ValueError('bottom cannot be >= top')
        if left is not None:
            self.left = left
        if right is not None:
            self.right = right
        if bottom is not None:
            self.bottom = bottom
        if top is not None:
            self.top = top
        if wspace is not None:
            self.wspace = wspace
        if hspace is not None:
            self.hspace = hspace

# File: matplotlib-main/lib/matplotlib/hatch.py
""""""
import numpy as np
from matplotlib import _api
from matplotlib.path import Path

class HatchPatternBase:
    pass

class HorizontalHatch(HatchPatternBase):

    def __init__(self, hatch, density):
        self.num_lines = int((hatch.count('-') + hatch.count('+')) * density)
        self.num_vertices = self.num_lines * 2

    def set_vertices_and_codes(self, vertices, codes):
        (steps, stepsize) = np.linspace(0.0, 1.0, self.num_lines, False, retstep=True)
        steps += stepsize / 2.0
        vertices[0::2, 0] = 0.0
        vertices[0::2, 1] = steps
        vertices[1::2, 0] = 1.0
        vertices[1::2, 1] = steps
        codes[0::2] = Path.MOVETO
        codes[1::2] = Path.LINETO

class VerticalHatch(HatchPatternBase):

    def __init__(self, hatch, density):
        self.num_lines = int((hatch.count('|') + hatch.count('+')) * density)
        self.num_vertices = self.num_lines * 2

    def set_vertices_and_codes(self, vertices, codes):
        (steps, stepsize) = np.linspace(0.0, 1.0, self.num_lines, False, retstep=True)
        steps += stepsize / 2.0
        vertices[0::2, 0] = steps
        vertices[0::2, 1] = 0.0
        vertices[1::2, 0] = steps
        vertices[1::2, 1] = 1.0
        codes[0::2] = Path.MOVETO
        codes[1::2] = Path.LINETO

class NorthEastHatch(HatchPatternBase):

    def __init__(self, hatch, density):
        self.num_lines = int((hatch.count('/') + hatch.count('x') + hatch.count('X')) * density)
        if self.num_lines:
            self.num_vertices = (self.num_lines + 1) * 2
        else:
            self.num_vertices = 0

    def set_vertices_and_codes(self, vertices, codes):
        steps = np.linspace(-0.5, 0.5, self.num_lines + 1)
        vertices[0::2, 0] = 0.0 + steps
        vertices[0::2, 1] = 0.0 - steps
        vertices[1::2, 0] = 1.0 + steps
        vertices[1::2, 1] = 1.0 - steps
        codes[0::2] = Path.MOVETO
        codes[1::2] = Path.LINETO

class SouthEastHatch(HatchPatternBase):

    def __init__(self, hatch, density):
        self.num_lines = int((hatch.count('\\') + hatch.count('x') + hatch.count('X')) * density)
        if self.num_lines:
            self.num_vertices = (self.num_lines + 1) * 2
        else:
            self.num_vertices = 0

    def set_vertices_and_codes(self, vertices, codes):
        steps = np.linspace(-0.5, 0.5, self.num_lines + 1)
        vertices[0::2, 0] = 0.0 + steps
        vertices[0::2, 1] = 1.0 + steps
        vertices[1::2, 0] = 1.0 + steps
        vertices[1::2, 1] = 0.0 + steps
        codes[0::2] = Path.MOVETO
        codes[1::2] = Path.LINETO

class Shapes(HatchPatternBase):
    filled = False

    def __init__(self, hatch, density):
        if self.num_rows == 0:
            self.num_shapes = 0
            self.num_vertices = 0
        else:
            self.num_shapes = (self.num_rows // 2 + 1) * (self.num_rows + 1) + self.num_rows // 2 * self.num_rows
            self.num_vertices = self.num_shapes * len(self.shape_vertices) * (1 if self.filled else 2)

    def set_vertices_and_codes(self, vertices, codes):
        offset = 1.0 / self.num_rows
        shape_vertices = self.shape_vertices * offset * self.size
        shape_codes = self.shape_codes
        if not self.filled:
            shape_vertices = np.concatenate([shape_vertices, shape_vertices[::-1] * 0.9])
            shape_codes = np.concatenate([shape_codes, shape_codes])
        vertices_parts = []
        codes_parts = []
        for row in range(self.num_rows + 1):
            if row % 2 == 0:
                cols = np.linspace(0, 1, self.num_rows + 1)
            else:
                cols = np.linspace(offset / 2, 1 - offset / 2, self.num_rows)
            row_pos = row * offset
            for col_pos in cols:
                vertices_parts.append(shape_vertices + [col_pos, row_pos])
                codes_parts.append(shape_codes)
        np.concatenate(vertices_parts, out=vertices)
        np.concatenate(codes_parts, out=codes)

class Circles(Shapes):

    def __init__(self, hatch, density):
        path = Path.unit_circle()
        self.shape_vertices = path.vertices
        self.shape_codes = path.codes
        super().__init__(hatch, density)

class SmallCircles(Circles):
    size = 0.2

    def __init__(self, hatch, density):
        self.num_rows = hatch.count('o') * density
        super().__init__(hatch, density)

class LargeCircles(Circles):
    size = 0.35

    def __init__(self, hatch, density):
        self.num_rows = hatch.count('O') * density
        super().__init__(hatch, density)

class SmallFilledCircles(Circles):
    size = 0.1
    filled = True

    def __init__(self, hatch, density):
        self.num_rows = hatch.count('.') * density
        super().__init__(hatch, density)

class Stars(Shapes):
    size = 1.0 / 3.0
    filled = True

    def __init__(self, hatch, density):
        self.num_rows = hatch.count('*') * density
        path = Path.unit_regular_star(5)
        self.shape_vertices = path.vertices
        self.shape_codes = np.full(len(self.shape_vertices), Path.LINETO, dtype=Path.code_type)
        self.shape_codes[0] = Path.MOVETO
        super().__init__(hatch, density)
_hatch_types = [HorizontalHatch, VerticalHatch, NorthEastHatch, SouthEastHatch, SmallCircles, LargeCircles, SmallFilledCircles, Stars]

def _validate_hatch_pattern(hatch):
    valid_hatch_patterns = set('-+|/\\xXoO.*')
    if hatch is not None:
        invalids = set(hatch).difference(valid_hatch_patterns)
        if invalids:
            valid = ''.join(sorted(valid_hatch_patterns))
            invalids = ''.join(sorted(invalids))
            _api.warn_deprecated('3.4', removal='3.11', message=f'hatch must consist of a string of "{valid}" or None, but found the following invalid values "{invalids}". Passing invalid values is deprecated since %(since)s and will become an error %(removal)s.')

def get_path(hatchpattern, density=6):
    density = int(density)
    patterns = [hatch_type(hatchpattern, density) for hatch_type in _hatch_types]
    num_vertices = sum([pattern.num_vertices for pattern in patterns])
    if num_vertices == 0:
        return Path(np.empty((0, 2)))
    vertices = np.empty((num_vertices, 2))
    codes = np.empty(num_vertices, Path.code_type)
    cursor = 0
    for pattern in patterns:
        if pattern.num_vertices != 0:
            vertices_chunk = vertices[cursor:cursor + pattern.num_vertices]
            codes_chunk = codes[cursor:cursor + pattern.num_vertices]
            pattern.set_vertices_and_codes(vertices_chunk, codes_chunk)
            cursor += pattern.num_vertices
    return Path(vertices, codes)

# File: matplotlib-main/lib/matplotlib/image.py
""""""
import math
import os
import logging
from pathlib import Path
import warnings
import numpy as np
import PIL.Image
import PIL.PngImagePlugin
import matplotlib as mpl
from matplotlib import _api, cbook, cm
from matplotlib import _image
from matplotlib._image import *
import matplotlib.artist as martist
from matplotlib.backend_bases import FigureCanvasBase
import matplotlib.colors as mcolors
from matplotlib.transforms import Affine2D, BboxBase, Bbox, BboxTransform, BboxTransformTo, IdentityTransform, TransformedBbox
_log = logging.getLogger(__name__)
_interpd_ = {'auto': _image.NEAREST, 'none': _image.NEAREST, 'nearest': _image.NEAREST, 'bilinear': _image.BILINEAR, 'bicubic': _image.BICUBIC, 'spline16': _image.SPLINE16, 'spline36': _image.SPLINE36, 'hanning': _image.HANNING, 'hamming': _image.HAMMING, 'hermite': _image.HERMITE, 'kaiser': _image.KAISER, 'quadric': _image.QUADRIC, 'catrom': _image.CATROM, 'gaussian': _image.GAUSSIAN, 'bessel': _image.BESSEL, 'mitchell': _image.MITCHELL, 'sinc': _image.SINC, 'lanczos': _image.LANCZOS, 'blackman': _image.BLACKMAN, 'antialiased': _image.NEAREST}
interpolations_names = set(_interpd_)

def composite_images(images, renderer, magnification=1.0):
    if len(images) == 0:
        return (np.empty((0, 0, 4), dtype=np.uint8), 0, 0)
    parts = []
    bboxes = []
    for image in images:
        (data, x, y, trans) = image.make_image(renderer, magnification)
        if data is not None:
            x *= magnification
            y *= magnification
            parts.append((data, x, y, image._get_scalar_alpha()))
            bboxes.append(Bbox([[x, y], [x + data.shape[1], y + data.shape[0]]]))
    if len(parts) == 0:
        return (np.empty((0, 0, 4), dtype=np.uint8), 0, 0)
    bbox = Bbox.union(bboxes)
    output = np.zeros((int(bbox.height), int(bbox.width), 4), dtype=np.uint8)
    for (data, x, y, alpha) in parts:
        trans = Affine2D().translate(x - bbox.x0, y - bbox.y0)
        _image.resample(data, output, trans, _image.NEAREST, resample=False, alpha=alpha)
    return (output, bbox.x0 / magnification, bbox.y0 / magnification)

def _draw_list_compositing_images(renderer, parent, artists, suppress_composite=None):
    has_images = any((isinstance(x, _ImageBase) for x in artists))
    not_composite = suppress_composite if suppress_composite is not None else renderer.option_image_nocomposite()
    if not_composite or not has_images:
        for a in artists:
            a.draw(renderer)
    else:
        image_group = []
        mag = renderer.get_image_magnification()

        def flush_images():
            if len(image_group) == 1:
                image_group[0].draw(renderer)
            elif len(image_group) > 1:
                (data, l, b) = composite_images(image_group, renderer, mag)
                if data.size != 0:
                    gc = renderer.new_gc()
                    gc.set_clip_rectangle(parent.bbox)
                    gc.set_clip_path(parent.get_clip_path())
                    renderer.draw_image(gc, round(l), round(b), data)
                    gc.restore()
            del image_group[:]
        for a in artists:
            if isinstance(a, _ImageBase) and a.can_composite() and a.get_clip_on() and (not a.get_clip_path()):
                image_group.append(a)
            else:
                flush_images()
                a.draw(renderer)
        flush_images()

def _resample(image_obj, data, out_shape, transform, *, resample=None, alpha=1):
    msg = 'Data with more than {n} cannot be accurately displayed. Downsampling to less than {n} before displaying. To remove this warning, manually downsample your data.'
    if data.shape[1] > 2 ** 23:
        warnings.warn(msg.format(n='2**23 columns'))
        step = int(np.ceil(data.shape[1] / 2 ** 23))
        data = data[:, ::step]
        transform = Affine2D().scale(step, 1) + transform
    if data.shape[0] > 2 ** 24:
        warnings.warn(msg.format(n='2**24 rows'))
        step = int(np.ceil(data.shape[0] / 2 ** 24))
        data = data[::step, :]
        transform = Affine2D().scale(1, step) + transform
    interpolation = image_obj.get_interpolation()
    if interpolation in ['antialiased', 'auto']:
        pos = np.array([[0, 0], [data.shape[1], data.shape[0]]])
        disp = transform.transform(pos)
        dispx = np.abs(np.diff(disp[:, 0]))
        dispy = np.abs(np.diff(disp[:, 1]))
        if (dispx > 3 * data.shape[1] or dispx == data.shape[1] or dispx == 2 * data.shape[1]) and (dispy > 3 * data.shape[0] or dispy == data.shape[0] or dispy == 2 * data.shape[0]):
            interpolation = 'nearest'
        else:
            interpolation = 'hanning'
    out = np.zeros(out_shape + data.shape[2:], data.dtype)
    if resample is None:
        resample = image_obj.get_resample()
    _image.resample(data, out, transform, _interpd_[interpolation], resample, alpha, image_obj.get_filternorm(), image_obj.get_filterrad())
    return out

def _rgb_to_rgba(A):
    rgba = np.zeros((A.shape[0], A.shape[1], 4), dtype=A.dtype)
    rgba[:, :, :3] = A
    if rgba.dtype == np.uint8:
        rgba[:, :, 3] = 255
    else:
        rgba[:, :, 3] = 1.0
    return rgba

class _ImageBase(martist.Artist, cm.ScalarMappable):
    zorder = 0

    def __init__(self, ax, cmap=None, norm=None, interpolation=None, origin=None, filternorm=True, filterrad=4.0, resample=False, *, interpolation_stage=None, **kwargs):
        martist.Artist.__init__(self)
        cm.ScalarMappable.__init__(self, norm, cmap)
        if origin is None:
            origin = mpl.rcParams['image.origin']
        _api.check_in_list(['upper', 'lower'], origin=origin)
        self.origin = origin
        self.set_filternorm(filternorm)
        self.set_filterrad(filterrad)
        self.set_interpolation(interpolation)
        self.set_interpolation_stage(interpolation_stage)
        self.set_resample(resample)
        self.axes = ax
        self._imcache = None
        self._internal_update(kwargs)

    def __str__(self):
        try:
            shape = self.get_shape()
            return f'{type(self).__name__}(shape={shape!r})'
        except RuntimeError:
            return type(self).__name__

    def __getstate__(self):
        return {**super().__getstate__(), '_imcache': None}

    def get_size(self):
        return self.get_shape()[:2]

    def get_shape(self):
        if self._A is None:
            raise RuntimeError('You must first set the image array')
        return self._A.shape

    def set_alpha(self, alpha):
        martist.Artist._set_alpha_for_array(self, alpha)
        if np.ndim(alpha) not in (0, 2):
            raise TypeError('alpha must be a float, two-dimensional array, or None')
        self._imcache = None

    def _get_scalar_alpha(self):
        return 1.0 if self._alpha is None or np.ndim(self._alpha) > 0 else self._alpha

    def changed(self):
        self._imcache = None
        cm.ScalarMappable.changed(self)

    def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0, unsampled=False, round_to_pixel_border=True):
        if A is None:
            raise RuntimeError('You must first set the image array or the image attribute')
        if A.size == 0:
            raise RuntimeError("_make_image must get a non-empty image. Your Artist's draw method must filter before this method is called.")
        clipped_bbox = Bbox.intersection(out_bbox, clip_bbox)
        if clipped_bbox is None:
            return (None, 0, 0, None)
        out_width_base = clipped_bbox.width * magnification
        out_height_base = clipped_bbox.height * magnification
        if out_width_base == 0 or out_height_base == 0:
            return (None, 0, 0, None)
        if self.origin == 'upper':
            t0 = Affine2D().translate(0, -A.shape[0]).scale(1, -1)
        else:
            t0 = IdentityTransform()
        t0 += Affine2D().scale(in_bbox.width / A.shape[1], in_bbox.height / A.shape[0]).translate(in_bbox.x0, in_bbox.y0) + self.get_transform()
        t = t0 + Affine2D().translate(-clipped_bbox.x0, -clipped_bbox.y0).scale(magnification)
        if not unsampled and t.is_affine and round_to_pixel_border and (out_width_base % 1.0 != 0.0 or out_height_base % 1.0 != 0.0):
            out_width = math.ceil(out_width_base)
            out_height = math.ceil(out_height_base)
            extra_width = (out_width - out_width_base) / out_width_base
            extra_height = (out_height - out_height_base) / out_height_base
            t += Affine2D().scale(1.0 + extra_width, 1.0 + extra_height)
        else:
            out_width = int(out_width_base)
            out_height = int(out_height_base)
        out_shape = (out_height, out_width)
        if not unsampled:
            if not (A.ndim == 2 or (A.ndim == 3 and A.shape[-1] in (3, 4))):
                raise ValueError(f'Invalid shape {A.shape} for image data')
            interpolation_stage = self._interpolation_stage
            if interpolation_stage in ['antialiased', 'auto']:
                pos = np.array([[0, 0], [A.shape[1], A.shape[0]]])
                disp = t.transform(pos)
                dispx = np.abs(np.diff(disp[:, 0])) / A.shape[1]
                dispy = np.abs(np.diff(disp[:, 1])) / A.shape[0]
                if dispx < 3 or dispy < 3:
                    interpolation_stage = 'rgba'
                else:
                    interpolation_stage = 'data'
            if A.ndim == 2 and interpolation_stage == 'data':
                if A.dtype.kind == 'f':
                    scaled_dtype = np.dtype('f8' if A.dtype.itemsize > 4 else 'f4')
                    if scaled_dtype.itemsize < A.dtype.itemsize:
                        _api.warn_external(f'Casting input data from {A.dtype} to {scaled_dtype} for imshow.')
                else:
                    da = A.max().astype('f8') - A.min().astype('f8')
                    scaled_dtype = 'f8' if da > 100000000.0 else 'f4'
                A_resampled = _resample(self, A.astype(scaled_dtype), out_shape, t)
                if isinstance(self.norm, mcolors.NoNorm):
                    A_resampled = A_resampled.astype(A.dtype)
                mask = np.where(A.mask, np.float32(np.nan), np.float32(1)) if A.mask.shape == A.shape else np.ones_like(A, np.float32)
                out_alpha = _resample(self, mask, out_shape, t, resample=True)
                del mask
                out_mask = np.isnan(out_alpha)
                out_alpha[out_mask] = 1
                alpha = self.get_alpha()
                if alpha is not None and np.ndim(alpha) > 0:
                    out_alpha *= _resample(self, alpha, out_shape, t, resample=True)
                resampled_masked = np.ma.masked_array(A_resampled, out_mask)
                output = self.norm(resampled_masked)
            else:
                if A.ndim == 2:
                    self.norm.autoscale_None(A)
                    A = self.to_rgba(A)
                alpha = self._get_scalar_alpha()
                if A.shape[2] == 3:
                    output_alpha = 255 * alpha if A.dtype == np.uint8 else alpha
                else:
                    output_alpha = _resample(self, A[..., 3], out_shape, t, alpha=alpha)
                output = _resample(self, _rgb_to_rgba(A[..., :3]), out_shape, t, alpha=alpha)
                output[..., 3] = output_alpha
            output = self.to_rgba(output, bytes=True, norm=False)
            if A.ndim == 2:
                alpha = self._get_scalar_alpha()
                alpha_channel = output[:, :, 3]
                alpha_channel[:] = alpha_channel.astype(np.float32) * out_alpha * alpha
        else:
            if self._imcache is None:
                self._imcache = self.to_rgba(A, bytes=True, norm=A.ndim == 2)
            output = self._imcache
            subset = TransformedBbox(clip_bbox, t0.inverted()).frozen()
            output = output[int(max(subset.ymin, 0)):int(min(subset.ymax + 1, output.shape[0])), int(max(subset.xmin, 0)):int(min(subset.xmax + 1, output.shape[1]))]
            t = Affine2D().translate(int(max(subset.xmin, 0)), int(max(subset.ymin, 0))) + t
        return (output, clipped_bbox.x0, clipped_bbox.y0, t)

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        raise NotImplementedError('The make_image method must be overridden')

    def _check_unsampled_image(self):
        return False

    @martist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            self.stale = False
            return
        if self.get_array().size == 0:
            self.stale = False
            return
        gc = renderer.new_gc()
        self._set_gc_clip(gc)
        gc.set_alpha(self._get_scalar_alpha())
        gc.set_url(self.get_url())
        gc.set_gid(self.get_gid())
        if renderer.option_scale_image() and self._check_unsampled_image() and self.get_transform().is_affine:
            (im, l, b, trans) = self.make_image(renderer, unsampled=True)
            if im is not None:
                trans = Affine2D().scale(im.shape[1], im.shape[0]) + trans
                renderer.draw_image(gc, l, b, im, trans)
        else:
            (im, l, b, trans) = self.make_image(renderer, renderer.get_image_magnification())
            if im is not None:
                renderer.draw_image(gc, l, b, im)
        gc.restore()
        self.stale = False

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent) or not self.axes.contains(mouseevent)[0]:
            return (False, {})
        trans = self.get_transform().inverted()
        (x, y) = trans.transform([mouseevent.x, mouseevent.y])
        (xmin, xmax, ymin, ymax) = self.get_extent()
        inside = x is not None and (x - xmin) * (x - xmax) <= 0 and (y is not None) and ((y - ymin) * (y - ymax) <= 0)
        return (inside, {})

    def write_png(self, fname):
        im = self.to_rgba(self._A[::-1] if self.origin == 'lower' else self._A, bytes=True, norm=True)
        PIL.Image.fromarray(im).save(fname, format='png')

    @staticmethod
    def _normalize_image_array(A):
        A = cbook.safe_masked_invalid(A, copy=True)
        if A.dtype != np.uint8 and (not np.can_cast(A.dtype, float, 'same_kind')):
            raise TypeError(f'Image data of dtype {A.dtype} cannot be converted to float')
        if A.ndim == 3 and A.shape[-1] == 1:
            A = A.squeeze(-1)
        if not (A.ndim == 2 or (A.ndim == 3 and A.shape[-1] in [3, 4])):
            raise TypeError(f'Invalid shape {A.shape} for image data')
        if A.ndim == 3:
            high = 255 if np.issubdtype(A.dtype, np.integer) else 1
            if A.min() < 0 or high < A.max():
                _log.warning('Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [%s..%s].', A.min(), A.max())
                A = np.clip(A, 0, high)
            if A.dtype != np.uint8 and np.issubdtype(A.dtype, np.integer):
                A = A.astype(np.uint8)
        return A

    def set_data(self, A):
        if isinstance(A, PIL.Image.Image):
            A = pil_to_array(A)
        self._A = self._normalize_image_array(A)
        self._imcache = None
        self.stale = True

    def set_array(self, A):
        self.set_data(A)

    def get_interpolation(self):
        return self._interpolation

    def set_interpolation(self, s):
        s = mpl._val_or_rc(s, 'image.interpolation').lower()
        _api.check_in_list(interpolations_names, interpolation=s)
        self._interpolation = s
        self.stale = True

    def get_interpolation_stage(self):
        return self._interpolation_stage

    def set_interpolation_stage(self, s):
        s = mpl._val_or_rc(s, 'image.interpolation_stage')
        _api.check_in_list(['data', 'rgba', 'auto'], s=s)
        self._interpolation_stage = s
        self.stale = True

    def can_composite(self):
        trans = self.get_transform()
        return self._interpolation != 'none' and trans.is_affine and trans.is_separable

    def set_resample(self, v):
        v = mpl._val_or_rc(v, 'image.resample')
        self._resample = v
        self.stale = True

    def get_resample(self):
        return self._resample

    def set_filternorm(self, filternorm):
        self._filternorm = bool(filternorm)
        self.stale = True

    def get_filternorm(self):
        return self._filternorm

    def set_filterrad(self, filterrad):
        r = float(filterrad)
        if r <= 0:
            raise ValueError('The filter radius must be a positive number')
        self._filterrad = r
        self.stale = True

    def get_filterrad(self):
        return self._filterrad

class AxesImage(_ImageBase):

    def __init__(self, ax, *, cmap=None, norm=None, interpolation=None, origin=None, extent=None, filternorm=True, filterrad=4.0, resample=False, interpolation_stage=None, **kwargs):
        self._extent = extent
        super().__init__(ax, cmap=cmap, norm=norm, interpolation=interpolation, origin=origin, filternorm=filternorm, filterrad=filterrad, resample=resample, interpolation_stage=interpolation_stage, **kwargs)

    def get_window_extent(self, renderer=None):
        (x0, x1, y0, y1) = self._extent
        bbox = Bbox.from_extents([x0, y0, x1, y1])
        return bbox.transformed(self.get_transform())

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        trans = self.get_transform()
        (x1, x2, y1, y2) = self.get_extent()
        bbox = Bbox(np.array([[x1, y1], [x2, y2]]))
        transformed_bbox = TransformedBbox(bbox, trans)
        clip = self.get_clip_box() or self.axes.bbox if self.get_clip_on() else self.get_figure(root=True).bbox
        return self._make_image(self._A, bbox, transformed_bbox, clip, magnification, unsampled=unsampled)

    def _check_unsampled_image(self):
        return self.get_interpolation() == 'none'

    def set_extent(self, extent, **kwargs):
        ((xmin, xmax), (ymin, ymax)) = self.axes._process_unit_info([('x', [extent[0], extent[1]]), ('y', [extent[2], extent[3]])], kwargs)
        if kwargs:
            raise _api.kwarg_error('set_extent', kwargs)
        xmin = self.axes._validate_converted_limits(xmin, self.convert_xunits)
        xmax = self.axes._validate_converted_limits(xmax, self.convert_xunits)
        ymin = self.axes._validate_converted_limits(ymin, self.convert_yunits)
        ymax = self.axes._validate_converted_limits(ymax, self.convert_yunits)
        extent = [xmin, xmax, ymin, ymax]
        self._extent = extent
        corners = ((xmin, ymin), (xmax, ymax))
        self.axes.update_datalim(corners)
        self.sticky_edges.x[:] = [xmin, xmax]
        self.sticky_edges.y[:] = [ymin, ymax]
        if self.axes.get_autoscalex_on():
            self.axes.set_xlim((xmin, xmax), auto=None)
        if self.axes.get_autoscaley_on():
            self.axes.set_ylim((ymin, ymax), auto=None)
        self.stale = True

    def get_extent(self):
        if self._extent is not None:
            return self._extent
        else:
            sz = self.get_size()
            (numrows, numcols) = sz
            if self.origin == 'upper':
                return (-0.5, numcols - 0.5, numrows - 0.5, -0.5)
            else:
                return (-0.5, numcols - 0.5, -0.5, numrows - 0.5)

    def get_cursor_data(self, event):
        (xmin, xmax, ymin, ymax) = self.get_extent()
        if self.origin == 'upper':
            (ymin, ymax) = (ymax, ymin)
        arr = self.get_array()
        data_extent = Bbox([[xmin, ymin], [xmax, ymax]])
        array_extent = Bbox([[0, 0], [arr.shape[1], arr.shape[0]]])
        trans = self.get_transform().inverted()
        trans += BboxTransform(boxin=data_extent, boxout=array_extent)
        point = trans.transform([event.x, event.y])
        if any(np.isnan(point)):
            return None
        (j, i) = point.astype(int)
        if not 0 <= i < arr.shape[0] or not 0 <= j < arr.shape[1]:
            return None
        else:
            return arr[i, j]

class NonUniformImage(AxesImage):

    def __init__(self, ax, *, interpolation='nearest', **kwargs):
        super().__init__(ax, **kwargs)
        self.set_interpolation(interpolation)

    def _check_unsampled_image(self):
        return False

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        if self._A is None:
            raise RuntimeError('You must first set the image array')
        if unsampled:
            raise ValueError('unsampled not supported on NonUniformImage')
        A = self._A
        if A.ndim == 2:
            if A.dtype != np.uint8:
                A = self.to_rgba(A, bytes=True)
            else:
                A = np.repeat(A[:, :, np.newaxis], 4, 2)
                A[:, :, 3] = 255
        else:
            if A.dtype != np.uint8:
                A = (255 * A).astype(np.uint8)
            if A.shape[2] == 3:
                B = np.zeros(tuple([*A.shape[0:2], 4]), np.uint8)
                B[:, :, 0:3] = A
                B[:, :, 3] = 255
                A = B
        (l, b, r, t) = self.axes.bbox.extents
        width = int((round(r) + 0.5 - (round(l) - 0.5)) * magnification)
        height = int((round(t) + 0.5 - (round(b) - 0.5)) * magnification)
        invertedTransform = self.axes.transData.inverted()
        x_pix = invertedTransform.transform([(x, b) for x in np.linspace(l, r, width)])[:, 0]
        y_pix = invertedTransform.transform([(l, y) for y in np.linspace(b, t, height)])[:, 1]
        if self._interpolation == 'nearest':
            x_mid = (self._Ax[:-1] + self._Ax[1:]) / 2
            y_mid = (self._Ay[:-1] + self._Ay[1:]) / 2
            x_int = x_mid.searchsorted(x_pix)
            y_int = y_mid.searchsorted(y_pix)
            im = np.ascontiguousarray(A).view(np.uint32).ravel()[np.add.outer(y_int * A.shape[1], x_int)].view(np.uint8).reshape((height, width, 4))
        else:
            x_int = np.clip(self._Ax.searchsorted(x_pix) - 1, 0, len(self._Ax) - 2)
            y_int = np.clip(self._Ay.searchsorted(y_pix) - 1, 0, len(self._Ay) - 2)
            idx_int = np.add.outer(y_int * A.shape[1], x_int)
            x_frac = np.clip(np.divide(x_pix - self._Ax[x_int], np.diff(self._Ax)[x_int], dtype=np.float32), 0, 1)
            y_frac = np.clip(np.divide(y_pix - self._Ay[y_int], np.diff(self._Ay)[y_int], dtype=np.float32), 0, 1)
            f00 = np.outer(1 - y_frac, 1 - x_frac)
            f10 = np.outer(y_frac, 1 - x_frac)
            f01 = np.outer(1 - y_frac, x_frac)
            f11 = np.outer(y_frac, x_frac)
            im = np.empty((height, width, 4), np.uint8)
            for chan in range(4):
                ac = A[:, :, chan].reshape(-1)
                buf = f00 * ac[idx_int]
                buf += f10 * ac[A.shape[1]:][idx_int]
                buf += f01 * ac[1:][idx_int]
                buf += f11 * ac[A.shape[1] + 1:][idx_int]
                im[:, :, chan] = buf
        return (im, l, b, IdentityTransform())

    def set_data(self, x, y, A):
        A = self._normalize_image_array(A)
        x = np.array(x, np.float32)
        y = np.array(y, np.float32)
        if not (x.ndim == y.ndim == 1 and A.shape[:2] == y.shape + x.shape):
            raise TypeError("Axes don't match array shape")
        self._A = A
        self._Ax = x
        self._Ay = y
        self._imcache = None
        self.stale = True

    def set_array(self, *args):
        raise NotImplementedError('Method not supported')

    def set_interpolation(self, s):
        if s is not None and s not in ('nearest', 'bilinear'):
            raise NotImplementedError('Only nearest neighbor and bilinear interpolations are supported')
        super().set_interpolation(s)

    def get_extent(self):
        if self._A is None:
            raise RuntimeError('Must set data first')
        return (self._Ax[0], self._Ax[-1], self._Ay[0], self._Ay[-1])

    def set_filternorm(self, filternorm):
        pass

    def set_filterrad(self, filterrad):
        pass

    def set_norm(self, norm):
        if self._A is not None:
            raise RuntimeError('Cannot change colors after loading data')
        super().set_norm(norm)

    def set_cmap(self, cmap):
        if self._A is not None:
            raise RuntimeError('Cannot change colors after loading data')
        super().set_cmap(cmap)

    def get_cursor_data(self, event):
        (x, y) = (event.xdata, event.ydata)
        if x < self._Ax[0] or x > self._Ax[-1] or y < self._Ay[0] or (y > self._Ay[-1]):
            return None
        j = np.searchsorted(self._Ax, x) - 1
        i = np.searchsorted(self._Ay, y) - 1
        return self._A[i, j]

class PcolorImage(AxesImage):

    def __init__(self, ax, x=None, y=None, A=None, *, cmap=None, norm=None, **kwargs):
        super().__init__(ax, norm=norm, cmap=cmap)
        self._internal_update(kwargs)
        if A is not None:
            self.set_data(x, y, A)

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        if self._A is None:
            raise RuntimeError('You must first set the image array')
        if unsampled:
            raise ValueError('unsampled not supported on PColorImage')
        if self._imcache is None:
            A = self.to_rgba(self._A, bytes=True)
            self._imcache = np.pad(A, [(1, 1), (1, 1), (0, 0)], 'constant')
        padded_A = self._imcache
        bg = mcolors.to_rgba(self.axes.patch.get_facecolor(), 0)
        bg = (np.array(bg) * 255).astype(np.uint8)
        if (padded_A[0, 0] != bg).all():
            padded_A[[0, -1], :] = padded_A[:, [0, -1]] = bg
        (l, b, r, t) = self.axes.bbox.extents
        width = round(r) + 0.5 - (round(l) - 0.5)
        height = round(t) + 0.5 - (round(b) - 0.5)
        width = round(width * magnification)
        height = round(height * magnification)
        vl = self.axes.viewLim
        x_pix = np.linspace(vl.x0, vl.x1, width)
        y_pix = np.linspace(vl.y0, vl.y1, height)
        x_int = self._Ax.searchsorted(x_pix)
        y_int = self._Ay.searchsorted(y_pix)
        im = padded_A.view(np.uint32).ravel()[np.add.outer(y_int * padded_A.shape[1], x_int)].view(np.uint8).reshape((height, width, 4))
        return (im, l, b, IdentityTransform())

    def _check_unsampled_image(self):
        return False

    def set_data(self, x, y, A):
        A = self._normalize_image_array(A)
        x = np.arange(0.0, A.shape[1] + 1) if x is None else np.array(x, float).ravel()
        y = np.arange(0.0, A.shape[0] + 1) if y is None else np.array(y, float).ravel()
        if A.shape[:2] != (y.size - 1, x.size - 1):
            raise ValueError("Axes don't match array shape. Got %s, expected %s." % (A.shape[:2], (y.size - 1, x.size - 1)))
        if x[-1] < x[0]:
            x = x[::-1]
            A = A[:, ::-1]
        if y[-1] < y[0]:
            y = y[::-1]
            A = A[::-1]
        self._A = A
        self._Ax = x
        self._Ay = y
        self._imcache = None
        self.stale = True

    def set_array(self, *args):
        raise NotImplementedError('Method not supported')

    def get_cursor_data(self, event):
        (x, y) = (event.xdata, event.ydata)
        if x < self._Ax[0] or x > self._Ax[-1] or y < self._Ay[0] or (y > self._Ay[-1]):
            return None
        j = np.searchsorted(self._Ax, x) - 1
        i = np.searchsorted(self._Ay, y) - 1
        return self._A[i, j]

class FigureImage(_ImageBase):
    zorder = 0
    _interpolation = 'nearest'

    def __init__(self, fig, *, cmap=None, norm=None, offsetx=0, offsety=0, origin=None, **kwargs):
        super().__init__(None, norm=norm, cmap=cmap, origin=origin)
        self.set_figure(fig)
        self.ox = offsetx
        self.oy = offsety
        self._internal_update(kwargs)
        self.magnification = 1.0

    def get_extent(self):
        (numrows, numcols) = self.get_size()
        return (-0.5 + self.ox, numcols - 0.5 + self.ox, -0.5 + self.oy, numrows - 0.5 + self.oy)

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        fig = self.get_figure(root=True)
        fac = renderer.dpi / fig.dpi
        bbox = Bbox([[self.ox / fac, self.oy / fac], [self.ox / fac + self._A.shape[1], self.oy / fac + self._A.shape[0]]])
        (width, height) = fig.get_size_inches()
        width *= renderer.dpi
        height *= renderer.dpi
        clip = Bbox([[0, 0], [width, height]])
        return self._make_image(self._A, bbox, bbox, clip, magnification=magnification / fac, unsampled=unsampled, round_to_pixel_border=False)

    def set_data(self, A):
        cm.ScalarMappable.set_array(self, A)
        self.stale = True

class BboxImage(_ImageBase):

    def __init__(self, bbox, *, cmap=None, norm=None, interpolation=None, origin=None, filternorm=True, filterrad=4.0, resample=False, **kwargs):
        super().__init__(None, cmap=cmap, norm=norm, interpolation=interpolation, origin=origin, filternorm=filternorm, filterrad=filterrad, resample=resample, **kwargs)
        self.bbox = bbox

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure()._get_renderer()
        if isinstance(self.bbox, BboxBase):
            return self.bbox
        elif callable(self.bbox):
            return self.bbox(renderer)
        else:
            raise ValueError('Unknown type of bbox')

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent) or not self.get_visible():
            return (False, {})
        (x, y) = (mouseevent.x, mouseevent.y)
        inside = self.get_window_extent().contains(x, y)
        return (inside, {})

    def make_image(self, renderer, magnification=1.0, unsampled=False):
        (width, height) = renderer.get_canvas_width_height()
        bbox_in = self.get_window_extent(renderer).frozen()
        bbox_in._points /= [width, height]
        bbox_out = self.get_window_extent(renderer)
        clip = Bbox([[0, 0], [width, height]])
        self._transform = BboxTransformTo(clip)
        return self._make_image(self._A, bbox_in, bbox_out, clip, magnification, unsampled=unsampled)

def imread(fname, format=None):
    from urllib import parse
    if format is None:
        if isinstance(fname, str):
            parsed = parse.urlparse(fname)
            if len(parsed.scheme) > 1:
                ext = 'png'
            else:
                ext = Path(fname).suffix.lower()[1:]
        elif hasattr(fname, 'geturl'):
            ext = 'png'
        elif hasattr(fname, 'name'):
            ext = Path(fname.name).suffix.lower()[1:]
        else:
            ext = 'png'
    else:
        ext = format
    img_open = PIL.PngImagePlugin.PngImageFile if ext == 'png' else PIL.Image.open
    if isinstance(fname, str) and len(parse.urlparse(fname).scheme) > 1:
        raise ValueError('Please open the URL for reading and pass the result to Pillow, e.g. with ``np.array(PIL.Image.open(urllib.request.urlopen(url)))``.')
    with img_open(fname) as image:
        return _pil_png_to_float_array(image) if isinstance(image, PIL.PngImagePlugin.PngImageFile) else pil_to_array(image)

def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None, dpi=100, *, metadata=None, pil_kwargs=None):
    from matplotlib.figure import Figure
    if isinstance(fname, os.PathLike):
        fname = os.fspath(fname)
    if format is None:
        format = (Path(fname).suffix[1:] if isinstance(fname, str) else mpl.rcParams['savefig.format']).lower()
    if format in ['pdf', 'ps', 'eps', 'svg']:
        if pil_kwargs is not None:
            raise ValueError(f"Cannot use 'pil_kwargs' when saving to {format}")
        fig = Figure(dpi=dpi, frameon=False)
        fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin, resize=True)
        fig.savefig(fname, dpi=dpi, format=format, transparent=True, metadata=metadata)
    else:
        if origin is None:
            origin = mpl.rcParams['image.origin']
        else:
            _api.check_in_list(('upper', 'lower'), origin=origin)
        if origin == 'lower':
            arr = arr[::-1]
        if isinstance(arr, memoryview) and arr.format == 'B' and (arr.ndim == 3) and (arr.shape[-1] == 4):
            rgba = arr
        else:
            sm = cm.ScalarMappable(cmap=cmap)
            sm.set_clim(vmin, vmax)
            rgba = sm.to_rgba(arr, bytes=True)
        if pil_kwargs is None:
            pil_kwargs = {}
        else:
            pil_kwargs = pil_kwargs.copy()
        pil_shape = (rgba.shape[1], rgba.shape[0])
        rgba = np.require(rgba, requirements='C')
        image = PIL.Image.frombuffer('RGBA', pil_shape, rgba, 'raw', 'RGBA', 0, 1)
        if format == 'png':
            if 'pnginfo' in pil_kwargs:
                if metadata:
                    _api.warn_external("'metadata' is overridden by the 'pnginfo' entry in 'pil_kwargs'.")
            else:
                metadata = {'Software': f'Matplotlib version{mpl.__version__}, https://matplotlib.org/', **(metadata if metadata is not None else {})}
                pil_kwargs['pnginfo'] = pnginfo = PIL.PngImagePlugin.PngInfo()
                for (k, v) in metadata.items():
                    if v is not None:
                        pnginfo.add_text(k, v)
        elif metadata is not None:
            raise ValueError(f'metadata not supported for format {format!r}')
        if format in ['jpg', 'jpeg']:
            format = 'jpeg'
            facecolor = mpl.rcParams['savefig.facecolor']
            if cbook._str_equal(facecolor, 'auto'):
                facecolor = mpl.rcParams['figure.facecolor']
            color = tuple((int(x * 255) for x in mcolors.to_rgb(facecolor)))
            background = PIL.Image.new('RGB', pil_shape, color)
            background.paste(image, image)
            image = background
        pil_kwargs.setdefault('format', format)
        pil_kwargs.setdefault('dpi', (dpi, dpi))
        image.save(fname, **pil_kwargs)

def pil_to_array(pilImage):
    if pilImage.mode in ['RGBA', 'RGBX', 'RGB', 'L']:
        return np.asarray(pilImage)
    elif pilImage.mode.startswith('I;16'):
        raw = pilImage.tobytes('raw', pilImage.mode)
        if pilImage.mode.endswith('B'):
            x = np.frombuffer(raw, '>u2')
        else:
            x = np.frombuffer(raw, '<u2')
        return x.reshape(pilImage.size[::-1]).astype('=u2')
    else:
        try:
            pilImage = pilImage.convert('RGBA')
        except ValueError as err:
            raise RuntimeError('Unknown image mode') from err
        return np.asarray(pilImage)

def _pil_png_to_float_array(pil_png):
    mode = pil_png.mode
    rawmode = pil_png.png.im_rawmode
    if rawmode == '1':
        return np.asarray(pil_png, np.float32)
    if rawmode == 'L;2':
        return np.divide(pil_png, 2 ** 2 - 1, dtype=np.float32)
    if rawmode == 'L;4':
        return np.divide(pil_png, 2 ** 4 - 1, dtype=np.float32)
    if rawmode == 'L':
        return np.divide(pil_png, 2 ** 8 - 1, dtype=np.float32)
    if rawmode == 'I;16B':
        return np.divide(pil_png, 2 ** 16 - 1, dtype=np.float32)
    if mode == 'RGB':
        return np.divide(pil_png, 2 ** 8 - 1, dtype=np.float32)
    if mode == 'P':
        return np.divide(pil_png.convert('RGBA'), 2 ** 8 - 1, dtype=np.float32)
    if mode == 'LA':
        return np.divide(pil_png.convert('RGBA'), 2 ** 8 - 1, dtype=np.float32)
    if mode == 'RGBA':
        return np.divide(pil_png, 2 ** 8 - 1, dtype=np.float32)
    raise ValueError(f'Unknown PIL rawmode: {rawmode}')

def thumbnail(infile, thumbfile, scale=0.1, interpolation='bilinear', preview=False):
    im = imread(infile)
    (rows, cols, depth) = im.shape
    dpi = 100
    height = rows / dpi * scale
    width = cols / dpi * scale
    if preview:
        import matplotlib.pyplot as plt
        fig = plt.figure(figsize=(width, height), dpi=dpi)
    else:
        from matplotlib.figure import Figure
        fig = Figure(figsize=(width, height), dpi=dpi)
        FigureCanvasBase(fig)
    ax = fig.add_axes([0, 0, 1, 1], aspect='auto', frameon=False, xticks=[], yticks=[])
    ax.imshow(im, aspect='auto', resample=True, interpolation=interpolation)
    fig.savefig(thumbfile, dpi=dpi)
    return fig

# File: matplotlib-main/lib/matplotlib/layout_engine.py
""""""
from contextlib import nullcontext
import matplotlib as mpl
from matplotlib._constrained_layout import do_constrained_layout
from matplotlib._tight_layout import get_subplotspec_list, get_tight_layout_figure

class LayoutEngine:
    _adjust_compatible = None
    _colorbar_gridspec = None

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._params = {}

    def set(self, **kwargs):
        raise NotImplementedError

    @property
    def colorbar_gridspec(self):
        if self._colorbar_gridspec is None:
            raise NotImplementedError
        return self._colorbar_gridspec

    @property
    def adjust_compatible(self):
        if self._adjust_compatible is None:
            raise NotImplementedError
        return self._adjust_compatible

    def get(self):
        return dict(self._params)

    def execute(self, fig):
        raise NotImplementedError

class PlaceHolderLayoutEngine(LayoutEngine):

    def __init__(self, adjust_compatible, colorbar_gridspec, **kwargs):
        self._adjust_compatible = adjust_compatible
        self._colorbar_gridspec = colorbar_gridspec
        super().__init__(**kwargs)

    def execute(self, fig):
        return

class TightLayoutEngine(LayoutEngine):
    _adjust_compatible = True
    _colorbar_gridspec = True

    def __init__(self, *, pad=1.08, h_pad=None, w_pad=None, rect=(0, 0, 1, 1), **kwargs):
        super().__init__(**kwargs)
        for td in ['pad', 'h_pad', 'w_pad', 'rect']:
            self._params[td] = None
        self.set(pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)

    def execute(self, fig):
        info = self._params
        renderer = fig._get_renderer()
        with getattr(renderer, '_draw_disabled', nullcontext)():
            kwargs = get_tight_layout_figure(fig, fig.axes, get_subplotspec_list(fig.axes), renderer, pad=info['pad'], h_pad=info['h_pad'], w_pad=info['w_pad'], rect=info['rect'])
        if kwargs:
            fig.subplots_adjust(**kwargs)

    def set(self, *, pad=None, w_pad=None, h_pad=None, rect=None):
        for td in self.set.__kwdefaults__:
            if locals()[td] is not None:
                self._params[td] = locals()[td]

class ConstrainedLayoutEngine(LayoutEngine):
    _adjust_compatible = False
    _colorbar_gridspec = False

    def __init__(self, *, h_pad=None, w_pad=None, hspace=None, wspace=None, rect=(0, 0, 1, 1), compress=False, **kwargs):
        super().__init__(**kwargs)
        self.set(w_pad=mpl.rcParams['figure.constrained_layout.w_pad'], h_pad=mpl.rcParams['figure.constrained_layout.h_pad'], wspace=mpl.rcParams['figure.constrained_layout.wspace'], hspace=mpl.rcParams['figure.constrained_layout.hspace'], rect=(0, 0, 1, 1))
        self.set(w_pad=w_pad, h_pad=h_pad, wspace=wspace, hspace=hspace, rect=rect)
        self._compress = compress

    def execute(self, fig):
        (width, height) = fig.get_size_inches()
        w_pad = self._params['w_pad'] / width
        h_pad = self._params['h_pad'] / height
        return do_constrained_layout(fig, w_pad=w_pad, h_pad=h_pad, wspace=self._params['wspace'], hspace=self._params['hspace'], rect=self._params['rect'], compress=self._compress)

    def set(self, *, h_pad=None, w_pad=None, hspace=None, wspace=None, rect=None):
        for td in self.set.__kwdefaults__:
            if locals()[td] is not None:
                self._params[td] = locals()[td]

# File: matplotlib-main/lib/matplotlib/legend.py
""""""
import itertools
import logging
import numbers
import time
import numpy as np
import matplotlib as mpl
from matplotlib import _api, _docstring, cbook, colors, offsetbox
from matplotlib.artist import Artist, allow_rasterization
from matplotlib.cbook import silent_list
from matplotlib.font_manager import FontProperties
from matplotlib.lines import Line2D
from matplotlib.patches import Patch, Rectangle, Shadow, FancyBboxPatch, StepPatch
from matplotlib.collections import Collection, CircleCollection, LineCollection, PathCollection, PolyCollection, RegularPolyCollection
from matplotlib.text import Text
from matplotlib.transforms import Bbox, BboxBase, TransformedBbox
from matplotlib.transforms import BboxTransformTo, BboxTransformFrom
from matplotlib.offsetbox import AnchoredOffsetbox, DraggableOffsetBox, HPacker, VPacker, DrawingArea, TextArea
from matplotlib.container import ErrorbarContainer, BarContainer, StemContainer
from . import legend_handler

class DraggableLegend(DraggableOffsetBox):

    def __init__(self, legend, use_blit=False, update='loc'):
        self.legend = legend
        _api.check_in_list(['loc', 'bbox'], update=update)
        self._update = update
        super().__init__(legend, legend._legend_box, use_blit=use_blit)

    def finalize_offset(self):
        if self._update == 'loc':
            self._update_loc(self.get_loc_in_canvas())
        elif self._update == 'bbox':
            self._update_bbox_to_anchor(self.get_loc_in_canvas())

    def _update_loc(self, loc_in_canvas):
        bbox = self.legend.get_bbox_to_anchor()
        if bbox.width == 0 or bbox.height == 0:
            self.legend.set_bbox_to_anchor(None)
            bbox = self.legend.get_bbox_to_anchor()
        _bbox_transform = BboxTransformFrom(bbox)
        self.legend._loc = tuple(_bbox_transform.transform(loc_in_canvas))

    def _update_bbox_to_anchor(self, loc_in_canvas):
        loc_in_bbox = self.legend.axes.transAxes.transform(loc_in_canvas)
        self.legend.set_bbox_to_anchor(loc_in_bbox)
_legend_kw_doc_base = '\nbbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats\n    Box that is used to position the legend in conjunction with *loc*.\n    Defaults to ``axes.bbox`` (if called as a method to `.Axes.legend`) or\n    ``figure.bbox`` (if ``figure.legend``).  This argument allows arbitrary\n    placement of the legend.\n\n    Bbox coordinates are interpreted in the coordinate system given by\n    *bbox_transform*, with the default transform\n    Axes or Figure coordinates, depending on which ``legend`` is called.\n\n    If a 4-tuple or `.BboxBase` is given, then it specifies the bbox\n    ``(x, y, width, height)`` that the legend is placed in.\n    To put the legend in the best location in the bottom right\n    quadrant of the Axes (or figure)::\n\n        loc=\'best\', bbox_to_anchor=(0.5, 0., 0.5, 0.5)\n\n    A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at\n    x, y.  For example, to put the legend\'s upper right-hand corner in the\n    center of the Axes (or figure) the following keywords can be used::\n\n        loc=\'upper right\', bbox_to_anchor=(0.5, 0.5)\n\nncols : int, default: 1\n    The number of columns that the legend has.\n\n    For backward compatibility, the spelling *ncol* is also supported\n    but it is discouraged. If both are given, *ncols* takes precedence.\n\nprop : None or `~matplotlib.font_manager.FontProperties` or dict\n    The font properties of the legend. If None (default), the current\n    :data:`matplotlib.rcParams` will be used.\n\nfontsize : int or {\'xx-small\', \'x-small\', \'small\', \'medium\', \'large\', \'x-large\', \'xx-large\'}\n    The font size of the legend. If the value is numeric the size will be the\n    absolute font size in points. String values are relative to the current\n    default font size. This argument is only used if *prop* is not specified.\n\nlabelcolor : str or list, default: :rc:`legend.labelcolor`\n    The color of the text in the legend. Either a valid color string\n    (for example, \'red\'), or a list of color strings. The labelcolor can\n    also be made to match the color of the line or marker using \'linecolor\',\n    \'markerfacecolor\' (or \'mfc\'), or \'markeredgecolor\' (or \'mec\').\n\n    Labelcolor can be set globally using :rc:`legend.labelcolor`. If None,\n    use :rc:`text.color`.\n\nnumpoints : int, default: :rc:`legend.numpoints`\n    The number of marker points in the legend when creating a legend\n    entry for a `.Line2D` (line).\n\nscatterpoints : int, default: :rc:`legend.scatterpoints`\n    The number of marker points in the legend when creating\n    a legend entry for a `.PathCollection` (scatter plot).\n\nscatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``\n    The vertical offset (relative to the font size) for the markers\n    created for a scatter plot legend entry. 0.0 is at the base the\n    legend text, and 1.0 is at the top. To draw all markers at the\n    same height, set to ``[0.5]``.\n\nmarkerscale : float, default: :rc:`legend.markerscale`\n    The relative size of legend markers compared to the originally drawn ones.\n\nmarkerfirst : bool, default: True\n    If *True*, legend marker is placed to the left of the legend label.\n    If *False*, legend marker is placed to the right of the legend label.\n\nreverse : bool, default: False\n    If *True*, the legend labels are displayed in reverse order from the input.\n    If *False*, the legend labels are displayed in the same order as the input.\n\n    .. versionadded:: 3.7\n\nframeon : bool, default: :rc:`legend.frameon`\n    Whether the legend should be drawn on a patch (frame).\n\nfancybox : bool, default: :rc:`legend.fancybox`\n    Whether round edges should be enabled around the `.FancyBboxPatch` which\n    makes up the legend\'s background.\n\nshadow : None, bool or dict, default: :rc:`legend.shadow`\n    Whether to draw a shadow behind the legend.\n    The shadow can be configured using `.Patch` keywords.\n    Customization via :rc:`legend.shadow` is currently not supported.\n\nframealpha : float, default: :rc:`legend.framealpha`\n    The alpha transparency of the legend\'s background.\n    If *shadow* is activated and *framealpha* is ``None``, the default value is\n    ignored.\n\nfacecolor : "inherit" or color, default: :rc:`legend.facecolor`\n    The legend\'s background color.\n    If ``"inherit"``, use :rc:`axes.facecolor`.\n\nedgecolor : "inherit" or color, default: :rc:`legend.edgecolor`\n    The legend\'s background patch edge color.\n    If ``"inherit"``, use :rc:`axes.edgecolor`.\n\nmode : {"expand", None}\n    If *mode* is set to ``"expand"`` the legend will be horizontally\n    expanded to fill the Axes area (or *bbox_to_anchor* if defines\n    the legend\'s size).\n\nbbox_transform : None or `~matplotlib.transforms.Transform`\n    The transform for the bounding box (*bbox_to_anchor*). For a value\n    of ``None`` (default) the Axes\'\n    :data:`~matplotlib.axes.Axes.transAxes` transform will be used.\n\ntitle : str or None\n    The legend\'s title. Default is no title (``None``).\n\ntitle_fontproperties : None or `~matplotlib.font_manager.FontProperties` or dict\n    The font properties of the legend\'s title. If None (default), the\n    *title_fontsize* argument will be used if present; if *title_fontsize* is\n    also None, the current :rc:`legend.title_fontsize` will be used.\n\ntitle_fontsize : int or {\'xx-small\', \'x-small\', \'small\', \'medium\', \'large\', \'x-large\', \'xx-large\'}, default: :rc:`legend.title_fontsize`\n    The font size of the legend\'s title.\n    Note: This cannot be combined with *title_fontproperties*. If you want\n    to set the fontsize alongside other font properties, use the *size*\n    parameter in *title_fontproperties*.\n\nalignment : {\'center\', \'left\', \'right\'}, default: \'center\'\n    The alignment of the legend title and the box of entries. The entries\n    are aligned as a single block, so that markers always lined up.\n\nborderpad : float, default: :rc:`legend.borderpad`\n    The fractional whitespace inside the legend border, in font-size units.\n\nlabelspacing : float, default: :rc:`legend.labelspacing`\n    The vertical space between the legend entries, in font-size units.\n\nhandlelength : float, default: :rc:`legend.handlelength`\n    The length of the legend handles, in font-size units.\n\nhandleheight : float, default: :rc:`legend.handleheight`\n    The height of the legend handles, in font-size units.\n\nhandletextpad : float, default: :rc:`legend.handletextpad`\n    The pad between the legend handle and text, in font-size units.\n\nborderaxespad : float, default: :rc:`legend.borderaxespad`\n    The pad between the Axes and legend border, in font-size units.\n\ncolumnspacing : float, default: :rc:`legend.columnspacing`\n    The spacing between columns, in font-size units.\n\nhandler_map : dict or None\n    The custom dictionary mapping instances or types to a legend\n    handler. This *handler_map* updates the default handler map\n    found at `matplotlib.legend.Legend.get_legend_handler_map`.\n\ndraggable : bool, default: False\n    Whether the legend can be dragged with the mouse.\n'
_loc_doc_base = '\nloc : str or pair of floats, default: {default}\n    The location of the legend.\n\n    The strings ``\'upper left\'``, ``\'upper right\'``, ``\'lower left\'``,\n    ``\'lower right\'`` place the legend at the corresponding corner of the\n    {parent}.\n\n    The strings ``\'upper center\'``, ``\'lower center\'``, ``\'center left\'``,\n    ``\'center right\'`` place the legend at the center of the corresponding edge\n    of the {parent}.\n\n    The string ``\'center\'`` places the legend at the center of the {parent}.\n{best}\n    The location can also be a 2-tuple giving the coordinates of the lower-left\n    corner of the legend in {parent} coordinates (in which case *bbox_to_anchor*\n    will be ignored).\n\n    For back-compatibility, ``\'center right\'`` (but no other location) can also\n    be spelled ``\'right\'``, and each "string" location can also be given as a\n    numeric value:\n\n    ==================   =============\n    Location String      Location Code\n    ==================   =============\n    \'best\' (Axes only)   0\n    \'upper right\'        1\n    \'upper left\'         2\n    \'lower left\'         3\n    \'lower right\'        4\n    \'right\'              5\n    \'center left\'        6\n    \'center right\'       7\n    \'lower center\'       8\n    \'upper center\'       9\n    \'center\'             10\n    ==================   =============\n    {outside}'
_loc_doc_best = "\n    The string ``'best'`` places the legend at the location, among the nine\n    locations defined so far, with the minimum overlap with other drawn\n    artists.  This option can be quite slow for plots with large amounts of\n    data; your plotting speed may benefit from providing a specific location.\n"
_legend_kw_axes_st = _loc_doc_base.format(parent='axes', default=':rc:`legend.loc`', best=_loc_doc_best, outside='') + _legend_kw_doc_base
_docstring.interpd.update(_legend_kw_axes=_legend_kw_axes_st)
_outside_doc = "\n    If a figure is using the constrained layout manager, the string codes\n    of the *loc* keyword argument can get better layout behaviour using the\n    prefix 'outside'. There is ambiguity at the corners, so 'outside\n    upper right' will make space for the legend above the rest of the\n    axes in the layout, and 'outside right upper' will make space on the\n    right side of the layout.  In addition to the values of *loc*\n    listed above, we have 'outside right upper', 'outside right lower',\n    'outside left upper', and 'outside left lower'.  See\n    :ref:`legend_guide` for more details.\n"
_legend_kw_figure_st = _loc_doc_base.format(parent='figure', default="'upper right'", best='', outside=_outside_doc) + _legend_kw_doc_base
_docstring.interpd.update(_legend_kw_figure=_legend_kw_figure_st)
_legend_kw_both_st = _loc_doc_base.format(parent='axes/figure', default=":rc:`legend.loc` for Axes, 'upper right' for Figure", best=_loc_doc_best, outside=_outside_doc) + _legend_kw_doc_base
_docstring.interpd.update(_legend_kw_doc=_legend_kw_both_st)
_legend_kw_set_loc_st = _loc_doc_base.format(parent='axes/figure', default=":rc:`legend.loc` for Axes, 'upper right' for Figure", best=_loc_doc_best, outside=_outside_doc)
_docstring.interpd.update(_legend_kw_set_loc_doc=_legend_kw_set_loc_st)

class Legend(Artist):
    codes = {'best': 0, **AnchoredOffsetbox.codes}
    zorder = 5

    def __str__(self):
        return 'Legend'

    @_docstring.dedent_interpd
    def __init__(self, parent, handles, labels, *, loc=None, numpoints=None, markerscale=None, markerfirst=True, reverse=False, scatterpoints=None, scatteryoffsets=None, prop=None, fontsize=None, labelcolor=None, borderpad=None, labelspacing=None, handlelength=None, handleheight=None, handletextpad=None, borderaxespad=None, columnspacing=None, ncols=1, mode=None, fancybox=None, shadow=None, title=None, title_fontsize=None, framealpha=None, edgecolor=None, facecolor=None, bbox_to_anchor=None, bbox_transform=None, frameon=None, handler_map=None, title_fontproperties=None, alignment='center', ncol=1, draggable=False):
        from matplotlib.axes import Axes
        from matplotlib.figure import FigureBase
        super().__init__()
        if prop is None:
            self.prop = FontProperties(size=mpl._val_or_rc(fontsize, 'legend.fontsize'))
        else:
            self.prop = FontProperties._from_any(prop)
            if isinstance(prop, dict) and 'size' not in prop:
                self.prop.set_size(mpl.rcParams['legend.fontsize'])
        self._fontsize = self.prop.get_size_in_points()
        self.texts = []
        self.legend_handles = []
        self._legend_title_box = None
        self._custom_handler_map = handler_map
        self.numpoints = mpl._val_or_rc(numpoints, 'legend.numpoints')
        self.markerscale = mpl._val_or_rc(markerscale, 'legend.markerscale')
        self.scatterpoints = mpl._val_or_rc(scatterpoints, 'legend.scatterpoints')
        self.borderpad = mpl._val_or_rc(borderpad, 'legend.borderpad')
        self.labelspacing = mpl._val_or_rc(labelspacing, 'legend.labelspacing')
        self.handlelength = mpl._val_or_rc(handlelength, 'legend.handlelength')
        self.handleheight = mpl._val_or_rc(handleheight, 'legend.handleheight')
        self.handletextpad = mpl._val_or_rc(handletextpad, 'legend.handletextpad')
        self.borderaxespad = mpl._val_or_rc(borderaxespad, 'legend.borderaxespad')
        self.columnspacing = mpl._val_or_rc(columnspacing, 'legend.columnspacing')
        self.shadow = mpl._val_or_rc(shadow, 'legend.shadow')
        (_lab, _hand) = ([], [])
        for (label, handle) in zip(labels, handles):
            if isinstance(label, str) and label.startswith('_'):
                _api.warn_deprecated('3.8', message="An artist whose label starts with an underscore was passed to legend(); such artists will no longer be ignored in the future.  To suppress this warning, explicitly filter out such artists, e.g. with `[art for art in artists if not art.get_label().startswith('_')]`.")
            else:
                _lab.append(label)
                _hand.append(handle)
        (labels, handles) = (_lab, _hand)
        if reverse:
            labels.reverse()
            handles.reverse()
        if len(handles) < 2:
            ncols = 1
        self._ncols = ncols if ncols != 1 else ncol
        if self.numpoints <= 0:
            raise ValueError('numpoints must be > 0; it was %d' % numpoints)
        if scatteryoffsets is None:
            self._scatteryoffsets = np.array([3.0 / 8.0, 4.0 / 8.0, 2.5 / 8.0])
        else:
            self._scatteryoffsets = np.asarray(scatteryoffsets)
        reps = self.scatterpoints // len(self._scatteryoffsets) + 1
        self._scatteryoffsets = np.tile(self._scatteryoffsets, reps)[:self.scatterpoints]
        self._legend_box = None
        if isinstance(parent, Axes):
            self.isaxes = True
            self.axes = parent
            self.set_figure(parent.get_figure(root=False))
        elif isinstance(parent, FigureBase):
            self.isaxes = False
            self.set_figure(parent)
        else:
            raise TypeError('Legend needs either Axes or FigureBase as parent')
        self.parent = parent
        self._mode = mode
        self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
        self._shadow_props = {'ox': 2, 'oy': -2}
        if isinstance(self.shadow, dict):
            self._shadow_props.update(self.shadow)
            self.shadow = True
        elif self.shadow in (0, 1, True, False):
            self.shadow = bool(self.shadow)
        else:
            raise ValueError(f'Legend shadow must be a dict or bool, not {self.shadow!r} of type {type(self.shadow)}.')
        facecolor = mpl._val_or_rc(facecolor, 'legend.facecolor')
        if facecolor == 'inherit':
            facecolor = mpl.rcParams['axes.facecolor']
        edgecolor = mpl._val_or_rc(edgecolor, 'legend.edgecolor')
        if edgecolor == 'inherit':
            edgecolor = mpl.rcParams['axes.edgecolor']
        fancybox = mpl._val_or_rc(fancybox, 'legend.fancybox')
        self.legendPatch = FancyBboxPatch(xy=(0, 0), width=1, height=1, facecolor=facecolor, edgecolor=edgecolor, alpha=framealpha if framealpha is not None else 1 if shadow else mpl.rcParams['legend.framealpha'], boxstyle='round,pad=0,rounding_size=0.2' if fancybox else 'square,pad=0', mutation_scale=self._fontsize, snap=True, visible=mpl._val_or_rc(frameon, 'legend.frameon'))
        self._set_artist_props(self.legendPatch)
        _api.check_in_list(['center', 'left', 'right'], alignment=alignment)
        self._alignment = alignment
        self._init_legend_box(handles, labels, markerfirst)
        self.set_loc(loc)
        if title_fontsize is not None and title_fontproperties is not None:
            raise ValueError("title_fontsize and title_fontproperties can't be specified at the same time. Only use one of them. ")
        title_prop_fp = FontProperties._from_any(title_fontproperties)
        if isinstance(title_fontproperties, dict):
            if 'size' not in title_fontproperties:
                title_fontsize = mpl.rcParams['legend.title_fontsize']
                title_prop_fp.set_size(title_fontsize)
        elif title_fontsize is not None:
            title_prop_fp.set_size(title_fontsize)
        elif not isinstance(title_fontproperties, FontProperties):
            title_fontsize = mpl.rcParams['legend.title_fontsize']
            title_prop_fp.set_size(title_fontsize)
        self.set_title(title, prop=title_prop_fp)
        self._draggable = None
        self.set_draggable(state=draggable)
        color_getters = {'linecolor': ['get_color', 'get_facecolor'], 'markerfacecolor': ['get_markerfacecolor', 'get_facecolor'], 'mfc': ['get_markerfacecolor', 'get_facecolor'], 'markeredgecolor': ['get_markeredgecolor', 'get_edgecolor'], 'mec': ['get_markeredgecolor', 'get_edgecolor']}
        labelcolor = mpl._val_or_rc(labelcolor, 'legend.labelcolor')
        if labelcolor is None:
            labelcolor = mpl.rcParams['text.color']
        if isinstance(labelcolor, str) and labelcolor in color_getters:
            getter_names = color_getters[labelcolor]
            for (handle, text) in zip(self.legend_handles, self.texts):
                try:
                    if handle.get_array() is not None:
                        continue
                except AttributeError:
                    pass
                for getter_name in getter_names:
                    try:
                        color = getattr(handle, getter_name)()
                        if isinstance(color, np.ndarray):
                            if color.shape[0] == 1 or np.isclose(color, color[0]).all():
                                text.set_color(color[0])
                            else:
                                pass
                        else:
                            text.set_color(color)
                        break
                    except AttributeError:
                        pass
        elif cbook._str_equal(labelcolor, 'none'):
            for text in self.texts:
                text.set_color(labelcolor)
        elif np.iterable(labelcolor):
            for (text, color) in zip(self.texts, itertools.cycle(colors.to_rgba_array(labelcolor))):
                text.set_color(color)
        else:
            raise ValueError(f'Invalid labelcolor: {labelcolor!r}')

    def _set_artist_props(self, a):
        a.set_figure(self.get_figure(root=False))
        if self.isaxes:
            a.axes = self.axes
        a.set_transform(self.get_transform())

    @_docstring.dedent_interpd
    def set_loc(self, loc=None):
        loc0 = loc
        self._loc_used_default = loc is None
        if loc is None:
            loc = mpl.rcParams['legend.loc']
            if not self.isaxes and loc in [0, 'best']:
                loc = 'upper right'
        type_err_message = f'loc must be string, coordinate tuple, or an integer 0-10, not {loc!r}'
        self._outside_loc = None
        if isinstance(loc, str):
            if loc.split()[0] == 'outside':
                loc = loc.split('outside ')[1]
                self._outside_loc = loc.replace('center ', '')
                self._outside_loc = self._outside_loc.split()[0]
                locs = loc.split()
                if len(locs) > 1 and locs[0] in ('right', 'left'):
                    if locs[0] != 'center':
                        locs = locs[::-1]
                    loc = locs[0] + ' ' + locs[1]
            loc = _api.check_getitem(self.codes, loc=loc)
        elif np.iterable(loc):
            loc = tuple(loc)
            if len(loc) != 2 or not all((isinstance(e, numbers.Real) for e in loc)):
                raise ValueError(type_err_message)
        elif isinstance(loc, int):
            if loc < 0 or loc > 10:
                raise ValueError(type_err_message)
        else:
            raise ValueError(type_err_message)
        if self.isaxes and self._outside_loc:
            raise ValueError(f"'outside' option for loc='{loc0}' keyword argument only works for figure legends")
        if not self.isaxes and loc == 0:
            raise ValueError("Automatic legend placement (loc='best') not implemented for figure legend")
        tmp = self._loc_used_default
        self._set_loc(loc)
        self._loc_used_default = tmp

    def _set_loc(self, loc):
        self._loc_used_default = False
        self._loc_real = loc
        self.stale = True
        self._legend_box.set_offset(self._findoffset)

    def set_ncols(self, ncols):
        self._ncols = ncols

    def _get_loc(self):
        return self._loc_real
    _loc = property(_get_loc, _set_loc)

    def _findoffset(self, width, height, xdescent, ydescent, renderer):
        if self._loc == 0:
            (x, y) = self._find_best_position(width, height, renderer)
        elif self._loc in Legend.codes.values():
            bbox = Bbox.from_bounds(0, 0, width, height)
            (x, y) = self._get_anchored_bbox(self._loc, bbox, self.get_bbox_to_anchor(), renderer)
        else:
            (fx, fy) = self._loc
            bbox = self.get_bbox_to_anchor()
            (x, y) = (bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy)
        return (x + xdescent, y + ydescent)

    @allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group('legend', gid=self.get_gid())
        fontsize = renderer.points_to_pixels(self._fontsize)
        if self._mode in ['expand']:
            pad = 2 * (self.borderaxespad + self.borderpad) * fontsize
            self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)
        bbox = self._legend_box.get_window_extent(renderer)
        self.legendPatch.set_bounds(bbox.bounds)
        self.legendPatch.set_mutation_scale(fontsize)
        if self.shadow:
            Shadow(self.legendPatch, **self._shadow_props).draw(renderer)
        self.legendPatch.draw(renderer)
        self._legend_box.draw(renderer)
        renderer.close_group('legend')
        self.stale = False
    _default_handler_map = {StemContainer: legend_handler.HandlerStem(), ErrorbarContainer: legend_handler.HandlerErrorbar(), Line2D: legend_handler.HandlerLine2D(), Patch: legend_handler.HandlerPatch(), StepPatch: legend_handler.HandlerStepPatch(), LineCollection: legend_handler.HandlerLineCollection(), RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(), CircleCollection: legend_handler.HandlerCircleCollection(), BarContainer: legend_handler.HandlerPatch(update_func=legend_handler.update_from_first_child), tuple: legend_handler.HandlerTuple(), PathCollection: legend_handler.HandlerPathCollection(), PolyCollection: legend_handler.HandlerPolyCollection()}

    @classmethod
    def get_default_handler_map(cls):
        return cls._default_handler_map

    @classmethod
    def set_default_handler_map(cls, handler_map):
        cls._default_handler_map = handler_map

    @classmethod
    def update_default_handler_map(cls, handler_map):
        cls._default_handler_map.update(handler_map)

    def get_legend_handler_map(self):
        default_handler_map = self.get_default_handler_map()
        return {**default_handler_map, **self._custom_handler_map} if self._custom_handler_map else default_handler_map

    @staticmethod
    def get_legend_handler(legend_handler_map, orig_handle):
        try:
            return legend_handler_map[orig_handle]
        except (TypeError, KeyError):
            pass
        for handle_type in type(orig_handle).mro():
            try:
                return legend_handler_map[handle_type]
            except KeyError:
                pass
        return None

    def _init_legend_box(self, handles, labels, markerfirst=True):
        fontsize = self._fontsize
        text_list = []
        handle_list = []
        handles_and_labels = []
        descent = 0.35 * fontsize * (self.handleheight - 0.7)
        height = fontsize * self.handleheight - descent
        legend_handler_map = self.get_legend_handler_map()
        for (orig_handle, label) in zip(handles, labels):
            handler = self.get_legend_handler(legend_handler_map, orig_handle)
            if handler is None:
                _api.warn_external(f'Legend does not support handles for {type(orig_handle).__name__} instances.\nA proxy artist may be used instead.\nSee: https://matplotlib.org/stable/users/explain/axes/legend_guide.html#controlling-the-legend-entries')
                handle_list.append(None)
            else:
                textbox = TextArea(label, multilinebaseline=True, textprops=dict(verticalalignment='baseline', horizontalalignment='left', fontproperties=self.prop))
                handlebox = DrawingArea(width=self.handlelength * fontsize, height=height, xdescent=0.0, ydescent=descent)
                text_list.append(textbox._text)
                handle_list.append(handler.legend_artist(self, orig_handle, fontsize, handlebox))
                handles_and_labels.append((handlebox, textbox))
        columnbox = []
        for handles_and_labels_column in filter(len, np.array_split(handles_and_labels, self._ncols)):
            itemboxes = [HPacker(pad=0, sep=self.handletextpad * fontsize, children=[h, t] if markerfirst else [t, h], align='baseline') for (h, t) in handles_and_labels_column]
            alignment = 'baseline' if markerfirst else 'right'
            columnbox.append(VPacker(pad=0, sep=self.labelspacing * fontsize, align=alignment, children=itemboxes))
        mode = 'expand' if self._mode == 'expand' else 'fixed'
        sep = self.columnspacing * fontsize
        self._legend_handle_box = HPacker(pad=0, sep=sep, align='baseline', mode=mode, children=columnbox)
        self._legend_title_box = TextArea('')
        self._legend_box = VPacker(pad=self.borderpad * fontsize, sep=self.labelspacing * fontsize, align=self._alignment, children=[self._legend_title_box, self._legend_handle_box])
        self._legend_box.set_figure(self.get_figure(root=False))
        self._legend_box.axes = self.axes
        self.texts = text_list
        self.legend_handles = handle_list

    def _auto_legend_data(self):
        assert self.isaxes
        bboxes = []
        lines = []
        offsets = []
        for artist in self.parent._children:
            if isinstance(artist, Line2D):
                lines.append(artist.get_transform().transform_path(artist.get_path()))
            elif isinstance(artist, Rectangle):
                bboxes.append(artist.get_bbox().transformed(artist.get_data_transform()))
            elif isinstance(artist, Patch):
                lines.append(artist.get_transform().transform_path(artist.get_path()))
            elif isinstance(artist, PolyCollection):
                lines.extend((artist.get_transform().transform_path(path) for path in artist.get_paths()))
            elif isinstance(artist, Collection):
                (transform, transOffset, hoffsets, _) = artist._prepare_points()
                if len(hoffsets):
                    offsets.extend(transOffset.transform(hoffsets))
            elif isinstance(artist, Text):
                bboxes.append(artist.get_window_extent())
        return (bboxes, lines, offsets)

    def get_children(self):
        return [self._legend_box, self.get_frame()]

    def get_frame(self):
        return self.legendPatch

    def get_lines(self):
        return [h for h in self.legend_handles if isinstance(h, Line2D)]

    def get_patches(self):
        return silent_list('Patch', [h for h in self.legend_handles if isinstance(h, Patch)])

    def get_texts(self):
        return silent_list('Text', self.texts)

    def set_alignment(self, alignment):
        _api.check_in_list(['center', 'left', 'right'], alignment=alignment)
        self._alignment = alignment
        self._legend_box.align = alignment

    def get_alignment(self):
        return self._legend_box.align

    def set_title(self, title, prop=None):
        self._legend_title_box._text.set_text(title)
        if title:
            self._legend_title_box._text.set_visible(True)
            self._legend_title_box.set_visible(True)
        else:
            self._legend_title_box._text.set_visible(False)
            self._legend_title_box.set_visible(False)
        if prop is not None:
            self._legend_title_box._text.set_fontproperties(prop)
        self.stale = True

    def get_title(self):
        return self._legend_title_box._text

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        return self._legend_box.get_window_extent(renderer=renderer)

    def get_tightbbox(self, renderer=None):
        return self._legend_box.get_window_extent(renderer)

    def get_frame_on(self):
        return self.legendPatch.get_visible()

    def set_frame_on(self, b):
        self.legendPatch.set_visible(b)
        self.stale = True
    draw_frame = set_frame_on

    def get_bbox_to_anchor(self):
        if self._bbox_to_anchor is None:
            return self.parent.bbox
        else:
            return self._bbox_to_anchor

    def set_bbox_to_anchor(self, bbox, transform=None):
        if bbox is None:
            self._bbox_to_anchor = None
            return
        elif isinstance(bbox, BboxBase):
            self._bbox_to_anchor = bbox
        else:
            try:
                l = len(bbox)
            except TypeError as err:
                raise ValueError(f'Invalid bbox: {bbox}') from err
            if l == 2:
                bbox = [bbox[0], bbox[1], 0, 0]
            self._bbox_to_anchor = Bbox.from_bounds(*bbox)
        if transform is None:
            transform = BboxTransformTo(self.parent.bbox)
        self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor, transform)
        self.stale = True

    def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):
        return offsetbox._get_anchored_bbox(loc, bbox, parentbbox, self.borderaxespad * renderer.points_to_pixels(self._fontsize))

    def _find_best_position(self, width, height, renderer):
        assert self.isaxes
        start_time = time.perf_counter()
        (bboxes, lines, offsets) = self._auto_legend_data()
        bbox = Bbox.from_bounds(0, 0, width, height)
        candidates = []
        for idx in range(1, len(self.codes)):
            (l, b) = self._get_anchored_bbox(idx, bbox, self.get_bbox_to_anchor(), renderer)
            legendBox = Bbox.from_bounds(l, b, width, height)
            badness = sum((legendBox.count_contains(line.vertices) for line in lines)) + legendBox.count_contains(offsets) + legendBox.count_overlaps(bboxes) + sum((line.intersects_bbox(legendBox, filled=False) for line in lines))
            candidates.append((badness, idx, (l, b)))
            if badness == 0:
                break
        (_, _, (l, b)) = min(candidates)
        if self._loc_used_default and time.perf_counter() - start_time > 1:
            _api.warn_external('Creating legend with loc="best" can be slow with large amounts of data.')
        return (l, b)

    def contains(self, mouseevent):
        return self.legendPatch.contains(mouseevent)

    def set_draggable(self, state, use_blit=False, update='loc'):
        if state:
            if self._draggable is None:
                self._draggable = DraggableLegend(self, use_blit, update=update)
        else:
            if self._draggable is not None:
                self._draggable.disconnect()
            self._draggable = None
        return self._draggable

    def get_draggable(self):
        return self._draggable is not None

def _get_legend_handles(axs, legend_handler_map=None):
    handles_original = []
    for ax in axs:
        handles_original += [*(a for a in ax._children if isinstance(a, (Line2D, Patch, Collection, Text))), *ax.containers]
        if hasattr(ax, 'parasites'):
            for axx in ax.parasites:
                handles_original += [*(a for a in axx._children if isinstance(a, (Line2D, Patch, Collection, Text))), *axx.containers]
    handler_map = {**Legend.get_default_handler_map(), **(legend_handler_map or {})}
    has_handler = Legend.get_legend_handler
    for handle in handles_original:
        label = handle.get_label()
        if label != '_nolegend_' and has_handler(handler_map, handle):
            yield handle
        elif label and (not label.startswith('_')) and (not has_handler(handler_map, handle)):
            _api.warn_external(f'Legend does not support handles for {type(handle).__name__} instances.\nSee: https://matplotlib.org/stable/tutorials/intermediate/legend_guide.html#implementing-a-custom-legend-handler')
            continue

def _get_legend_handles_labels(axs, legend_handler_map=None):
    handles = []
    labels = []
    for handle in _get_legend_handles(axs, legend_handler_map):
        label = handle.get_label()
        if label and (not label.startswith('_')):
            handles.append(handle)
            labels.append(label)
    return (handles, labels)

def _parse_legend_args(axs, *args, handles=None, labels=None, **kwargs):
    log = logging.getLogger(__name__)
    handlers = kwargs.get('handler_map')
    if (handles is not None or labels is not None) and args:
        _api.warn_deprecated('3.9', message='You have mixed positional and keyword arguments, some input may be discarded.  This is deprecated since %(since)s and will become an error %(removal)s.')
    if hasattr(handles, '__len__') and hasattr(labels, '__len__') and (len(handles) != len(labels)):
        _api.warn_external(f'Mismatched number of handles and labels: len(handles) = {len(handles)} len(labels) = {len(labels)}')
    if handles and labels:
        (handles, labels) = zip(*zip(handles, labels))
    elif handles is not None and labels is None:
        labels = [handle.get_label() for handle in handles]
    elif labels is not None and handles is None:
        handles = [handle for (handle, label) in zip(_get_legend_handles(axs, handlers), labels)]
    elif len(args) == 0:
        (handles, labels) = _get_legend_handles_labels(axs, handlers)
        if not handles:
            _api.warn_external('No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.')
    elif len(args) == 1:
        (labels,) = args
        if any((isinstance(l, Artist) for l in labels)):
            raise TypeError('A single argument passed to legend() must be a list of labels, but found an Artist in there.')
        handles = [handle for (handle, label) in zip(_get_legend_handles(axs, handlers), labels)]
    elif len(args) == 2:
        (handles, labels) = args[:2]
    else:
        raise _api.nargs_error('legend', '0-2', len(args))
    return (handles, labels, kwargs)

# File: matplotlib-main/lib/matplotlib/legend_handler.py
""""""
from itertools import cycle
import numpy as np
from matplotlib import cbook
from matplotlib.lines import Line2D
from matplotlib.patches import Rectangle
import matplotlib.collections as mcoll

def update_from_first_child(tgt, src):
    first_child = next(iter(src.get_children()), None)
    if first_child is not None:
        tgt.update_from(first_child)

class HandlerBase:

    def __init__(self, xpad=0.0, ypad=0.0, update_func=None):
        (self._xpad, self._ypad) = (xpad, ypad)
        self._update_prop_func = update_func

    def _update_prop(self, legend_handle, orig_handle):
        if self._update_prop_func is None:
            self._default_update_prop(legend_handle, orig_handle)
        else:
            self._update_prop_func(legend_handle, orig_handle)

    def _default_update_prop(self, legend_handle, orig_handle):
        legend_handle.update_from(orig_handle)

    def update_prop(self, legend_handle, orig_handle, legend):
        self._update_prop(legend_handle, orig_handle)
        legend._set_artist_props(legend_handle)
        legend_handle.set_clip_box(None)
        legend_handle.set_clip_path(None)

    def adjust_drawing_area(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize):
        xdescent = xdescent - self._xpad * fontsize
        ydescent = ydescent - self._ypad * fontsize
        width = width - self._xpad * fontsize
        height = height - self._ypad * fontsize
        return (xdescent, ydescent, width, height)

    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
        (xdescent, ydescent, width, height) = self.adjust_drawing_area(legend, orig_handle, handlebox.xdescent, handlebox.ydescent, handlebox.width, handlebox.height, fontsize)
        artists = self.create_artists(legend, orig_handle, xdescent, ydescent, width, height, fontsize, handlebox.get_transform())
        for a in artists:
            handlebox.add_artist(a)
        return artists[0]

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        raise NotImplementedError('Derived must override')

class HandlerNpoints(HandlerBase):

    def __init__(self, marker_pad=0.3, numpoints=None, **kwargs):
        super().__init__(**kwargs)
        self._numpoints = numpoints
        self._marker_pad = marker_pad

    def get_numpoints(self, legend):
        if self._numpoints is None:
            return legend.numpoints
        else:
            return self._numpoints

    def get_xdata(self, legend, xdescent, ydescent, width, height, fontsize):
        numpoints = self.get_numpoints(legend)
        if numpoints > 1:
            pad = self._marker_pad * fontsize
            xdata = np.linspace(-xdescent + pad, -xdescent + width - pad, numpoints)
            xdata_marker = xdata
        else:
            xdata = [-xdescent, -xdescent + width]
            xdata_marker = [-xdescent + 0.5 * width]
        return (xdata, xdata_marker)

class HandlerNpointsYoffsets(HandlerNpoints):

    def __init__(self, numpoints=None, yoffsets=None, **kwargs):
        super().__init__(numpoints=numpoints, **kwargs)
        self._yoffsets = yoffsets

    def get_ydata(self, legend, xdescent, ydescent, width, height, fontsize):
        if self._yoffsets is None:
            ydata = height * legend._scatteryoffsets
        else:
            ydata = height * np.asarray(self._yoffsets)
        return ydata

class HandlerLine2DCompound(HandlerNpoints):

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        ydata = np.full_like(xdata, (height - ydescent) / 2)
        legline = Line2D(xdata, ydata)
        self.update_prop(legline, orig_handle, legend)
        legline.set_drawstyle('default')
        legline.set_marker('')
        legline_marker = Line2D(xdata_marker, ydata[:len(xdata_marker)])
        self.update_prop(legline_marker, orig_handle, legend)
        legline_marker.set_linestyle('None')
        if legend.markerscale != 1:
            newsz = legline_marker.get_markersize() * legend.markerscale
            legline_marker.set_markersize(newsz)
        legline._legmarker = legline_marker
        legline.set_transform(trans)
        legline_marker.set_transform(trans)
        return [legline, legline_marker]

class HandlerLine2D(HandlerNpoints):

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        markevery = None
        if self.get_numpoints(legend) == 1:
            xdata = np.linspace(xdata[0], xdata[-1], 3)
            markevery = [1]
        ydata = np.full_like(xdata, (height - ydescent) / 2)
        legline = Line2D(xdata, ydata, markevery=markevery)
        self.update_prop(legline, orig_handle, legend)
        if legend.markerscale != 1:
            newsz = legline.get_markersize() * legend.markerscale
            legline.set_markersize(newsz)
        legline.set_transform(trans)
        return [legline]

class HandlerPatch(HandlerBase):

    def __init__(self, patch_func=None, **kwargs):
        super().__init__(**kwargs)
        self._patch_func = patch_func

    def _create_patch(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize):
        if self._patch_func is None:
            p = Rectangle(xy=(-xdescent, -ydescent), width=width, height=height)
        else:
            p = self._patch_func(legend=legend, orig_handle=orig_handle, xdescent=xdescent, ydescent=ydescent, width=width, height=height, fontsize=fontsize)
        return p

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        p = self._create_patch(legend, orig_handle, xdescent, ydescent, width, height, fontsize)
        self.update_prop(p, orig_handle, legend)
        p.set_transform(trans)
        return [p]

class HandlerStepPatch(HandlerBase):

    @staticmethod
    def _create_patch(orig_handle, xdescent, ydescent, width, height):
        return Rectangle(xy=(-xdescent, -ydescent), width=width, height=height, color=orig_handle.get_facecolor())

    @staticmethod
    def _create_line(orig_handle, width, height):
        legline = Line2D([0, width], [height / 2, height / 2], color=orig_handle.get_edgecolor(), linestyle=orig_handle.get_linestyle(), linewidth=orig_handle.get_linewidth())
        legline.set_drawstyle('default')
        legline.set_marker('')
        return legline

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        if orig_handle.get_fill() or orig_handle.get_hatch() is not None:
            p = self._create_patch(orig_handle, xdescent, ydescent, width, height)
            self.update_prop(p, orig_handle, legend)
        else:
            p = self._create_line(orig_handle, width, height)
        p.set_transform(trans)
        return [p]

class HandlerLineCollection(HandlerLine2D):

    def get_numpoints(self, legend):
        if self._numpoints is None:
            return legend.scatterpoints
        else:
            return self._numpoints

    def _default_update_prop(self, legend_handle, orig_handle):
        lw = orig_handle.get_linewidths()[0]
        dashes = orig_handle._us_linestyles[0]
        color = orig_handle.get_colors()[0]
        legend_handle.set_color(color)
        legend_handle.set_linestyle(dashes)
        legend_handle.set_linewidth(lw)

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        ydata = np.full_like(xdata, (height - ydescent) / 2)
        legline = Line2D(xdata, ydata)
        self.update_prop(legline, orig_handle, legend)
        legline.set_transform(trans)
        return [legline]

class HandlerRegularPolyCollection(HandlerNpointsYoffsets):

    def __init__(self, yoffsets=None, sizes=None, **kwargs):
        super().__init__(yoffsets=yoffsets, **kwargs)
        self._sizes = sizes

    def get_numpoints(self, legend):
        if self._numpoints is None:
            return legend.scatterpoints
        else:
            return self._numpoints

    def get_sizes(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize):
        if self._sizes is None:
            handle_sizes = orig_handle.get_sizes()
            if not len(handle_sizes):
                handle_sizes = [1]
            size_max = max(handle_sizes) * legend.markerscale ** 2
            size_min = min(handle_sizes) * legend.markerscale ** 2
            numpoints = self.get_numpoints(legend)
            if numpoints < 4:
                sizes = [0.5 * (size_max + size_min), size_max, size_min][:numpoints]
            else:
                rng = size_max - size_min
                sizes = rng * np.linspace(0, 1, numpoints) + size_min
        else:
            sizes = self._sizes
        return sizes

    def update_prop(self, legend_handle, orig_handle, legend):
        self._update_prop(legend_handle, orig_handle)
        legend_handle.set_figure(legend.get_figure(root=False))
        legend_handle.set_clip_box(None)
        legend_handle.set_clip_path(None)

    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
        return type(orig_handle)(orig_handle.get_numsides(), rotation=orig_handle.get_rotation(), sizes=sizes, offsets=offsets, offset_transform=offset_transform)

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        ydata = self.get_ydata(legend, xdescent, ydescent, width, height, fontsize)
        sizes = self.get_sizes(legend, orig_handle, xdescent, ydescent, width, height, fontsize)
        p = self.create_collection(orig_handle, sizes, offsets=list(zip(xdata_marker, ydata)), offset_transform=trans)
        self.update_prop(p, orig_handle, legend)
        p.set_offset_transform(trans)
        return [p]

class HandlerPathCollection(HandlerRegularPolyCollection):

    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
        return type(orig_handle)([orig_handle.get_paths()[0]], sizes=sizes, offsets=offsets, offset_transform=offset_transform)

class HandlerCircleCollection(HandlerRegularPolyCollection):

    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
        return type(orig_handle)(sizes, offsets=offsets, offset_transform=offset_transform)

class HandlerErrorbar(HandlerLine2D):

    def __init__(self, xerr_size=0.5, yerr_size=None, marker_pad=0.3, numpoints=None, **kwargs):
        self._xerr_size = xerr_size
        self._yerr_size = yerr_size
        super().__init__(marker_pad=marker_pad, numpoints=numpoints, **kwargs)

    def get_err_size(self, legend, xdescent, ydescent, width, height, fontsize):
        xerr_size = self._xerr_size * fontsize
        if self._yerr_size is None:
            yerr_size = xerr_size
        else:
            yerr_size = self._yerr_size * fontsize
        return (xerr_size, yerr_size)

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (plotlines, caplines, barlinecols) = orig_handle
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        ydata = np.full_like(xdata, (height - ydescent) / 2)
        legline = Line2D(xdata, ydata)
        xdata_marker = np.asarray(xdata_marker)
        ydata_marker = np.asarray(ydata[:len(xdata_marker)])
        (xerr_size, yerr_size) = self.get_err_size(legend, xdescent, ydescent, width, height, fontsize)
        legline_marker = Line2D(xdata_marker, ydata_marker)
        if plotlines is None:
            legline.set_visible(False)
            legline_marker.set_visible(False)
        else:
            self.update_prop(legline, plotlines, legend)
            legline.set_drawstyle('default')
            legline.set_marker('none')
            self.update_prop(legline_marker, plotlines, legend)
            legline_marker.set_linestyle('None')
            if legend.markerscale != 1:
                newsz = legline_marker.get_markersize() * legend.markerscale
                legline_marker.set_markersize(newsz)
        handle_barlinecols = []
        handle_caplines = []
        if orig_handle.has_xerr:
            verts = [((x - xerr_size, y), (x + xerr_size, y)) for (x, y) in zip(xdata_marker, ydata_marker)]
            coll = mcoll.LineCollection(verts)
            self.update_prop(coll, barlinecols[0], legend)
            handle_barlinecols.append(coll)
            if caplines:
                capline_left = Line2D(xdata_marker - xerr_size, ydata_marker)
                capline_right = Line2D(xdata_marker + xerr_size, ydata_marker)
                self.update_prop(capline_left, caplines[0], legend)
                self.update_prop(capline_right, caplines[0], legend)
                capline_left.set_marker('|')
                capline_right.set_marker('|')
                handle_caplines.append(capline_left)
                handle_caplines.append(capline_right)
        if orig_handle.has_yerr:
            verts = [((x, y - yerr_size), (x, y + yerr_size)) for (x, y) in zip(xdata_marker, ydata_marker)]
            coll = mcoll.LineCollection(verts)
            self.update_prop(coll, barlinecols[0], legend)
            handle_barlinecols.append(coll)
            if caplines:
                capline_left = Line2D(xdata_marker, ydata_marker - yerr_size)
                capline_right = Line2D(xdata_marker, ydata_marker + yerr_size)
                self.update_prop(capline_left, caplines[0], legend)
                self.update_prop(capline_right, caplines[0], legend)
                capline_left.set_marker('_')
                capline_right.set_marker('_')
                handle_caplines.append(capline_left)
                handle_caplines.append(capline_right)
        artists = [*handle_barlinecols, *handle_caplines, legline, legline_marker]
        for artist in artists:
            artist.set_transform(trans)
        return artists

class HandlerStem(HandlerNpointsYoffsets):

    def __init__(self, marker_pad=0.3, numpoints=None, bottom=None, yoffsets=None, **kwargs):
        super().__init__(marker_pad=marker_pad, numpoints=numpoints, yoffsets=yoffsets, **kwargs)
        self._bottom = bottom

    def get_ydata(self, legend, xdescent, ydescent, width, height, fontsize):
        if self._yoffsets is None:
            ydata = height * (0.5 * legend._scatteryoffsets + 0.5)
        else:
            ydata = height * np.asarray(self._yoffsets)
        return ydata

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        (markerline, stemlines, baseline) = orig_handle
        using_linecoll = isinstance(stemlines, mcoll.LineCollection)
        (xdata, xdata_marker) = self.get_xdata(legend, xdescent, ydescent, width, height, fontsize)
        ydata = self.get_ydata(legend, xdescent, ydescent, width, height, fontsize)
        if self._bottom is None:
            bottom = 0.0
        else:
            bottom = self._bottom
        leg_markerline = Line2D(xdata_marker, ydata[:len(xdata_marker)])
        self.update_prop(leg_markerline, markerline, legend)
        leg_stemlines = [Line2D([x, x], [bottom, y]) for (x, y) in zip(xdata_marker, ydata)]
        if using_linecoll:
            with cbook._setattr_cm(self, _update_prop_func=self._copy_collection_props):
                for line in leg_stemlines:
                    self.update_prop(line, stemlines, legend)
        else:
            for (lm, m) in zip(leg_stemlines, stemlines):
                self.update_prop(lm, m, legend)
        leg_baseline = Line2D([np.min(xdata), np.max(xdata)], [bottom, bottom])
        self.update_prop(leg_baseline, baseline, legend)
        artists = [*leg_stemlines, leg_baseline, leg_markerline]
        for artist in artists:
            artist.set_transform(trans)
        return artists

    def _copy_collection_props(self, legend_handle, orig_handle):
        legend_handle.set_color(orig_handle.get_color()[0])
        legend_handle.set_linestyle(orig_handle.get_linestyle()[0])

class HandlerTuple(HandlerBase):

    def __init__(self, ndivide=1, pad=None, **kwargs):
        self._ndivide = ndivide
        self._pad = pad
        super().__init__(**kwargs)

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        handler_map = legend.get_legend_handler_map()
        if self._ndivide is None:
            ndivide = len(orig_handle)
        else:
            ndivide = self._ndivide
        if self._pad is None:
            pad = legend.borderpad * fontsize
        else:
            pad = self._pad * fontsize
        if ndivide > 1:
            width = (width - pad * (ndivide - 1)) / ndivide
        xds_cycle = cycle(xdescent - (width + pad) * np.arange(ndivide))
        a_list = []
        for handle1 in orig_handle:
            handler = legend.get_legend_handler(handler_map, handle1)
            _a_list = handler.create_artists(legend, handle1, next(xds_cycle), ydescent, width, height, fontsize, trans)
            a_list.extend(_a_list)
        return a_list

class HandlerPolyCollection(HandlerBase):

    def _update_prop(self, legend_handle, orig_handle):

        def first_color(colors):
            if colors.size == 0:
                return (0, 0, 0, 0)
            return tuple(colors[0])

        def get_first(prop_array):
            if len(prop_array):
                return prop_array[0]
            else:
                return None
        legend_handle._facecolor = first_color(orig_handle.get_facecolor())
        legend_handle._edgecolor = first_color(orig_handle.get_edgecolor())
        legend_handle._original_facecolor = orig_handle._original_facecolor
        legend_handle._original_edgecolor = orig_handle._original_edgecolor
        legend_handle._fill = orig_handle.get_fill()
        legend_handle._hatch = orig_handle.get_hatch()
        legend_handle._hatch_color = orig_handle._hatch_color
        legend_handle.set_linewidth(get_first(orig_handle.get_linewidths()))
        legend_handle.set_linestyle(get_first(orig_handle.get_linestyles()))
        legend_handle.set_transform(get_first(orig_handle.get_transforms()))
        legend_handle.set_figure(orig_handle.get_figure())

    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        p = Rectangle(xy=(-xdescent, -ydescent), width=width, height=height)
        self.update_prop(p, orig_handle, legend)
        p.set_transform(trans)
        return [p]

# File: matplotlib-main/lib/matplotlib/lines.py
""""""
import copy
from numbers import Integral, Number, Real
import logging
import numpy as np
import matplotlib as mpl
from . import _api, cbook, colors as mcolors, _docstring
from .artist import Artist, allow_rasterization
from .cbook import _to_unmasked_float_array, ls_mapper, ls_mapper_r, STEP_LOOKUP_MAP
from .markers import MarkerStyle
from .path import Path
from .transforms import Bbox, BboxTransformTo, TransformedPath
from ._enums import JoinStyle, CapStyle
from . import _path
from .markers import CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN, CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE, TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN
_log = logging.getLogger(__name__)

def _get_dash_pattern(style):
    if isinstance(style, str):
        style = ls_mapper.get(style, style)
    if style in ['solid', 'None']:
        offset = 0
        dashes = None
    elif style in ['dashed', 'dashdot', 'dotted']:
        offset = 0
        dashes = tuple(mpl.rcParams[f'lines.{style}_pattern'])
    elif isinstance(style, tuple):
        (offset, dashes) = style
        if offset is None:
            raise ValueError(f'Unrecognized linestyle: {style!r}')
    else:
        raise ValueError(f'Unrecognized linestyle: {style!r}')
    if dashes is not None:
        dsum = sum(dashes)
        if dsum:
            offset %= dsum
    return (offset, dashes)

def _get_inverse_dash_pattern(offset, dashes):
    gaps = dashes[-1:] + dashes[:-1]
    offset_gaps = offset + dashes[-1]
    return (offset_gaps, gaps)

def _scale_dashes(offset, dashes, lw):
    if not mpl.rcParams['lines.scale_dashes']:
        return (offset, dashes)
    scaled_offset = offset * lw
    scaled_dashes = [x * lw if x is not None else None for x in dashes] if dashes is not None else None
    return (scaled_offset, scaled_dashes)

def segment_hits(cx, cy, x, y, radius):
    if len(x) <= 1:
        (res,) = np.nonzero((cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2)
        return res
    (xr, yr) = (x[:-1], y[:-1])
    (dx, dy) = (x[1:] - xr, y[1:] - yr)
    Lnorm_sq = dx ** 2 + dy ** 2
    u = ((cx - xr) * dx + (cy - yr) * dy) / Lnorm_sq
    candidates = (u >= 0) & (u <= 1)
    point_hits = (cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2
    candidates = candidates & ~(point_hits[:-1] | point_hits[1:])
    (px, py) = (xr + u * dx, yr + u * dy)
    line_hits = (cx - px) ** 2 + (cy - py) ** 2 <= radius ** 2
    line_hits = line_hits & candidates
    (points,) = point_hits.ravel().nonzero()
    (lines,) = line_hits.ravel().nonzero()
    return np.concatenate((points, lines))

def _mark_every_path(markevery, tpath, affine, ax):
    (codes, verts) = (tpath.codes, tpath.vertices)

    def _slice_or_none(in_v, slc):
        if in_v is None:
            return None
        return in_v[slc]
    if isinstance(markevery, Integral):
        markevery = (0, markevery)
    elif isinstance(markevery, Real):
        markevery = (0.0, markevery)
    if isinstance(markevery, tuple):
        if len(markevery) != 2:
            raise ValueError(f'`markevery` is a tuple but its len is not 2; markevery={markevery}')
        (start, step) = markevery
        if isinstance(step, Integral):
            if not isinstance(start, Integral):
                raise ValueError(f'`markevery` is a tuple with len 2 and second element is an int, but the first element is not an int; markevery={markevery}')
            return Path(verts[slice(start, None, step)], _slice_or_none(codes, slice(start, None, step)))
        elif isinstance(step, Real):
            if not isinstance(start, Real):
                raise ValueError(f'`markevery` is a tuple with len 2 and second element is a float, but the first element is not a float or an int; markevery={markevery}')
            if ax is None:
                raise ValueError('markevery is specified relative to the Axes size, but the line does not have a Axes as parent')
            fin = np.isfinite(verts).all(axis=1)
            fverts = verts[fin]
            disp_coords = affine.transform(fverts)
            delta = np.empty((len(disp_coords), 2))
            delta[0, :] = 0
            delta[1:, :] = disp_coords[1:, :] - disp_coords[:-1, :]
            delta = np.hypot(*delta.T).cumsum()
            ((x0, y0), (x1, y1)) = ax.transAxes.transform([[0, 0], [1, 1]])
            scale = np.hypot(x1 - x0, y1 - y0)
            marker_delta = np.arange(start * scale, delta[-1], step * scale)
            inds = np.abs(delta[np.newaxis, :] - marker_delta[:, np.newaxis])
            inds = inds.argmin(axis=1)
            inds = np.unique(inds)
            return Path(fverts[inds], _slice_or_none(codes, inds))
        else:
            raise ValueError(f'markevery={markevery!r} is a tuple with len 2, but its second element is not an int or a float')
    elif isinstance(markevery, slice):
        return Path(verts[markevery], _slice_or_none(codes, markevery))
    elif np.iterable(markevery):
        try:
            return Path(verts[markevery], _slice_or_none(codes, markevery))
        except (ValueError, IndexError) as err:
            raise ValueError(f'markevery={markevery!r} is iterable but not a valid numpy fancy index') from err
    else:
        raise ValueError(f'markevery={markevery!r} is not a recognized value')

@_docstring.interpd
@_api.define_aliases({'antialiased': ['aa'], 'color': ['c'], 'drawstyle': ['ds'], 'linestyle': ['ls'], 'linewidth': ['lw'], 'markeredgecolor': ['mec'], 'markeredgewidth': ['mew'], 'markerfacecolor': ['mfc'], 'markerfacecoloralt': ['mfcalt'], 'markersize': ['ms']})
class Line2D(Artist):
    lineStyles = _lineStyles = {'-': '_draw_solid', '--': '_draw_dashed', '-.': '_draw_dash_dot', ':': '_draw_dotted', 'None': '_draw_nothing', ' ': '_draw_nothing', '': '_draw_nothing'}
    _drawStyles_l = {'default': '_draw_lines', 'steps-mid': '_draw_steps_mid', 'steps-pre': '_draw_steps_pre', 'steps-post': '_draw_steps_post'}
    _drawStyles_s = {'steps': '_draw_steps_pre'}
    drawStyles = {**_drawStyles_l, **_drawStyles_s}
    drawStyleKeys = [*_drawStyles_l, *_drawStyles_s]
    markers = MarkerStyle.markers
    filled_markers = MarkerStyle.filled_markers
    fillStyles = MarkerStyle.fillstyles
    zorder = 2
    _subslice_optim_min_size = 1000

    def __str__(self):
        if self._label != '':
            return f'Line2D({self._label})'
        elif self._x is None:
            return 'Line2D()'
        elif len(self._x) > 3:
            return 'Line2D(({:g},{:g}),({:g},{:g}),...,({:g},{:g}))'.format(self._x[0], self._y[0], self._x[1], self._y[1], self._x[-1], self._y[-1])
        else:
            return 'Line2D(%s)' % ','.join(map('({:g},{:g})'.format, self._x, self._y))

    def __init__(self, xdata, ydata, *, linewidth=None, linestyle=None, color=None, gapcolor=None, marker=None, markersize=None, markeredgewidth=None, markeredgecolor=None, markerfacecolor=None, markerfacecoloralt='none', fillstyle=None, antialiased=None, dash_capstyle=None, solid_capstyle=None, dash_joinstyle=None, solid_joinstyle=None, pickradius=5, drawstyle=None, markevery=None, **kwargs):
        super().__init__()
        if not np.iterable(xdata):
            raise RuntimeError('xdata must be a sequence')
        if not np.iterable(ydata):
            raise RuntimeError('ydata must be a sequence')
        if linewidth is None:
            linewidth = mpl.rcParams['lines.linewidth']
        if linestyle is None:
            linestyle = mpl.rcParams['lines.linestyle']
        if marker is None:
            marker = mpl.rcParams['lines.marker']
        if color is None:
            color = mpl.rcParams['lines.color']
        if markersize is None:
            markersize = mpl.rcParams['lines.markersize']
        if antialiased is None:
            antialiased = mpl.rcParams['lines.antialiased']
        if dash_capstyle is None:
            dash_capstyle = mpl.rcParams['lines.dash_capstyle']
        if dash_joinstyle is None:
            dash_joinstyle = mpl.rcParams['lines.dash_joinstyle']
        if solid_capstyle is None:
            solid_capstyle = mpl.rcParams['lines.solid_capstyle']
        if solid_joinstyle is None:
            solid_joinstyle = mpl.rcParams['lines.solid_joinstyle']
        if drawstyle is None:
            drawstyle = 'default'
        self._dashcapstyle = None
        self._dashjoinstyle = None
        self._solidjoinstyle = None
        self._solidcapstyle = None
        self.set_dash_capstyle(dash_capstyle)
        self.set_dash_joinstyle(dash_joinstyle)
        self.set_solid_capstyle(solid_capstyle)
        self.set_solid_joinstyle(solid_joinstyle)
        self._linestyles = None
        self._drawstyle = None
        self._linewidth = linewidth
        self._unscaled_dash_pattern = (0, None)
        self._dash_pattern = (0, None)
        self.set_linewidth(linewidth)
        self.set_linestyle(linestyle)
        self.set_drawstyle(drawstyle)
        self._color = None
        self.set_color(color)
        if marker is None:
            marker = 'none'
        if not isinstance(marker, MarkerStyle):
            self._marker = MarkerStyle(marker, fillstyle)
        else:
            self._marker = marker
        self._gapcolor = None
        self.set_gapcolor(gapcolor)
        self._markevery = None
        self._markersize = None
        self._antialiased = None
        self.set_markevery(markevery)
        self.set_antialiased(antialiased)
        self.set_markersize(markersize)
        self._markeredgecolor = None
        self._markeredgewidth = None
        self._markerfacecolor = None
        self._markerfacecoloralt = None
        self.set_markerfacecolor(markerfacecolor)
        self.set_markerfacecoloralt(markerfacecoloralt)
        self.set_markeredgecolor(markeredgecolor)
        self.set_markeredgewidth(markeredgewidth)
        self._internal_update(kwargs)
        self.pickradius = pickradius
        self.ind_offset = 0
        if isinstance(self._picker, Number) and (not isinstance(self._picker, bool)):
            self._pickradius = self._picker
        self._xorig = np.asarray([])
        self._yorig = np.asarray([])
        self._invalidx = True
        self._invalidy = True
        self._x = None
        self._y = None
        self._xy = None
        self._path = None
        self._transformed_path = None
        self._subslice = False
        self._x_filled = None
        self.set_data(xdata, ydata)

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        if self._invalidy or self._invalidx:
            self.recache()
        if len(self._xy) == 0:
            return (False, {})
        transformed_path = self._get_transformed_path()
        (path, affine) = transformed_path.get_transformed_path_and_affine()
        path = affine.transform_path(path)
        xy = path.vertices
        xt = xy[:, 0]
        yt = xy[:, 1]
        fig = self.get_figure(root=True)
        if fig is None:
            _log.warning('no figure set when check if mouse is on line')
            pixels = self._pickradius
        else:
            pixels = fig.dpi / 72.0 * self._pickradius
        with np.errstate(all='ignore'):
            if self._linestyle in ['None', None]:
                (ind,) = np.nonzero((xt - mouseevent.x) ** 2 + (yt - mouseevent.y) ** 2 <= pixels ** 2)
            else:
                ind = segment_hits(mouseevent.x, mouseevent.y, xt, yt, pixels)
                if self._drawstyle.startswith('steps'):
                    ind //= 2
        ind += self.ind_offset
        return (len(ind) > 0, dict(ind=ind))

    def get_pickradius(self):
        return self._pickradius

    def set_pickradius(self, pickradius):
        if not isinstance(pickradius, Real) or pickradius < 0:
            raise ValueError('pick radius should be a distance')
        self._pickradius = pickradius
    pickradius = property(get_pickradius, set_pickradius)

    def get_fillstyle(self):
        return self._marker.get_fillstyle()

    def set_fillstyle(self, fs):
        self.set_marker(MarkerStyle(self._marker.get_marker(), fs))
        self.stale = True

    def set_markevery(self, every):
        self._markevery = every
        self.stale = True

    def get_markevery(self):
        return self._markevery

    def set_picker(self, p):
        if not callable(p):
            self.set_pickradius(p)
        self._picker = p

    def get_bbox(self):
        bbox = Bbox([[0, 0], [0, 0]])
        bbox.update_from_data_xy(self.get_xydata())
        return bbox

    def get_window_extent(self, renderer=None):
        bbox = Bbox([[0, 0], [0, 0]])
        trans_data_to_xy = self.get_transform().transform
        bbox.update_from_data_xy(trans_data_to_xy(self.get_xydata()), ignore=True)
        if self._marker:
            ms = self._markersize / 72.0 * self.get_figure(root=True).dpi * 0.5
            bbox = bbox.padded(ms)
        return bbox

    def set_data(self, *args):
        if len(args) == 1:
            ((x, y),) = args
        else:
            (x, y) = args
        self.set_xdata(x)
        self.set_ydata(y)

    def recache_always(self):
        self.recache(always=True)

    def recache(self, always=False):
        if always or self._invalidx:
            xconv = self.convert_xunits(self._xorig)
            x = _to_unmasked_float_array(xconv).ravel()
        else:
            x = self._x
        if always or self._invalidy:
            yconv = self.convert_yunits(self._yorig)
            y = _to_unmasked_float_array(yconv).ravel()
        else:
            y = self._y
        self._xy = np.column_stack(np.broadcast_arrays(x, y)).astype(float)
        (self._x, self._y) = self._xy.T
        self._subslice = False
        if self.axes and len(x) > self._subslice_optim_min_size and _path.is_sorted_and_has_non_nan(x) and (self.axes.name == 'rectilinear') and (self.axes.get_xscale() == 'linear') and (self._markevery is None) and self.get_clip_on() and (self.get_transform() == self.axes.transData):
            self._subslice = True
            nanmask = np.isnan(x)
            if nanmask.any():
                self._x_filled = self._x.copy()
                indices = np.arange(len(x))
                self._x_filled[nanmask] = np.interp(indices[nanmask], indices[~nanmask], self._x[~nanmask])
            else:
                self._x_filled = self._x
        if self._path is not None:
            interpolation_steps = self._path._interpolation_steps
        else:
            interpolation_steps = 1
        xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy.T)
        self._path = Path(np.asarray(xy).T, _interpolation_steps=interpolation_steps)
        self._transformed_path = None
        self._invalidx = False
        self._invalidy = False

    def _transform_path(self, subslice=None):
        if subslice is not None:
            xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy[subslice, :].T)
            _path = Path(np.asarray(xy).T, _interpolation_steps=self._path._interpolation_steps)
        else:
            _path = self._path
        self._transformed_path = TransformedPath(_path, self.get_transform())

    def _get_transformed_path(self):
        if self._transformed_path is None:
            self._transform_path()
        return self._transformed_path

    def set_transform(self, t):
        self._invalidx = True
        self._invalidy = True
        super().set_transform(t)

    @allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        if self._invalidy or self._invalidx:
            self.recache()
        self.ind_offset = 0
        if self._subslice and self.axes:
            (x0, x1) = self.axes.get_xbound()
            i0 = self._x_filled.searchsorted(x0, 'left')
            i1 = self._x_filled.searchsorted(x1, 'right')
            subslice = slice(max(i0 - 1, 0), i1 + 1)
            self.ind_offset = subslice.start
            self._transform_path(subslice)
        else:
            subslice = None
        if self.get_path_effects():
            from matplotlib.patheffects import PathEffectRenderer
            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
        renderer.open_group('line2d', self.get_gid())
        if self._lineStyles[self._linestyle] != '_draw_nothing':
            (tpath, affine) = self._get_transformed_path().get_transformed_path_and_affine()
            if len(tpath.vertices):
                gc = renderer.new_gc()
                self._set_gc_clip(gc)
                gc.set_url(self.get_url())
                gc.set_antialiased(self._antialiased)
                gc.set_linewidth(self._linewidth)
                if self.is_dashed():
                    cap = self._dashcapstyle
                    join = self._dashjoinstyle
                else:
                    cap = self._solidcapstyle
                    join = self._solidjoinstyle
                gc.set_joinstyle(join)
                gc.set_capstyle(cap)
                gc.set_snap(self.get_snap())
                if self.get_sketch_params() is not None:
                    gc.set_sketch_params(*self.get_sketch_params())
                if self.is_dashed() and self._gapcolor is not None:
                    lc_rgba = mcolors.to_rgba(self._gapcolor, self._alpha)
                    gc.set_foreground(lc_rgba, isRGBA=True)
                    (offset_gaps, gaps) = _get_inverse_dash_pattern(*self._dash_pattern)
                    gc.set_dashes(offset_gaps, gaps)
                    renderer.draw_path(gc, tpath, affine.frozen())
                lc_rgba = mcolors.to_rgba(self._color, self._alpha)
                gc.set_foreground(lc_rgba, isRGBA=True)
                gc.set_dashes(*self._dash_pattern)
                renderer.draw_path(gc, tpath, affine.frozen())
                gc.restore()
        if self._marker and self._markersize > 0:
            gc = renderer.new_gc()
            self._set_gc_clip(gc)
            gc.set_url(self.get_url())
            gc.set_linewidth(self._markeredgewidth)
            gc.set_antialiased(self._antialiased)
            ec_rgba = mcolors.to_rgba(self.get_markeredgecolor(), self._alpha)
            fc_rgba = mcolors.to_rgba(self._get_markerfacecolor(), self._alpha)
            fcalt_rgba = mcolors.to_rgba(self._get_markerfacecolor(alt=True), self._alpha)
            if cbook._str_equal(self._markeredgecolor, 'auto') and (not cbook._str_lower_equal(self.get_markerfacecolor(), 'none')):
                ec_rgba = ec_rgba[:3] + (fc_rgba[3],)
            gc.set_foreground(ec_rgba, isRGBA=True)
            if self.get_sketch_params() is not None:
                (scale, length, randomness) = self.get_sketch_params()
                gc.set_sketch_params(scale / 2, length / 2, 2 * randomness)
            marker = self._marker
            if self.get_drawstyle() != 'default':
                with cbook._setattr_cm(self, _drawstyle='default', _transformed_path=None):
                    self.recache()
                    self._transform_path(subslice)
                    (tpath, affine) = self._get_transformed_path().get_transformed_points_and_affine()
            else:
                (tpath, affine) = self._get_transformed_path().get_transformed_points_and_affine()
            if len(tpath.vertices):
                markevery = self.get_markevery()
                if markevery is not None:
                    subsampled = _mark_every_path(markevery, tpath, affine, self.axes)
                else:
                    subsampled = tpath
                snap = marker.get_snap_threshold()
                if isinstance(snap, Real):
                    snap = renderer.points_to_pixels(self._markersize) >= snap
                gc.set_snap(snap)
                gc.set_joinstyle(marker.get_joinstyle())
                gc.set_capstyle(marker.get_capstyle())
                marker_path = marker.get_path()
                marker_trans = marker.get_transform()
                w = renderer.points_to_pixels(self._markersize)
                if cbook._str_equal(marker.get_marker(), ','):
                    gc.set_linewidth(0)
                else:
                    marker_trans = marker_trans.scale(w)
                renderer.draw_markers(gc, marker_path, marker_trans, subsampled, affine.frozen(), fc_rgba)
                alt_marker_path = marker.get_alt_path()
                if alt_marker_path:
                    alt_marker_trans = marker.get_alt_transform()
                    alt_marker_trans = alt_marker_trans.scale(w)
                    renderer.draw_markers(gc, alt_marker_path, alt_marker_trans, subsampled, affine.frozen(), fcalt_rgba)
            gc.restore()
        renderer.close_group('line2d')
        self.stale = False

    def get_antialiased(self):
        return self._antialiased

    def get_color(self):
        return self._color

    def get_drawstyle(self):
        return self._drawstyle

    def get_gapcolor(self):
        return self._gapcolor

    def get_linestyle(self):
        return self._linestyle

    def get_linewidth(self):
        return self._linewidth

    def get_marker(self):
        return self._marker.get_marker()

    def get_markeredgecolor(self):
        mec = self._markeredgecolor
        if cbook._str_equal(mec, 'auto'):
            if mpl.rcParams['_internal.classic_mode']:
                if self._marker.get_marker() in ('.', ','):
                    return self._color
                if self._marker.is_filled() and self._marker.get_fillstyle() != 'none':
                    return 'k'
            return self._color
        else:
            return mec

    def get_markeredgewidth(self):
        return self._markeredgewidth

    def _get_markerfacecolor(self, alt=False):
        if self._marker.get_fillstyle() == 'none':
            return 'none'
        fc = self._markerfacecoloralt if alt else self._markerfacecolor
        if cbook._str_lower_equal(fc, 'auto'):
            return self._color
        else:
            return fc

    def get_markerfacecolor(self):
        return self._get_markerfacecolor(alt=False)

    def get_markerfacecoloralt(self):
        return self._get_markerfacecolor(alt=True)

    def get_markersize(self):
        return self._markersize

    def get_data(self, orig=True):
        return (self.get_xdata(orig=orig), self.get_ydata(orig=orig))

    def get_xdata(self, orig=True):
        if orig:
            return self._xorig
        if self._invalidx:
            self.recache()
        return self._x

    def get_ydata(self, orig=True):
        if orig:
            return self._yorig
        if self._invalidy:
            self.recache()
        return self._y

    def get_path(self):
        if self._invalidy or self._invalidx:
            self.recache()
        return self._path

    def get_xydata(self):
        if self._invalidy or self._invalidx:
            self.recache()
        return self._xy

    def set_antialiased(self, b):
        if self._antialiased != b:
            self.stale = True
        self._antialiased = b

    def set_color(self, color):
        mcolors._check_color_like(color=color)
        self._color = color
        self.stale = True

    def set_drawstyle(self, drawstyle):
        if drawstyle is None:
            drawstyle = 'default'
        _api.check_in_list(self.drawStyles, drawstyle=drawstyle)
        if self._drawstyle != drawstyle:
            self.stale = True
            self._invalidx = True
        self._drawstyle = drawstyle

    def set_gapcolor(self, gapcolor):
        if gapcolor is not None:
            mcolors._check_color_like(color=gapcolor)
        self._gapcolor = gapcolor
        self.stale = True

    def set_linewidth(self, w):
        w = float(w)
        if self._linewidth != w:
            self.stale = True
        self._linewidth = w
        self._dash_pattern = _scale_dashes(*self._unscaled_dash_pattern, w)

    def set_linestyle(self, ls):
        if isinstance(ls, str):
            if ls in [' ', '', 'none']:
                ls = 'None'
            _api.check_in_list([*self._lineStyles, *ls_mapper_r], ls=ls)
            if ls not in self._lineStyles:
                ls = ls_mapper_r[ls]
            self._linestyle = ls
        else:
            self._linestyle = '--'
        self._unscaled_dash_pattern = _get_dash_pattern(ls)
        self._dash_pattern = _scale_dashes(*self._unscaled_dash_pattern, self._linewidth)
        self.stale = True

    @_docstring.interpd
    def set_marker(self, marker):
        self._marker = MarkerStyle(marker, self._marker.get_fillstyle())
        self.stale = True

    def _set_markercolor(self, name, has_rcdefault, val):
        if val is None:
            val = mpl.rcParams[f'lines.{name}'] if has_rcdefault else 'auto'
        attr = f'_{name}'
        current = getattr(self, attr)
        if current is None:
            self.stale = True
        else:
            neq = current != val
            if neq.any() if isinstance(neq, np.ndarray) else neq:
                self.stale = True
        setattr(self, attr, val)

    def set_markeredgecolor(self, ec):
        self._set_markercolor('markeredgecolor', True, ec)

    def set_markerfacecolor(self, fc):
        self._set_markercolor('markerfacecolor', True, fc)

    def set_markerfacecoloralt(self, fc):
        self._set_markercolor('markerfacecoloralt', False, fc)

    def set_markeredgewidth(self, ew):
        if ew is None:
            ew = mpl.rcParams['lines.markeredgewidth']
        if self._markeredgewidth != ew:
            self.stale = True
        self._markeredgewidth = ew

    def set_markersize(self, sz):
        sz = float(sz)
        if self._markersize != sz:
            self.stale = True
        self._markersize = sz

    def set_xdata(self, x):
        if not np.iterable(x):
            raise RuntimeError('x must be a sequence')
        self._xorig = copy.copy(x)
        self._invalidx = True
        self.stale = True

    def set_ydata(self, y):
        if not np.iterable(y):
            raise RuntimeError('y must be a sequence')
        self._yorig = copy.copy(y)
        self._invalidy = True
        self.stale = True

    def set_dashes(self, seq):
        if seq == (None, None) or len(seq) == 0:
            self.set_linestyle('-')
        else:
            self.set_linestyle((0, seq))

    def update_from(self, other):
        super().update_from(other)
        self._linestyle = other._linestyle
        self._linewidth = other._linewidth
        self._color = other._color
        self._gapcolor = other._gapcolor
        self._markersize = other._markersize
        self._markerfacecolor = other._markerfacecolor
        self._markerfacecoloralt = other._markerfacecoloralt
        self._markeredgecolor = other._markeredgecolor
        self._markeredgewidth = other._markeredgewidth
        self._unscaled_dash_pattern = other._unscaled_dash_pattern
        self._dash_pattern = other._dash_pattern
        self._dashcapstyle = other._dashcapstyle
        self._dashjoinstyle = other._dashjoinstyle
        self._solidcapstyle = other._solidcapstyle
        self._solidjoinstyle = other._solidjoinstyle
        self._linestyle = other._linestyle
        self._marker = MarkerStyle(marker=other._marker)
        self._drawstyle = other._drawstyle

    @_docstring.interpd
    def set_dash_joinstyle(self, s):
        js = JoinStyle(s)
        if self._dashjoinstyle != js:
            self.stale = True
        self._dashjoinstyle = js

    @_docstring.interpd
    def set_solid_joinstyle(self, s):
        js = JoinStyle(s)
        if self._solidjoinstyle != js:
            self.stale = True
        self._solidjoinstyle = js

    def get_dash_joinstyle(self):
        return self._dashjoinstyle.name

    def get_solid_joinstyle(self):
        return self._solidjoinstyle.name

    @_docstring.interpd
    def set_dash_capstyle(self, s):
        cs = CapStyle(s)
        if self._dashcapstyle != cs:
            self.stale = True
        self._dashcapstyle = cs

    @_docstring.interpd
    def set_solid_capstyle(self, s):
        cs = CapStyle(s)
        if self._solidcapstyle != cs:
            self.stale = True
        self._solidcapstyle = cs

    def get_dash_capstyle(self):
        return self._dashcapstyle.name

    def get_solid_capstyle(self):
        return self._solidcapstyle.name

    def is_dashed(self):
        return self._linestyle in ('--', '-.', ':')

class AxLine(Line2D):

    def __init__(self, xy1, xy2, slope, **kwargs):
        super().__init__([0, 1], [0, 1], **kwargs)
        if xy2 is None and slope is None or (xy2 is not None and slope is not None):
            raise TypeError("Exactly one of 'xy2' and 'slope' must be given")
        self._slope = slope
        self._xy1 = xy1
        self._xy2 = xy2

    def get_transform(self):
        ax = self.axes
        points_transform = self._transform - ax.transData + ax.transScale
        if self._xy2 is not None:
            ((x1, y1), (x2, y2)) = points_transform.transform([self._xy1, self._xy2])
            dx = x2 - x1
            dy = y2 - y1
            if np.allclose(x1, x2):
                if np.allclose(y1, y2):
                    raise ValueError(f'Cannot draw a line through two identical points (x={(x1, x2)}, y={(y1, y2)})')
                slope = np.inf
            else:
                slope = dy / dx
        else:
            (x1, y1) = points_transform.transform(self._xy1)
            slope = self._slope
        ((vxlo, vylo), (vxhi, vyhi)) = ax.transScale.transform(ax.viewLim)
        if np.isclose(slope, 0):
            start = (vxlo, y1)
            stop = (vxhi, y1)
        elif np.isinf(slope):
            start = (x1, vylo)
            stop = (x1, vyhi)
        else:
            (_, start, stop, _) = sorted([(vxlo, y1 + (vxlo - x1) * slope), (vxhi, y1 + (vxhi - x1) * slope), (x1 + (vylo - y1) / slope, vylo), (x1 + (vyhi - y1) / slope, vyhi)])
        return BboxTransformTo(Bbox([start, stop])) + ax.transLimits + ax.transAxes

    def draw(self, renderer):
        self._transformed_path = None
        super().draw(renderer)

    def get_xy1(self):
        return self._xy1

    def get_xy2(self):
        return self._xy2

    def get_slope(self):
        return self._slope

    def set_xy1(self, x, y):
        self._xy1 = (x, y)

    def set_xy2(self, x, y):
        if self._slope is None:
            self._xy2 = (x, y)
        else:
            raise ValueError("Cannot set an 'xy2' value while 'slope' is set; they differ but their functionalities overlap")

    def set_slope(self, slope):
        if self._xy2 is None:
            self._slope = slope
        else:
            raise ValueError("Cannot set a 'slope' value while 'xy2' is set; they differ but their functionalities overlap")

class VertexSelector:

    def __init__(self, line):
        if line.axes is None:
            raise RuntimeError('You must first add the line to the Axes')
        if line.get_picker() is None:
            raise RuntimeError('You must first set the picker property of the line')
        self.axes = line.axes
        self.line = line
        self.cid = self.canvas.callbacks._connect_picklable('pick_event', self.onpick)
        self.ind = set()
    canvas = property(lambda self: self.axes.get_figure(root=True).canvas)

    def process_selected(self, ind, xs, ys):
        pass

    def onpick(self, event):
        if event.artist is not self.line:
            return
        self.ind ^= set(event.ind)
        ind = sorted(self.ind)
        (xdata, ydata) = self.line.get_data()
        self.process_selected(ind, xdata[ind], ydata[ind])
lineStyles = Line2D._lineStyles
lineMarkers = MarkerStyle.markers
drawStyles = Line2D.drawStyles
fillStyles = MarkerStyle.fillstyles

# File: matplotlib-main/lib/matplotlib/markers.py
""""""
import copy
from collections.abc import Sized
import numpy as np
import matplotlib as mpl
from . import _api, cbook
from .path import Path
from .transforms import IdentityTransform, Affine2D
from ._enums import JoinStyle, CapStyle
(TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN, CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN, CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE) = range(12)
_empty_path = Path(np.empty((0, 2)))

class MarkerStyle:
    markers = {'.': 'point', ',': 'pixel', 'o': 'circle', 'v': 'triangle_down', '^': 'triangle_up', '<': 'triangle_left', '>': 'triangle_right', '1': 'tri_down', '2': 'tri_up', '3': 'tri_left', '4': 'tri_right', '8': 'octagon', 's': 'square', 'p': 'pentagon', '*': 'star', 'h': 'hexagon1', 'H': 'hexagon2', '+': 'plus', 'x': 'x', 'D': 'diamond', 'd': 'thin_diamond', '|': 'vline', '_': 'hline', 'P': 'plus_filled', 'X': 'x_filled', TICKLEFT: 'tickleft', TICKRIGHT: 'tickright', TICKUP: 'tickup', TICKDOWN: 'tickdown', CARETLEFT: 'caretleft', CARETRIGHT: 'caretright', CARETUP: 'caretup', CARETDOWN: 'caretdown', CARETLEFTBASE: 'caretleftbase', CARETRIGHTBASE: 'caretrightbase', CARETUPBASE: 'caretupbase', CARETDOWNBASE: 'caretdownbase', 'None': 'nothing', 'none': 'nothing', ' ': 'nothing', '': 'nothing'}
    filled_markers = ('.', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X')
    fillstyles = ('full', 'left', 'right', 'bottom', 'top', 'none')
    _half_fillstyles = ('left', 'right', 'bottom', 'top')

    def __init__(self, marker, fillstyle=None, transform=None, capstyle=None, joinstyle=None):
        self._marker_function = None
        self._user_transform = transform
        self._user_capstyle = CapStyle(capstyle) if capstyle is not None else None
        self._user_joinstyle = JoinStyle(joinstyle) if joinstyle is not None else None
        self._set_fillstyle(fillstyle)
        self._set_marker(marker)

    def _recache(self):
        if self._marker_function is None:
            return
        self._path = _empty_path
        self._transform = IdentityTransform()
        self._alt_path = None
        self._alt_transform = None
        self._snap_threshold = None
        self._joinstyle = JoinStyle.round
        self._capstyle = self._user_capstyle or CapStyle.butt
        self._filled = self._fillstyle != 'none'
        self._marker_function()

    def __bool__(self):
        return bool(len(self._path.vertices))

    def is_filled(self):
        return self._filled

    def get_fillstyle(self):
        return self._fillstyle

    def _set_fillstyle(self, fillstyle):
        if fillstyle is None:
            fillstyle = mpl.rcParams['markers.fillstyle']
        _api.check_in_list(self.fillstyles, fillstyle=fillstyle)
        self._fillstyle = fillstyle

    def get_joinstyle(self):
        return self._joinstyle.name

    def get_capstyle(self):
        return self._capstyle.name

    def get_marker(self):
        return self._marker

    def _set_marker(self, marker):
        if isinstance(marker, str) and cbook.is_math_text(marker):
            self._marker_function = self._set_mathtext_path
        elif isinstance(marker, (int, str)) and marker in self.markers:
            self._marker_function = getattr(self, '_set_' + self.markers[marker])
        elif isinstance(marker, np.ndarray) and marker.ndim == 2 and (marker.shape[1] == 2):
            self._marker_function = self._set_vertices
        elif isinstance(marker, Path):
            self._marker_function = self._set_path_marker
        elif isinstance(marker, Sized) and len(marker) in (2, 3) and (marker[1] in (0, 1, 2)):
            self._marker_function = self._set_tuple_marker
        elif isinstance(marker, MarkerStyle):
            self.__dict__ = copy.deepcopy(marker.__dict__)
        else:
            try:
                Path(marker)
                self._marker_function = self._set_vertices
            except ValueError as err:
                raise ValueError(f'Unrecognized marker style {marker!r}') from err
        if not isinstance(marker, MarkerStyle):
            self._marker = marker
            self._recache()

    def get_path(self):
        return self._path

    def get_transform(self):
        if self._user_transform is None:
            return self._transform.frozen()
        else:
            return (self._transform + self._user_transform).frozen()

    def get_alt_path(self):
        return self._alt_path

    def get_alt_transform(self):
        if self._user_transform is None:
            return self._alt_transform.frozen()
        else:
            return (self._alt_transform + self._user_transform).frozen()

    def get_snap_threshold(self):
        return self._snap_threshold

    def get_user_transform(self):
        if self._user_transform is not None:
            return self._user_transform.frozen()

    def transformed(self, transform):
        new_marker = MarkerStyle(self)
        if new_marker._user_transform is not None:
            new_marker._user_transform += transform
        else:
            new_marker._user_transform = transform
        return new_marker

    def rotated(self, *, deg=None, rad=None):
        if deg is None and rad is None:
            raise ValueError('One of deg or rad is required')
        if deg is not None and rad is not None:
            raise ValueError('Only one of deg and rad can be supplied')
        new_marker = MarkerStyle(self)
        if new_marker._user_transform is None:
            new_marker._user_transform = Affine2D()
        if deg is not None:
            new_marker._user_transform.rotate_deg(deg)
        if rad is not None:
            new_marker._user_transform.rotate(rad)
        return new_marker

    def scaled(self, sx, sy=None):
        if sy is None:
            sy = sx
        new_marker = MarkerStyle(self)
        _transform = new_marker._user_transform or Affine2D()
        new_marker._user_transform = _transform.scale(sx, sy)
        return new_marker

    def _set_nothing(self):
        self._filled = False

    def _set_custom_marker(self, path):
        rescale = np.max(np.abs(path.vertices))
        self._transform = Affine2D().scale(0.5 / rescale)
        self._path = path

    def _set_path_marker(self):
        self._set_custom_marker(self._marker)

    def _set_vertices(self):
        self._set_custom_marker(Path(self._marker))

    def _set_tuple_marker(self):
        marker = self._marker
        if len(marker) == 2:
            (numsides, rotation) = (marker[0], 0.0)
        elif len(marker) == 3:
            (numsides, rotation) = (marker[0], marker[2])
        symstyle = marker[1]
        if symstyle == 0:
            self._path = Path.unit_regular_polygon(numsides)
            self._joinstyle = self._user_joinstyle or JoinStyle.miter
        elif symstyle == 1:
            self._path = Path.unit_regular_star(numsides)
            self._joinstyle = self._user_joinstyle or JoinStyle.bevel
        elif symstyle == 2:
            self._path = Path.unit_regular_asterisk(numsides)
            self._filled = False
            self._joinstyle = self._user_joinstyle or JoinStyle.bevel
        else:
            raise ValueError(f'Unexpected tuple marker: {marker}')
        self._transform = Affine2D().scale(0.5).rotate_deg(rotation)

    def _set_mathtext_path(self):
        from matplotlib.text import TextPath
        text = TextPath(xy=(0, 0), s=self.get_marker(), usetex=mpl.rcParams['text.usetex'])
        if len(text.vertices) == 0:
            return
        bbox = text.get_extents()
        max_dim = max(bbox.width, bbox.height)
        self._transform = Affine2D().translate(-bbox.xmin + 0.5 * -bbox.width, -bbox.ymin + 0.5 * -bbox.height).scale(1.0 / max_dim)
        self._path = text
        self._snap = False

    def _half_fill(self):
        return self.get_fillstyle() in self._half_fillstyles

    def _set_circle(self, size=1.0):
        self._transform = Affine2D().scale(0.5 * size)
        self._snap_threshold = np.inf
        if not self._half_fill():
            self._path = Path.unit_circle()
        else:
            self._path = self._alt_path = Path.unit_circle_righthalf()
            fs = self.get_fillstyle()
            self._transform.rotate_deg({'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs])
            self._alt_transform = self._transform.frozen().rotate_deg(180.0)

    def _set_point(self):
        self._set_circle(size=0.5)

    def _set_pixel(self):
        self._path = Path.unit_rectangle()
        self._transform = Affine2D().translate(-0.49999, -0.49999)
        self._snap_threshold = None
    _triangle_path = Path._create_closed([[0, 1], [-1, -1], [1, -1]])
    _triangle_path_u = Path._create_closed([[0, 1], [-3 / 5, -1 / 5], [3 / 5, -1 / 5]])
    _triangle_path_d = Path._create_closed([[-3 / 5, -1 / 5], [3 / 5, -1 / 5], [1, -1], [-1, -1]])
    _triangle_path_l = Path._create_closed([[0, 1], [0, -1], [-1, -1]])
    _triangle_path_r = Path._create_closed([[0, 1], [0, -1], [1, -1]])

    def _set_triangle(self, rot, skip):
        self._transform = Affine2D().scale(0.5).rotate_deg(rot)
        self._snap_threshold = 5.0
        if not self._half_fill():
            self._path = self._triangle_path
        else:
            mpaths = [self._triangle_path_u, self._triangle_path_l, self._triangle_path_d, self._triangle_path_r]
            fs = self.get_fillstyle()
            if fs == 'top':
                self._path = mpaths[(0 + skip) % 4]
                self._alt_path = mpaths[(2 + skip) % 4]
            elif fs == 'bottom':
                self._path = mpaths[(2 + skip) % 4]
                self._alt_path = mpaths[(0 + skip) % 4]
            elif fs == 'left':
                self._path = mpaths[(1 + skip) % 4]
                self._alt_path = mpaths[(3 + skip) % 4]
            else:
                self._path = mpaths[(3 + skip) % 4]
                self._alt_path = mpaths[(1 + skip) % 4]
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_triangle_up(self):
        return self._set_triangle(0.0, 0)

    def _set_triangle_down(self):
        return self._set_triangle(180.0, 2)

    def _set_triangle_left(self):
        return self._set_triangle(90.0, 3)

    def _set_triangle_right(self):
        return self._set_triangle(270.0, 1)

    def _set_square(self):
        self._transform = Affine2D().translate(-0.5, -0.5)
        self._snap_threshold = 2.0
        if not self._half_fill():
            self._path = Path.unit_rectangle()
        else:
            self._path = Path([[0.0, 0.0], [1.0, 0.0], [1.0, 0.5], [0.0, 0.5], [0.0, 0.0]])
            self._alt_path = Path([[0.0, 0.5], [1.0, 0.5], [1.0, 1.0], [0.0, 1.0], [0.0, 0.5]])
            fs = self.get_fillstyle()
            rotate = {'bottom': 0, 'right': 90, 'top': 180, 'left': 270}[fs]
            self._transform.rotate_deg(rotate)
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_diamond(self):
        self._transform = Affine2D().translate(-0.5, -0.5).rotate_deg(45)
        self._snap_threshold = 5.0
        if not self._half_fill():
            self._path = Path.unit_rectangle()
        else:
            self._path = Path([[0, 0], [1, 0], [1, 1], [0, 0]])
            self._alt_path = Path([[0, 0], [0, 1], [1, 1], [0, 0]])
            fs = self.get_fillstyle()
            rotate = {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs]
            self._transform.rotate_deg(rotate)
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_thin_diamond(self):
        self._set_diamond()
        self._transform.scale(0.6, 1.0)

    def _set_pentagon(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 5.0
        polypath = Path.unit_regular_polygon(5)
        if not self._half_fill():
            self._path = polypath
        else:
            verts = polypath.vertices
            y = (1 + np.sqrt(5)) / 4.0
            top = Path(verts[[0, 1, 4, 0]])
            bottom = Path(verts[[1, 2, 3, 4, 1]])
            left = Path([verts[0], verts[1], verts[2], [0, -y], verts[0]])
            right = Path([verts[0], verts[4], verts[3], [0, -y], verts[0]])
            (self._path, self._alt_path) = {'top': (top, bottom), 'bottom': (bottom, top), 'left': (left, right), 'right': (right, left)}[self.get_fillstyle()]
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_star(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 5.0
        polypath = Path.unit_regular_star(5, innerCircle=0.381966)
        if not self._half_fill():
            self._path = polypath
        else:
            verts = polypath.vertices
            top = Path(np.concatenate([verts[0:4], verts[7:10], verts[0:1]]))
            bottom = Path(np.concatenate([verts[3:8], verts[3:4]]))
            left = Path(np.concatenate([verts[0:6], verts[0:1]]))
            right = Path(np.concatenate([verts[0:1], verts[5:10], verts[0:1]]))
            (self._path, self._alt_path) = {'top': (top, bottom), 'bottom': (bottom, top), 'left': (left, right), 'right': (right, left)}[self.get_fillstyle()]
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.bevel

    def _set_hexagon1(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = None
        polypath = Path.unit_regular_polygon(6)
        if not self._half_fill():
            self._path = polypath
        else:
            verts = polypath.vertices
            x = np.abs(np.cos(5 * np.pi / 6.0))
            top = Path(np.concatenate([[(-x, 0)], verts[[1, 0, 5]], [(x, 0)]]))
            bottom = Path(np.concatenate([[(-x, 0)], verts[2:5], [(x, 0)]]))
            left = Path(verts[0:4])
            right = Path(verts[[0, 5, 4, 3]])
            (self._path, self._alt_path) = {'top': (top, bottom), 'bottom': (bottom, top), 'left': (left, right), 'right': (right, left)}[self.get_fillstyle()]
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_hexagon2(self):
        self._transform = Affine2D().scale(0.5).rotate_deg(30)
        self._snap_threshold = None
        polypath = Path.unit_regular_polygon(6)
        if not self._half_fill():
            self._path = polypath
        else:
            verts = polypath.vertices
            (x, y) = (np.sqrt(3) / 4, 3 / 4.0)
            top = Path(verts[[1, 0, 5, 4, 1]])
            bottom = Path(verts[1:5])
            left = Path(np.concatenate([[(x, y)], verts[:3], [(-x, -y), (x, y)]]))
            right = Path(np.concatenate([[(x, y)], verts[5:2:-1], [(-x, -y)]]))
            (self._path, self._alt_path) = {'top': (top, bottom), 'bottom': (bottom, top), 'left': (left, right), 'right': (right, left)}[self.get_fillstyle()]
            self._alt_transform = self._transform
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_octagon(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 5.0
        polypath = Path.unit_regular_polygon(8)
        if not self._half_fill():
            self._transform.rotate_deg(22.5)
            self._path = polypath
        else:
            x = np.sqrt(2.0) / 4.0
            self._path = self._alt_path = Path([[0, -1], [0, 1], [-x, 1], [-1, x], [-1, -x], [-x, -1], [0, -1]])
            fs = self.get_fillstyle()
            self._transform.rotate_deg({'left': 0, 'bottom': 90, 'right': 180, 'top': 270}[fs])
            self._alt_transform = self._transform.frozen().rotate_deg(180.0)
        self._joinstyle = self._user_joinstyle or JoinStyle.miter
    _line_marker_path = Path([[0.0, -1.0], [0.0, 1.0]])

    def _set_vline(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._line_marker_path

    def _set_hline(self):
        self._set_vline()
        self._transform = self._transform.rotate_deg(90)
    _tickhoriz_path = Path([[0.0, 0.0], [1.0, 0.0]])

    def _set_tickleft(self):
        self._transform = Affine2D().scale(-1.0, 1.0)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._tickhoriz_path

    def _set_tickright(self):
        self._transform = Affine2D().scale(1.0, 1.0)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._tickhoriz_path
    _tickvert_path = Path([[-0.0, 0.0], [-0.0, 1.0]])

    def _set_tickup(self):
        self._transform = Affine2D().scale(1.0, 1.0)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._tickvert_path

    def _set_tickdown(self):
        self._transform = Affine2D().scale(1.0, -1.0)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._tickvert_path
    _tri_path = Path([[0.0, 0.0], [0.0, -1.0], [0.0, 0.0], [0.8, 0.5], [0.0, 0.0], [-0.8, 0.5]], [Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO])

    def _set_tri_down(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 5.0
        self._filled = False
        self._path = self._tri_path

    def _set_tri_up(self):
        self._set_tri_down()
        self._transform = self._transform.rotate_deg(180)

    def _set_tri_left(self):
        self._set_tri_down()
        self._transform = self._transform.rotate_deg(270)

    def _set_tri_right(self):
        self._set_tri_down()
        self._transform = self._transform.rotate_deg(90)
    _caret_path = Path([[-1.0, 1.5], [0.0, 0.0], [1.0, 1.5]])

    def _set_caretdown(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 3.0
        self._filled = False
        self._path = self._caret_path
        self._joinstyle = self._user_joinstyle or JoinStyle.miter

    def _set_caretup(self):
        self._set_caretdown()
        self._transform = self._transform.rotate_deg(180)

    def _set_caretleft(self):
        self._set_caretdown()
        self._transform = self._transform.rotate_deg(270)

    def _set_caretright(self):
        self._set_caretdown()
        self._transform = self._transform.rotate_deg(90)
    _caret_path_base = Path([[-1.0, 0.0], [0.0, -1.5], [1.0, 0]])

    def _set_caretdownbase(self):
        self._set_caretdown()
        self._path = self._caret_path_base

    def _set_caretupbase(self):
        self._set_caretdownbase()
        self._transform = self._transform.rotate_deg(180)

    def _set_caretleftbase(self):
        self._set_caretdownbase()
        self._transform = self._transform.rotate_deg(270)

    def _set_caretrightbase(self):
        self._set_caretdownbase()
        self._transform = self._transform.rotate_deg(90)
    _plus_path = Path([[-1.0, 0.0], [1.0, 0.0], [0.0, -1.0], [0.0, 1.0]], [Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO])

    def _set_plus(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 1.0
        self._filled = False
        self._path = self._plus_path
    _x_path = Path([[-1.0, -1.0], [1.0, 1.0], [-1.0, 1.0], [1.0, -1.0]], [Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO])

    def _set_x(self):
        self._transform = Affine2D().scale(0.5)
        self._snap_threshold = 3.0
        self._filled = False
        self._path = self._x_path
    _plus_filled_path = Path._create_closed(np.array([(-1, -3), (+1, -3), (+1, -1), (+3, -1), (+3, +1), (+1, +1), (+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, -1), (-1, -1)]) / 6)
    _plus_filled_path_t = Path._create_closed(np.array([(+3, 0), (+3, +1), (+1, +1), (+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, 0)]) / 6)

    def _set_plus_filled(self):
        self._transform = Affine2D()
        self._snap_threshold = 5.0
        self._joinstyle = self._user_joinstyle or JoinStyle.miter
        if not self._half_fill():
            self._path = self._plus_filled_path
        else:
            self._path = self._alt_path = self._plus_filled_path_t
            fs = self.get_fillstyle()
            self._transform.rotate_deg({'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
            self._alt_transform = self._transform.frozen().rotate_deg(180)
    _x_filled_path = Path._create_closed(np.array([(-1, -2), (0, -1), (+1, -2), (+2, -1), (+1, 0), (+2, +1), (+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0), (-2, -1)]) / 4)
    _x_filled_path_t = Path._create_closed(np.array([(+1, 0), (+2, +1), (+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0)]) / 4)

    def _set_x_filled(self):
        self._transform = Affine2D()
        self._snap_threshold = 5.0
        self._joinstyle = self._user_joinstyle or JoinStyle.miter
        if not self._half_fill():
            self._path = self._x_filled_path
        else:
            self._path = self._alt_path = self._x_filled_path_t
            fs = self.get_fillstyle()
            self._transform.rotate_deg({'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
            self._alt_transform = self._transform.frozen().rotate_deg(180)

# File: matplotlib-main/lib/matplotlib/mathtext.py
""""""
import functools
import logging
import matplotlib as mpl
from matplotlib import _api, _mathtext
from matplotlib.ft2font import LOAD_NO_HINTING
from matplotlib.font_manager import FontProperties
from ._mathtext import RasterParse, VectorParse, get_unicode_index
_log = logging.getLogger(__name__)
get_unicode_index.__module__ = __name__

class MathTextParser:
    _parser = None
    _font_type_mapping = {'cm': _mathtext.BakomaFonts, 'dejavuserif': _mathtext.DejaVuSerifFonts, 'dejavusans': _mathtext.DejaVuSansFonts, 'stix': _mathtext.StixFonts, 'stixsans': _mathtext.StixSansFonts, 'custom': _mathtext.UnicodeFonts}

    def __init__(self, output):
        self._output_type = _api.check_getitem({'path': 'vector', 'agg': 'raster', 'macosx': 'raster'}, output=output.lower())

    def parse(self, s, dpi=72, prop=None, *, antialiased=None):
        prop = prop.copy() if prop is not None else None
        antialiased = mpl._val_or_rc(antialiased, 'text.antialiased')
        from matplotlib.backends import backend_agg
        load_glyph_flags = {'vector': LOAD_NO_HINTING, 'raster': backend_agg.get_hinting_flag()}[self._output_type]
        return self._parse_cached(s, dpi, prop, antialiased, load_glyph_flags)

    @functools.lru_cache(50)
    def _parse_cached(self, s, dpi, prop, antialiased, load_glyph_flags):
        if prop is None:
            prop = FontProperties()
        fontset_class = _api.check_getitem(self._font_type_mapping, fontset=prop.get_math_fontfamily())
        fontset = fontset_class(prop, load_glyph_flags)
        fontsize = prop.get_size_in_points()
        if self._parser is None:
            self.__class__._parser = _mathtext.Parser()
        box = self._parser.parse(s, fontset, fontsize, dpi)
        output = _mathtext.ship(box)
        if self._output_type == 'vector':
            return output.to_vector()
        elif self._output_type == 'raster':
            return output.to_raster(antialiased=antialiased)

def math_to_image(s, filename_or_obj, prop=None, dpi=None, format=None, *, color=None):
    from matplotlib import figure
    parser = MathTextParser('path')
    (width, height, depth, _, _) = parser.parse(s, dpi=72, prop=prop)
    fig = figure.Figure(figsize=(width / 72.0, height / 72.0))
    fig.text(0, depth / height, s, fontproperties=prop, color=color)
    fig.savefig(filename_or_obj, dpi=dpi, format=format)
    return depth

# File: matplotlib-main/lib/matplotlib/mlab.py
""""""
import functools
from numbers import Number
import numpy as np
from matplotlib import _api, _docstring, cbook

def window_hanning(x):
    return np.hanning(len(x)) * x

def window_none(x):
    return x

def detrend(x, key=None, axis=None):
    if key is None or key in ['constant', 'mean', 'default']:
        return detrend(x, key=detrend_mean, axis=axis)
    elif key == 'linear':
        return detrend(x, key=detrend_linear, axis=axis)
    elif key == 'none':
        return detrend(x, key=detrend_none, axis=axis)
    elif callable(key):
        x = np.asarray(x)
        if axis is not None and axis + 1 > x.ndim:
            raise ValueError(f'axis(={axis}) out of bounds')
        if axis is None and x.ndim == 0 or (not axis and x.ndim == 1):
            return key(x)
        try:
            return key(x, axis=axis)
        except TypeError:
            return np.apply_along_axis(key, axis=axis, arr=x)
    else:
        raise ValueError(f"Unknown value for key: {key!r}, must be one of: 'default', 'constant', 'mean', 'linear', or a function")

def detrend_mean(x, axis=None):
    x = np.asarray(x)
    if axis is not None and axis + 1 > x.ndim:
        raise ValueError('axis(=%s) out of bounds' % axis)
    return x - x.mean(axis, keepdims=True)

def detrend_none(x, axis=None):
    return x

def detrend_linear(y):
    y = np.asarray(y)
    if y.ndim > 1:
        raise ValueError('y cannot have ndim > 1')
    if not y.ndim:
        return np.array(0.0, dtype=y.dtype)
    x = np.arange(y.size, dtype=float)
    C = np.cov(x, y, bias=1)
    b = C[0, 1] / C[0, 0]
    a = y.mean() - b * x.mean()
    return y - (b * x + a)

def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, mode=None):
    if y is None:
        same_data = True
    else:
        same_data = y is x
    if Fs is None:
        Fs = 2
    if noverlap is None:
        noverlap = 0
    if detrend_func is None:
        detrend_func = detrend_none
    if window is None:
        window = window_hanning
    if NFFT is None:
        NFFT = 256
    if noverlap >= NFFT:
        raise ValueError('noverlap must be less than NFFT')
    if mode is None or mode == 'default':
        mode = 'psd'
    _api.check_in_list(['default', 'psd', 'complex', 'magnitude', 'angle', 'phase'], mode=mode)
    if not same_data and mode != 'psd':
        raise ValueError("x and y must be equal if mode is not 'psd'")
    x = np.asarray(x)
    if not same_data:
        y = np.asarray(y)
    if sides is None or sides == 'default':
        if np.iscomplexobj(x):
            sides = 'twosided'
        else:
            sides = 'onesided'
    _api.check_in_list(['default', 'onesided', 'twosided'], sides=sides)
    if len(x) < NFFT:
        n = len(x)
        x = np.resize(x, NFFT)
        x[n:] = 0
    if not same_data and len(y) < NFFT:
        n = len(y)
        y = np.resize(y, NFFT)
        y[n:] = 0
    if pad_to is None:
        pad_to = NFFT
    if mode != 'psd':
        scale_by_freq = False
    elif scale_by_freq is None:
        scale_by_freq = True
    if sides == 'twosided':
        numFreqs = pad_to
        if pad_to % 2:
            freqcenter = (pad_to - 1) // 2 + 1
        else:
            freqcenter = pad_to // 2
        scaling_factor = 1.0
    elif sides == 'onesided':
        if pad_to % 2:
            numFreqs = (pad_to + 1) // 2
        else:
            numFreqs = pad_to // 2 + 1
        scaling_factor = 2.0
    if not np.iterable(window):
        window = window(np.ones(NFFT, x.dtype))
    if len(window) != NFFT:
        raise ValueError("The window length must match the data's first dimension")
    result = np.lib.stride_tricks.sliding_window_view(x, NFFT, axis=0)[::NFFT - noverlap].T
    result = detrend(result, detrend_func, axis=0)
    result = result * window.reshape((-1, 1))
    result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]
    freqs = np.fft.fftfreq(pad_to, 1 / Fs)[:numFreqs]
    if not same_data:
        resultY = np.lib.stride_tricks.sliding_window_view(y, NFFT, axis=0)[::NFFT - noverlap].T
        resultY = detrend(resultY, detrend_func, axis=0)
        resultY = resultY * window.reshape((-1, 1))
        resultY = np.fft.fft(resultY, n=pad_to, axis=0)[:numFreqs, :]
        result = np.conj(result) * resultY
    elif mode == 'psd':
        result = np.conj(result) * result
    elif mode == 'magnitude':
        result = np.abs(result) / window.sum()
    elif mode == 'angle' or mode == 'phase':
        result = np.angle(result)
    elif mode == 'complex':
        result /= window.sum()
    if mode == 'psd':
        if not NFFT % 2:
            slc = slice(1, -1, None)
        else:
            slc = slice(1, None, None)
        result[slc] *= scaling_factor
        if scale_by_freq:
            result /= Fs
            result /= (window ** 2).sum()
        else:
            result /= window.sum() ** 2
    t = np.arange(NFFT / 2, len(x) - NFFT / 2 + 1, NFFT - noverlap) / Fs
    if sides == 'twosided':
        freqs = np.roll(freqs, -freqcenter, axis=0)
        result = np.roll(result, -freqcenter, axis=0)
    elif not pad_to % 2:
        freqs[-1] *= -1
    if mode == 'phase':
        result = np.unwrap(result, axis=0)
    return (result, freqs, t)

def _single_spectrum_helper(mode, x, Fs=None, window=None, pad_to=None, sides=None):
    _api.check_in_list(['complex', 'magnitude', 'angle', 'phase'], mode=mode)
    if pad_to is None:
        pad_to = len(x)
    (spec, freqs, _) = _spectral_helper(x=x, y=None, NFFT=len(x), Fs=Fs, detrend_func=detrend_none, window=window, noverlap=0, pad_to=pad_to, sides=sides, scale_by_freq=False, mode=mode)
    if mode != 'complex':
        spec = spec.real
    if spec.ndim == 2 and spec.shape[1] == 1:
        spec = spec[:, 0]
    return (spec, freqs)
_docstring.interpd.update(Spectral="Fs : float, default: 2\n    The sampling frequency (samples per time unit).  It is used to calculate\n    the Fourier frequencies, *freqs*, in cycles per time unit.\n\nwindow : callable or ndarray, default: `.window_hanning`\n    A function or a vector of length *NFFT*.  To create window vectors see\n    `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n    `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n    function is passed as the argument, it must take a data segment as an\n    argument and return the windowed version of the segment.\n\nsides : {'default', 'onesided', 'twosided'}, optional\n    Which sides of the spectrum to return. 'default' is one-sided for real\n    data and two-sided for complex data. 'onesided' forces the return of a\n    one-sided spectrum, while 'twosided' forces two-sided.", Single_Spectrum='pad_to : int, optional\n    The number of points to which the data segment is padded when performing\n    the FFT.  While not increasing the actual resolution of the spectrum (the\n    minimum distance between resolvable peaks), this can give more points in\n    the plot, allowing for more detail. This corresponds to the *n* parameter\n    in the call to `~numpy.fft.fft`.  The default is None, which sets *pad_to*\n    equal to the length of the input signal (i.e. no padding).', PSD="pad_to : int, optional\n    The number of points to which the data segment is padded when performing\n    the FFT.  This can be different from *NFFT*, which specifies the number\n    of data points used.  While not increasing the actual resolution of the\n    spectrum (the minimum distance between resolvable peaks), this can give\n    more points in the plot, allowing for more detail. This corresponds to\n    the *n* parameter in the call to `~numpy.fft.fft`. The default is None,\n    which sets *pad_to* equal to *NFFT*\n\nNFFT : int, default: 256\n    The number of data points used in each block for the FFT.  A power 2 is\n    most efficient.  This should *NOT* be used to get zero padding, or the\n    scaling of the result will be incorrect; use *pad_to* for this instead.\n\ndetrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n    The function applied to each segment before fft-ing, designed to remove\n    the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n    is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`\n    module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n    but you can use a custom function as well.  You can also use a string to\n    choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n    `.detrend_mean`. 'linear' calls `.detrend_linear`.\n\nscale_by_freq : bool, default: True\n    Whether the resulting density values should be scaled by the scaling\n    frequency, which gives density in units of 1/Hz.  This allows for\n    integration over the returned frequency values.  The default is True for\n    MATLAB compatibility.")

@_docstring.dedent_interpd
def psd(x, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None):
    (Pxx, freqs) = csd(x=x, y=None, NFFT=NFFT, Fs=Fs, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq)
    return (Pxx.real, freqs)

@_docstring.dedent_interpd
def csd(x, y, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None):
    if NFFT is None:
        NFFT = 256
    (Pxy, freqs, _) = _spectral_helper(x=x, y=y, NFFT=NFFT, Fs=Fs, detrend_func=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode='psd')
    if Pxy.ndim == 2:
        if Pxy.shape[1] > 1:
            Pxy = Pxy.mean(axis=1)
        else:
            Pxy = Pxy[:, 0]
    return (Pxy, freqs)
_single_spectrum_docs = 'Compute the {quantity} of *x*.\nData is padded to a length of *pad_to* and the windowing function *window* is\napplied to the signal.\n\nParameters\n----------\nx : 1-D array or sequence\n    Array or sequence containing the data\n\n{Spectral}\n\n{Single_Spectrum}\n\nReturns\n-------\nspectrum : 1-D array\n    The {quantity}.\nfreqs : 1-D array\n    The frequencies corresponding to the elements in *spectrum*.\n\nSee Also\n--------\npsd\n    Returns the power spectral density.\ncomplex_spectrum\n    Returns the complex-valued frequency spectrum.\nmagnitude_spectrum\n    Returns the absolute value of the `complex_spectrum`.\nangle_spectrum\n    Returns the angle of the `complex_spectrum`.\nphase_spectrum\n    Returns the phase (unwrapped angle) of the `complex_spectrum`.\nspecgram\n    Can return the complex spectrum of segments within the signal.\n'
complex_spectrum = functools.partial(_single_spectrum_helper, 'complex')
complex_spectrum.__doc__ = _single_spectrum_docs.format(quantity='complex-valued frequency spectrum', **_docstring.interpd.params)
magnitude_spectrum = functools.partial(_single_spectrum_helper, 'magnitude')
magnitude_spectrum.__doc__ = _single_spectrum_docs.format(quantity='magnitude (absolute value) of the frequency spectrum', **_docstring.interpd.params)
angle_spectrum = functools.partial(_single_spectrum_helper, 'angle')
angle_spectrum.__doc__ = _single_spectrum_docs.format(quantity='angle of the frequency spectrum (wrapped phase spectrum)', **_docstring.interpd.params)
phase_spectrum = functools.partial(_single_spectrum_helper, 'phase')
phase_spectrum.__doc__ = _single_spectrum_docs.format(quantity='phase of the frequency spectrum (unwrapped phase spectrum)', **_docstring.interpd.params)

@_docstring.dedent_interpd
def specgram(x, NFFT=None, Fs=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, mode=None):
    if noverlap is None:
        noverlap = 128
    if NFFT is None:
        NFFT = 256
    if len(x) <= NFFT:
        _api.warn_external(f'Only one segment is calculated since parameter NFFT (={NFFT}) >= signal length (={len(x)}).')
    (spec, freqs, t) = _spectral_helper(x=x, y=None, NFFT=NFFT, Fs=Fs, detrend_func=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode=mode)
    if mode != 'complex':
        spec = spec.real
    return (spec, freqs, t)

@_docstring.dedent_interpd
def cohere(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning, noverlap=0, pad_to=None, sides='default', scale_by_freq=None):
    if len(x) < 2 * NFFT:
        raise ValueError('Coherence is calculated by averaging over *NFFT* length segments.  Your signal is too short for your choice of *NFFT*.')
    (Pxx, f) = psd(x, NFFT, Fs, detrend, window, noverlap, pad_to, sides, scale_by_freq)
    (Pyy, f) = psd(y, NFFT, Fs, detrend, window, noverlap, pad_to, sides, scale_by_freq)
    (Pxy, f) = csd(x, y, NFFT, Fs, detrend, window, noverlap, pad_to, sides, scale_by_freq)
    Cxy = np.abs(Pxy) ** 2 / (Pxx * Pyy)
    return (Cxy, f)

class GaussianKDE:

    def __init__(self, dataset, bw_method=None):
        self.dataset = np.atleast_2d(dataset)
        if not np.array(self.dataset).size > 1:
            raise ValueError('`dataset` input should have multiple elements.')
        (self.dim, self.num_dp) = np.array(self.dataset).shape
        if bw_method is None:
            pass
        elif cbook._str_equal(bw_method, 'scott'):
            self.covariance_factor = self.scotts_factor
        elif cbook._str_equal(bw_method, 'silverman'):
            self.covariance_factor = self.silverman_factor
        elif isinstance(bw_method, Number):
            self._bw_method = 'use constant'
            self.covariance_factor = lambda : bw_method
        elif callable(bw_method):
            self._bw_method = bw_method
            self.covariance_factor = lambda : self._bw_method(self)
        else:
            raise ValueError("`bw_method` should be 'scott', 'silverman', a scalar or a callable")
        self.factor = self.covariance_factor()
        if not hasattr(self, '_data_inv_cov'):
            self.data_covariance = np.atleast_2d(np.cov(self.dataset, rowvar=1, bias=False))
            self.data_inv_cov = np.linalg.inv(self.data_covariance)
        self.covariance = self.data_covariance * self.factor ** 2
        self.inv_cov = self.data_inv_cov / self.factor ** 2
        self.norm_factor = np.sqrt(np.linalg.det(2 * np.pi * self.covariance)) * self.num_dp

    def scotts_factor(self):
        return np.power(self.num_dp, -1.0 / (self.dim + 4))

    def silverman_factor(self):
        return np.power(self.num_dp * (self.dim + 2.0) / 4.0, -1.0 / (self.dim + 4))
    covariance_factor = scotts_factor

    def evaluate(self, points):
        points = np.atleast_2d(points)
        (dim, num_m) = np.array(points).shape
        if dim != self.dim:
            raise ValueError(f'points have dimension {dim}, dataset has dimension {self.dim}')
        result = np.zeros(num_m)
        if num_m >= self.num_dp:
            for i in range(self.num_dp):
                diff = self.dataset[:, i, np.newaxis] - points
                tdiff = np.dot(self.inv_cov, diff)
                energy = np.sum(diff * tdiff, axis=0) / 2.0
                result = result + np.exp(-energy)
        else:
            for i in range(num_m):
                diff = self.dataset - points[:, i, np.newaxis]
                tdiff = np.dot(self.inv_cov, diff)
                energy = np.sum(diff * tdiff, axis=0) / 2.0
                result[i] = np.sum(np.exp(-energy), axis=0)
        result = result / self.norm_factor
        return result
    __call__ = evaluate

# File: matplotlib-main/lib/matplotlib/offsetbox.py
""""""
import functools
import numpy as np
import matplotlib as mpl
from matplotlib import _api, _docstring
import matplotlib.artist as martist
import matplotlib.path as mpath
import matplotlib.text as mtext
import matplotlib.transforms as mtransforms
from matplotlib.font_manager import FontProperties
from matplotlib.image import BboxImage
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch, bbox_artist as mbbox_artist
from matplotlib.transforms import Bbox, BboxBase, TransformedBbox
DEBUG = False

def _compat_get_offset(meth):
    sigs = [lambda self, width, height, xdescent, ydescent, renderer: locals(), lambda self, bbox, renderer: locals()]

    @functools.wraps(meth)
    def get_offset(self, *args, **kwargs):
        params = _api.select_matching_signature(sigs, self, *args, **kwargs)
        bbox = params['bbox'] if 'bbox' in params else Bbox.from_bounds(-params['xdescent'], -params['ydescent'], params['width'], params['height'])
        return meth(params['self'], bbox, params['renderer'])
    return get_offset

def _bbox_artist(*args, **kwargs):
    if DEBUG:
        mbbox_artist(*args, **kwargs)

def _get_packed_offsets(widths, total, sep, mode='fixed'):
    _api.check_in_list(['fixed', 'expand', 'equal'], mode=mode)
    if mode == 'fixed':
        offsets_ = np.cumsum([0] + [w + sep for w in widths])
        offsets = offsets_[:-1]
        if total is None:
            total = offsets_[-1] - sep
        return (total, offsets)
    elif mode == 'expand':
        if total is None:
            total = 1
        if len(widths) > 1:
            sep = (total - sum(widths)) / (len(widths) - 1)
        else:
            sep = 0
        offsets_ = np.cumsum([0] + [w + sep for w in widths])
        offsets = offsets_[:-1]
        return (total, offsets)
    elif mode == 'equal':
        maxh = max(widths)
        if total is None:
            if sep is None:
                raise ValueError("total and sep cannot both be None when using layout mode 'equal'")
            total = (maxh + sep) * len(widths)
        else:
            sep = total / len(widths) - maxh
        offsets = (maxh + sep) * np.arange(len(widths))
        return (total, offsets)

def _get_aligned_offsets(yspans, height, align='baseline'):
    _api.check_in_list(['baseline', 'left', 'top', 'right', 'bottom', 'center'], align=align)
    if height is None:
        height = max((y1 - y0 for (y0, y1) in yspans))
    if align == 'baseline':
        yspan = (min((y0 for (y0, y1) in yspans)), max((y1 for (y0, y1) in yspans)))
        offsets = [0] * len(yspans)
    elif align in ['left', 'bottom']:
        yspan = (0, height)
        offsets = [-y0 for (y0, y1) in yspans]
    elif align in ['right', 'top']:
        yspan = (0, height)
        offsets = [height - y1 for (y0, y1) in yspans]
    elif align == 'center':
        yspan = (0, height)
        offsets = [(height - (y1 - y0)) * 0.5 - y0 for (y0, y1) in yspans]
    return (yspan, offsets)

class OffsetBox(martist.Artist):

    def __init__(self, *args, **kwargs):
        super().__init__(*args)
        self._internal_update(kwargs)
        self.set_clip_on(False)
        self._children = []
        self._offset = (0, 0)

    def set_figure(self, fig):
        super().set_figure(fig)
        for c in self.get_children():
            c.set_figure(fig)

    @martist.Artist.axes.setter
    def axes(self, ax):
        martist.Artist.axes.fset(self, ax)
        for c in self.get_children():
            if c is not None:
                c.axes = ax

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        for c in self.get_children():
            (a, b) = c.contains(mouseevent)
            if a:
                return (a, b)
        return (False, {})

    def set_offset(self, xy):
        self._offset = xy
        self.stale = True

    @_compat_get_offset
    def get_offset(self, bbox, renderer):
        return self._offset(bbox.width, bbox.height, -bbox.x0, -bbox.y0, renderer) if callable(self._offset) else self._offset

    def set_width(self, width):
        self.width = width
        self.stale = True

    def set_height(self, height):
        self.height = height
        self.stale = True

    def get_visible_children(self):
        return [c for c in self._children if c.get_visible()]

    def get_children(self):
        return self._children

    def _get_bbox_and_child_offsets(self, renderer):
        raise NotImplementedError('get_bbox_and_offsets must be overridden in derived classes')

    def get_bbox(self, renderer):
        (bbox, offsets) = self._get_bbox_and_child_offsets(renderer)
        return bbox

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        bbox = self.get_bbox(renderer)
        try:
            (px, py) = self.get_offset(bbox, renderer)
        except TypeError:
            (px, py) = self.get_offset()
        return bbox.translated(px, py)

    def draw(self, renderer):
        (bbox, offsets) = self._get_bbox_and_child_offsets(renderer)
        (px, py) = self.get_offset(bbox, renderer)
        for (c, (ox, oy)) in zip(self.get_visible_children(), offsets):
            c.set_offset((px + ox, py + oy))
            c.draw(renderer)
        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.0))
        self.stale = False

class PackerBase(OffsetBox):

    def __init__(self, pad=0.0, sep=0.0, width=None, height=None, align='baseline', mode='fixed', children=None):
        super().__init__()
        self.height = height
        self.width = width
        self.sep = sep
        self.pad = pad
        self.mode = mode
        self.align = align
        self._children = children

class VPacker(PackerBase):

    def _get_bbox_and_child_offsets(self, renderer):
        dpicor = renderer.points_to_pixels(1.0)
        pad = self.pad * dpicor
        sep = self.sep * dpicor
        if self.width is not None:
            for c in self.get_visible_children():
                if isinstance(c, PackerBase) and c.mode == 'expand':
                    c.set_width(self.width)
        bboxes = [c.get_bbox(renderer) for c in self.get_visible_children()]
        ((x0, x1), xoffsets) = _get_aligned_offsets([bbox.intervalx for bbox in bboxes], self.width, self.align)
        (height, yoffsets) = _get_packed_offsets([bbox.height for bbox in bboxes], self.height, sep, self.mode)
        yoffsets = height - (yoffsets + [bbox.y1 for bbox in bboxes])
        ydescent = yoffsets[0]
        yoffsets = yoffsets - ydescent
        return (Bbox.from_bounds(x0, -ydescent, x1 - x0, height).padded(pad), [*zip(xoffsets, yoffsets)])

class HPacker(PackerBase):

    def _get_bbox_and_child_offsets(self, renderer):
        dpicor = renderer.points_to_pixels(1.0)
        pad = self.pad * dpicor
        sep = self.sep * dpicor
        bboxes = [c.get_bbox(renderer) for c in self.get_visible_children()]
        if not bboxes:
            return (Bbox.from_bounds(0, 0, 0, 0).padded(pad), [])
        ((y0, y1), yoffsets) = _get_aligned_offsets([bbox.intervaly for bbox in bboxes], self.height, self.align)
        (width, xoffsets) = _get_packed_offsets([bbox.width for bbox in bboxes], self.width, sep, self.mode)
        x0 = bboxes[0].x0
        xoffsets -= [bbox.x0 for bbox in bboxes] - x0
        return (Bbox.from_bounds(x0, y0, width, y1 - y0).padded(pad), [*zip(xoffsets, yoffsets)])

class PaddedBox(OffsetBox):

    def __init__(self, child, pad=0.0, *, draw_frame=False, patch_attrs=None):
        super().__init__()
        self.pad = pad
        self._children = [child]
        self.patch = FancyBboxPatch(xy=(0.0, 0.0), width=1.0, height=1.0, facecolor='w', edgecolor='k', mutation_scale=1, snap=True, visible=draw_frame, boxstyle='square,pad=0')
        if patch_attrs is not None:
            self.patch.update(patch_attrs)

    def _get_bbox_and_child_offsets(self, renderer):
        pad = self.pad * renderer.points_to_pixels(1.0)
        return (self._children[0].get_bbox(renderer).padded(pad), [(0, 0)])

    def draw(self, renderer):
        (bbox, offsets) = self._get_bbox_and_child_offsets(renderer)
        (px, py) = self.get_offset(bbox, renderer)
        for (c, (ox, oy)) in zip(self.get_visible_children(), offsets):
            c.set_offset((px + ox, py + oy))
        self.draw_frame(renderer)
        for c in self.get_visible_children():
            c.draw(renderer)
        self.stale = False

    def update_frame(self, bbox, fontsize=None):
        self.patch.set_bounds(bbox.bounds)
        if fontsize:
            self.patch.set_mutation_scale(fontsize)
        self.stale = True

    def draw_frame(self, renderer):
        self.update_frame(self.get_window_extent(renderer))
        self.patch.draw(renderer)

class DrawingArea(OffsetBox):

    def __init__(self, width, height, xdescent=0.0, ydescent=0.0, clip=False):
        super().__init__()
        self.width = width
        self.height = height
        self.xdescent = xdescent
        self.ydescent = ydescent
        self._clip_children = clip
        self.offset_transform = mtransforms.Affine2D()
        self.dpi_transform = mtransforms.Affine2D()

    @property
    def clip_children(self):
        return self._clip_children

    @clip_children.setter
    def clip_children(self, val):
        self._clip_children = bool(val)
        self.stale = True

    def get_transform(self):
        return self.dpi_transform + self.offset_transform

    def set_transform(self, t):

    def set_offset(self, xy):
        self._offset = xy
        self.offset_transform.clear()
        self.offset_transform.translate(xy[0], xy[1])
        self.stale = True

    def get_offset(self):
        return self._offset

    def get_bbox(self, renderer):
        dpi_cor = renderer.points_to_pixels(1.0)
        return Bbox.from_bounds(-self.xdescent * dpi_cor, -self.ydescent * dpi_cor, self.width * dpi_cor, self.height * dpi_cor)

    def add_artist(self, a):
        self._children.append(a)
        if not a.is_transform_set():
            a.set_transform(self.get_transform())
        if self.axes is not None:
            a.axes = self.axes
        fig = self.get_figure(root=False)
        if fig is not None:
            a.set_figure(fig)

    def draw(self, renderer):
        dpi_cor = renderer.points_to_pixels(1.0)
        self.dpi_transform.clear()
        self.dpi_transform.scale(dpi_cor)
        tpath = mtransforms.TransformedPath(mpath.Path([[0, 0], [0, self.height], [self.width, self.height], [self.width, 0]]), self.get_transform())
        for c in self._children:
            if self._clip_children and (not (c.clipbox or c._clippath)):
                c.set_clip_path(tpath)
            c.draw(renderer)
        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.0))
        self.stale = False

class TextArea(OffsetBox):

    def __init__(self, s, *, textprops=None, multilinebaseline=False):
        if textprops is None:
            textprops = {}
        self._text = mtext.Text(0, 0, s, **textprops)
        super().__init__()
        self._children = [self._text]
        self.offset_transform = mtransforms.Affine2D()
        self._baseline_transform = mtransforms.Affine2D()
        self._text.set_transform(self.offset_transform + self._baseline_transform)
        self._multilinebaseline = multilinebaseline

    def set_text(self, s):
        self._text.set_text(s)
        self.stale = True

    def get_text(self):
        return self._text.get_text()

    def set_multilinebaseline(self, t):
        self._multilinebaseline = t
        self.stale = True

    def get_multilinebaseline(self):
        return self._multilinebaseline

    def set_transform(self, t):

    def set_offset(self, xy):
        self._offset = xy
        self.offset_transform.clear()
        self.offset_transform.translate(xy[0], xy[1])
        self.stale = True

    def get_offset(self):
        return self._offset

    def get_bbox(self, renderer):
        (_, h_, d_) = renderer.get_text_width_height_descent('lp', self._text._fontproperties, ismath='TeX' if self._text.get_usetex() else False)
        (bbox, info, yd) = self._text._get_layout(renderer)
        (w, h) = bbox.size
        self._baseline_transform.clear()
        if len(info) > 1 and self._multilinebaseline:
            yd_new = 0.5 * h - 0.5 * (h_ - d_)
            self._baseline_transform.translate(0, yd - yd_new)
            yd = yd_new
        else:
            h_d = max(h_ - d_, h - yd)
            h = h_d + yd
        ha = self._text.get_horizontalalignment()
        x0 = {'left': 0, 'center': -w / 2, 'right': -w}[ha]
        return Bbox.from_bounds(x0, -yd, w, h)

    def draw(self, renderer):
        self._text.draw(renderer)
        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.0))
        self.stale = False

class AuxTransformBox(OffsetBox):

    def __init__(self, aux_transform):
        self.aux_transform = aux_transform
        super().__init__()
        self.offset_transform = mtransforms.Affine2D()
        self.ref_offset_transform = mtransforms.Affine2D()

    def add_artist(self, a):
        self._children.append(a)
        a.set_transform(self.get_transform())
        self.stale = True

    def get_transform(self):
        return self.aux_transform + self.ref_offset_transform + self.offset_transform

    def set_transform(self, t):

    def set_offset(self, xy):
        self._offset = xy
        self.offset_transform.clear()
        self.offset_transform.translate(xy[0], xy[1])
        self.stale = True

    def get_offset(self):
        return self._offset

    def get_bbox(self, renderer):
        _off = self.offset_transform.get_matrix()
        self.ref_offset_transform.clear()
        self.offset_transform.clear()
        bboxes = [c.get_window_extent(renderer) for c in self._children]
        ub = Bbox.union(bboxes)
        self.ref_offset_transform.translate(-ub.x0, -ub.y0)
        self.offset_transform.set_matrix(_off)
        return Bbox.from_bounds(0, 0, ub.width, ub.height)

    def draw(self, renderer):
        for c in self._children:
            c.draw(renderer)
        _bbox_artist(self, renderer, fill=False, props=dict(pad=0.0))
        self.stale = False

class AnchoredOffsetbox(OffsetBox):
    zorder = 5
    codes = {'upper right': 1, 'upper left': 2, 'lower left': 3, 'lower right': 4, 'right': 5, 'center left': 6, 'center right': 7, 'lower center': 8, 'upper center': 9, 'center': 10}

    def __init__(self, loc, *, pad=0.4, borderpad=0.5, child=None, prop=None, frameon=True, bbox_to_anchor=None, bbox_transform=None, **kwargs):
        super().__init__(**kwargs)
        self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
        self.set_child(child)
        if isinstance(loc, str):
            loc = _api.check_getitem(self.codes, loc=loc)
        self.loc = loc
        self.borderpad = borderpad
        self.pad = pad
        if prop is None:
            self.prop = FontProperties(size=mpl.rcParams['legend.fontsize'])
        else:
            self.prop = FontProperties._from_any(prop)
            if isinstance(prop, dict) and 'size' not in prop:
                self.prop.set_size(mpl.rcParams['legend.fontsize'])
        self.patch = FancyBboxPatch(xy=(0.0, 0.0), width=1.0, height=1.0, facecolor='w', edgecolor='k', mutation_scale=self.prop.get_size_in_points(), snap=True, visible=frameon, boxstyle='square,pad=0')

    def set_child(self, child):
        self._child = child
        if child is not None:
            child.axes = self.axes
        self.stale = True

    def get_child(self):
        return self._child

    def get_children(self):
        return [self._child]

    def get_bbox(self, renderer):
        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
        pad = self.pad * fontsize
        return self.get_child().get_bbox(renderer).padded(pad)

    def get_bbox_to_anchor(self):
        if self._bbox_to_anchor is None:
            return self.axes.bbox
        else:
            transform = self._bbox_to_anchor_transform
            if transform is None:
                return self._bbox_to_anchor
            else:
                return TransformedBbox(self._bbox_to_anchor, transform)

    def set_bbox_to_anchor(self, bbox, transform=None):
        if bbox is None or isinstance(bbox, BboxBase):
            self._bbox_to_anchor = bbox
        else:
            try:
                l = len(bbox)
            except TypeError as err:
                raise ValueError(f'Invalid bbox: {bbox}') from err
            if l == 2:
                bbox = [bbox[0], bbox[1], 0, 0]
            self._bbox_to_anchor = Bbox.from_bounds(*bbox)
        self._bbox_to_anchor_transform = transform
        self.stale = True

    @_compat_get_offset
    def get_offset(self, bbox, renderer):
        pad = self.borderpad * renderer.points_to_pixels(self.prop.get_size_in_points())
        bbox_to_anchor = self.get_bbox_to_anchor()
        (x0, y0) = _get_anchored_bbox(self.loc, Bbox.from_bounds(0, 0, bbox.width, bbox.height), bbox_to_anchor, pad)
        return (x0 - bbox.x0, y0 - bbox.y0)

    def update_frame(self, bbox, fontsize=None):
        self.patch.set_bounds(bbox.bounds)
        if fontsize:
            self.patch.set_mutation_scale(fontsize)

    def draw(self, renderer):
        if not self.get_visible():
            return
        bbox = self.get_window_extent(renderer)
        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
        self.update_frame(bbox, fontsize)
        self.patch.draw(renderer)
        (px, py) = self.get_offset(self.get_bbox(renderer), renderer)
        self.get_child().set_offset((px, py))
        self.get_child().draw(renderer)
        self.stale = False

def _get_anchored_bbox(loc, bbox, parentbbox, borderpad):
    c = [None, 'NE', 'NW', 'SW', 'SE', 'E', 'W', 'E', 'S', 'N', 'C'][loc]
    container = parentbbox.padded(-borderpad)
    return bbox.anchored(c, container=container).p0

class AnchoredText(AnchoredOffsetbox):

    def __init__(self, s, loc, *, pad=0.4, borderpad=0.5, prop=None, **kwargs):
        if prop is None:
            prop = {}
        badkwargs = {'va', 'verticalalignment'}
        if badkwargs & set(prop):
            raise ValueError('Mixing verticalalignment with AnchoredText is not supported.')
        self.txt = TextArea(s, textprops=prop)
        fp = self.txt._text.get_fontproperties()
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self.txt, prop=fp, **kwargs)

class OffsetImage(OffsetBox):

    def __init__(self, arr, *, zoom=1, cmap=None, norm=None, interpolation=None, origin=None, filternorm=True, filterrad=4.0, resample=False, dpi_cor=True, **kwargs):
        super().__init__()
        self._dpi_cor = dpi_cor
        self.image = BboxImage(bbox=self.get_window_extent, cmap=cmap, norm=norm, interpolation=interpolation, origin=origin, filternorm=filternorm, filterrad=filterrad, resample=resample, **kwargs)
        self._children = [self.image]
        self.set_zoom(zoom)
        self.set_data(arr)

    def set_data(self, arr):
        self._data = np.asarray(arr)
        self.image.set_data(self._data)
        self.stale = True

    def get_data(self):
        return self._data

    def set_zoom(self, zoom):
        self._zoom = zoom
        self.stale = True

    def get_zoom(self):
        return self._zoom

    def get_offset(self):
        return self._offset

    def get_children(self):
        return [self.image]

    def get_bbox(self, renderer):
        dpi_cor = renderer.points_to_pixels(1.0) if self._dpi_cor else 1.0
        zoom = self.get_zoom()
        data = self.get_data()
        (ny, nx) = data.shape[:2]
        (w, h) = (dpi_cor * nx * zoom, dpi_cor * ny * zoom)
        return Bbox.from_bounds(0, 0, w, h)

    def draw(self, renderer):
        self.image.draw(renderer)
        self.stale = False

class AnnotationBbox(martist.Artist, mtext._AnnotationBase):
    zorder = 3

    def __str__(self):
        return f'AnnotationBbox({self.xy[0]:g},{self.xy[1]:g})'

    @_docstring.dedent_interpd
    def __init__(self, offsetbox, xy, xybox=None, xycoords='data', boxcoords=None, *, frameon=True, pad=0.4, annotation_clip=None, box_alignment=(0.5, 0.5), bboxprops=None, arrowprops=None, fontsize=None, **kwargs):
        martist.Artist.__init__(self)
        mtext._AnnotationBase.__init__(self, xy, xycoords=xycoords, annotation_clip=annotation_clip)
        self.offsetbox = offsetbox
        self.arrowprops = arrowprops.copy() if arrowprops is not None else None
        self.set_fontsize(fontsize)
        self.xybox = xybox if xybox is not None else xy
        self.boxcoords = boxcoords if boxcoords is not None else xycoords
        self._box_alignment = box_alignment
        if arrowprops is not None:
            self._arrow_relpos = self.arrowprops.pop('relpos', (0.5, 0.5))
            self.arrow_patch = FancyArrowPatch((0, 0), (1, 1), **self.arrowprops)
        else:
            self._arrow_relpos = None
            self.arrow_patch = None
        self.patch = FancyBboxPatch(xy=(0.0, 0.0), width=1.0, height=1.0, facecolor='w', edgecolor='k', mutation_scale=self.prop.get_size_in_points(), snap=True, visible=frameon)
        self.patch.set_boxstyle('square', pad=pad)
        if bboxprops:
            self.patch.set(**bboxprops)
        self._internal_update(kwargs)

    @property
    def xyann(self):
        return self.xybox

    @xyann.setter
    def xyann(self, xyann):
        self.xybox = xyann
        self.stale = True

    @property
    def anncoords(self):
        return self.boxcoords

    @anncoords.setter
    def anncoords(self, coords):
        self.boxcoords = coords
        self.stale = True

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        if not self._check_xy(None):
            return (False, {})
        return self.offsetbox.contains(mouseevent)

    def get_children(self):
        children = [self.offsetbox, self.patch]
        if self.arrow_patch:
            children.append(self.arrow_patch)
        return children

    def set_figure(self, fig):
        if self.arrow_patch is not None:
            self.arrow_patch.set_figure(fig)
        self.offsetbox.set_figure(fig)
        martist.Artist.set_figure(self, fig)

    def set_fontsize(self, s=None):
        if s is None:
            s = mpl.rcParams['legend.fontsize']
        self.prop = FontProperties(size=s)
        self.stale = True

    def get_fontsize(self):
        return self.prop.get_size_in_points()

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        self.update_positions(renderer)
        return Bbox.union([child.get_window_extent(renderer) for child in self.get_children()])

    def get_tightbbox(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        self.update_positions(renderer)
        return Bbox.union([child.get_tightbbox(renderer) for child in self.get_children()])

    def update_positions(self, renderer):
        (ox0, oy0) = self._get_xy(renderer, self.xybox, self.boxcoords)
        bbox = self.offsetbox.get_bbox(renderer)
        (fw, fh) = self._box_alignment
        self.offsetbox.set_offset((ox0 - fw * bbox.width - bbox.x0, oy0 - fh * bbox.height - bbox.y0))
        bbox = self.offsetbox.get_window_extent(renderer)
        self.patch.set_bounds(bbox.bounds)
        mutation_scale = renderer.points_to_pixels(self.get_fontsize())
        self.patch.set_mutation_scale(mutation_scale)
        if self.arrowprops:
            arrow_begin = bbox.p0 + bbox.size * self._arrow_relpos
            arrow_end = self._get_position_xy(renderer)
            self.arrow_patch.set_positions(arrow_begin, arrow_end)
            if 'mutation_scale' in self.arrowprops:
                mutation_scale = renderer.points_to_pixels(self.arrowprops['mutation_scale'])
            self.arrow_patch.set_mutation_scale(mutation_scale)
            patchA = self.arrowprops.get('patchA', self.patch)
            self.arrow_patch.set_patchA(patchA)

    def draw(self, renderer):
        if not self.get_visible() or not self._check_xy(renderer):
            return
        renderer.open_group(self.__class__.__name__, gid=self.get_gid())
        self.update_positions(renderer)
        if self.arrow_patch is not None:
            if self.arrow_patch.get_figure(root=False) is None and (fig := self.get_figure(root=False)) is not None:
                self.arrow_patch.set_figure(fig)
            self.arrow_patch.draw(renderer)
        self.patch.draw(renderer)
        self.offsetbox.draw(renderer)
        renderer.close_group(self.__class__.__name__)
        self.stale = False

class DraggableBase:

    def __init__(self, ref_artist, use_blit=False):
        self.ref_artist = ref_artist
        if not ref_artist.pickable():
            ref_artist.set_picker(True)
        self.got_artist = False
        self._use_blit = use_blit and self.canvas.supports_blit
        callbacks = self.canvas.callbacks
        self._disconnectors = [functools.partial(callbacks.disconnect, callbacks._connect_picklable(name, func)) for (name, func) in [('pick_event', self.on_pick), ('button_release_event', self.on_release), ('motion_notify_event', self.on_motion)]]
    canvas = property(lambda self: self.ref_artist.get_figure(root=True).canvas)
    cids = property(lambda self: [disconnect.args[0] for disconnect in self._disconnectors[:2]])

    def on_motion(self, evt):
        if self._check_still_parented() and self.got_artist:
            dx = evt.x - self.mouse_x
            dy = evt.y - self.mouse_y
            self.update_offset(dx, dy)
            if self._use_blit:
                self.canvas.restore_region(self.background)
                self.ref_artist.draw(self.ref_artist.get_figure(root=True)._get_renderer())
                self.canvas.blit()
            else:
                self.canvas.draw()

    def on_pick(self, evt):
        if self._check_still_parented():
            if evt.artist == self.ref_artist:
                self.mouse_x = evt.mouseevent.x
                self.mouse_y = evt.mouseevent.y
                self.save_offset()
                self.got_artist = True
            if self.got_artist and self._use_blit:
                self.ref_artist.set_animated(True)
                self.canvas.draw()
                fig = self.ref_artist.get_figure(root=False)
                self.background = self.canvas.copy_from_bbox(fig.bbox)
                self.ref_artist.draw(fig._get_renderer())
                self.canvas.blit()

    def on_release(self, event):
        if self._check_still_parented() and self.got_artist:
            self.finalize_offset()
            self.got_artist = False
            if self._use_blit:
                self.canvas.restore_region(self.background)
                self.ref_artist.draw(self.ref_artist.figure._get_renderer())
                self.canvas.blit()
                self.ref_artist.set_animated(False)

    def _check_still_parented(self):
        if self.ref_artist.get_figure(root=False) is None:
            self.disconnect()
            return False
        else:
            return True

    def disconnect(self):
        for disconnector in self._disconnectors:
            disconnector()

    def save_offset(self):
        pass

    def update_offset(self, dx, dy):
        pass

    def finalize_offset(self):
        pass

class DraggableOffsetBox(DraggableBase):

    def __init__(self, ref_artist, offsetbox, use_blit=False):
        super().__init__(ref_artist, use_blit=use_blit)
        self.offsetbox = offsetbox

    def save_offset(self):
        offsetbox = self.offsetbox
        renderer = offsetbox.get_figure(root=True)._get_renderer()
        offset = offsetbox.get_offset(offsetbox.get_bbox(renderer), renderer)
        (self.offsetbox_x, self.offsetbox_y) = offset
        self.offsetbox.set_offset(offset)

    def update_offset(self, dx, dy):
        loc_in_canvas = (self.offsetbox_x + dx, self.offsetbox_y + dy)
        self.offsetbox.set_offset(loc_in_canvas)

    def get_loc_in_canvas(self):
        offsetbox = self.offsetbox
        renderer = offsetbox.get_figure(root=True)._get_renderer()
        bbox = offsetbox.get_bbox(renderer)
        (ox, oy) = offsetbox._offset
        loc_in_canvas = (ox + bbox.x0, oy + bbox.y0)
        return loc_in_canvas

class DraggableAnnotation(DraggableBase):

    def __init__(self, annotation, use_blit=False):
        super().__init__(annotation, use_blit=use_blit)
        self.annotation = annotation

    def save_offset(self):
        ann = self.annotation
        (self.ox, self.oy) = ann.get_transform().transform(ann.xyann)

    def update_offset(self, dx, dy):
        ann = self.annotation
        ann.xyann = ann.get_transform().inverted().transform((self.ox + dx, self.oy + dy))

# File: matplotlib-main/lib/matplotlib/patches.py
""""""
import functools
import inspect
import math
from numbers import Number, Real
import textwrap
from types import SimpleNamespace
from collections import namedtuple
from matplotlib.transforms import Affine2D
import numpy as np
import matplotlib as mpl
from . import _api, artist, cbook, colors, _docstring, hatch as mhatch, lines as mlines, transforms
from .bezier import NonIntersectingPathException, get_cos_sin, get_intersection, get_parallels, inside_circle, make_wedged_bezier2, split_bezier_intersecting_with_closedpath, split_path_inout
from .path import Path
from ._enums import JoinStyle, CapStyle

@_docstring.interpd
@_api.define_aliases({'antialiased': ['aa'], 'edgecolor': ['ec'], 'facecolor': ['fc'], 'linestyle': ['ls'], 'linewidth': ['lw']})
class Patch(artist.Artist):
    zorder = 1
    _edge_default = False

    def __init__(self, *, edgecolor=None, facecolor=None, color=None, linewidth=None, linestyle=None, antialiased=None, hatch=None, fill=True, capstyle=None, joinstyle=None, **kwargs):
        super().__init__()
        if linestyle is None:
            linestyle = 'solid'
        if capstyle is None:
            capstyle = CapStyle.butt
        if joinstyle is None:
            joinstyle = JoinStyle.miter
        self._hatch_color = colors.to_rgba(mpl.rcParams['hatch.color'])
        self._fill = bool(fill)
        if color is not None:
            if edgecolor is not None or facecolor is not None:
                _api.warn_external("Setting the 'color' property will override the edgecolor or facecolor properties.")
            self.set_color(color)
        else:
            self.set_edgecolor(edgecolor)
            self.set_facecolor(facecolor)
        self._linewidth = 0
        self._unscaled_dash_pattern = (0, None)
        self._dash_pattern = (0, None)
        self.set_linestyle(linestyle)
        self.set_linewidth(linewidth)
        self.set_antialiased(antialiased)
        self.set_hatch(hatch)
        self.set_capstyle(capstyle)
        self.set_joinstyle(joinstyle)
        if len(kwargs):
            self._internal_update(kwargs)

    def get_verts(self):
        trans = self.get_transform()
        path = self.get_path()
        polygons = path.to_polygons(trans)
        if len(polygons):
            return polygons[0]
        return []

    def _process_radius(self, radius):
        if radius is not None:
            return radius
        if isinstance(self._picker, Number):
            _radius = self._picker
        elif self.get_edgecolor()[3] == 0:
            _radius = 0
        else:
            _radius = self.get_linewidth()
        return _radius

    def contains(self, mouseevent, radius=None):
        if self._different_canvas(mouseevent):
            return (False, {})
        radius = self._process_radius(radius)
        codes = self.get_path().codes
        if codes is not None:
            vertices = self.get_path().vertices
            (idxs,) = np.where(codes == Path.MOVETO)
            idxs = idxs[1:]
            subpaths = map(Path, np.split(vertices, idxs), np.split(codes, idxs))
        else:
            subpaths = [self.get_path()]
        inside = any((subpath.contains_point((mouseevent.x, mouseevent.y), self.get_transform(), radius) for subpath in subpaths))
        return (inside, {})

    def contains_point(self, point, radius=None):
        radius = self._process_radius(radius)
        return self.get_path().contains_point(point, self.get_transform(), radius)

    def contains_points(self, points, radius=None):
        radius = self._process_radius(radius)
        return self.get_path().contains_points(points, self.get_transform(), radius)

    def update_from(self, other):
        super().update_from(other)
        self._edgecolor = other._edgecolor
        self._facecolor = other._facecolor
        self._original_edgecolor = other._original_edgecolor
        self._original_facecolor = other._original_facecolor
        self._fill = other._fill
        self._hatch = other._hatch
        self._hatch_color = other._hatch_color
        self._unscaled_dash_pattern = other._unscaled_dash_pattern
        self.set_linewidth(other._linewidth)
        self.set_transform(other.get_data_transform())
        self._transformSet = other.is_transform_set()

    def get_extents(self):
        return self.get_path().get_extents(self.get_transform())

    def get_transform(self):
        return self.get_patch_transform() + artist.Artist.get_transform(self)

    def get_data_transform(self):
        return artist.Artist.get_transform(self)

    def get_patch_transform(self):
        return transforms.IdentityTransform()

    def get_antialiased(self):
        return self._antialiased

    def get_edgecolor(self):
        return self._edgecolor

    def get_facecolor(self):
        return self._facecolor

    def get_linewidth(self):
        return self._linewidth

    def get_linestyle(self):
        return self._linestyle

    def set_antialiased(self, aa):
        if aa is None:
            aa = mpl.rcParams['patch.antialiased']
        self._antialiased = aa
        self.stale = True

    def _set_edgecolor(self, color):
        set_hatch_color = True
        if color is None:
            if mpl.rcParams['patch.force_edgecolor'] or not self._fill or self._edge_default:
                color = mpl.rcParams['patch.edgecolor']
            else:
                color = 'none'
                set_hatch_color = False
        self._edgecolor = colors.to_rgba(color, self._alpha)
        if set_hatch_color:
            self._hatch_color = self._edgecolor
        self.stale = True

    def set_edgecolor(self, color):
        self._original_edgecolor = color
        self._set_edgecolor(color)

    def _set_facecolor(self, color):
        if color is None:
            color = mpl.rcParams['patch.facecolor']
        alpha = self._alpha if self._fill else 0
        self._facecolor = colors.to_rgba(color, alpha)
        self.stale = True

    def set_facecolor(self, color):
        self._original_facecolor = color
        self._set_facecolor(color)

    def set_color(self, c):
        self.set_facecolor(c)
        self.set_edgecolor(c)

    def set_alpha(self, alpha):
        super().set_alpha(alpha)
        self._set_facecolor(self._original_facecolor)
        self._set_edgecolor(self._original_edgecolor)

    def set_linewidth(self, w):
        if w is None:
            w = mpl.rcParams['patch.linewidth']
        self._linewidth = float(w)
        self._dash_pattern = mlines._scale_dashes(*self._unscaled_dash_pattern, w)
        self.stale = True

    def set_linestyle(self, ls):
        if ls is None:
            ls = 'solid'
        if ls in [' ', '', 'none']:
            ls = 'None'
        self._linestyle = ls
        self._unscaled_dash_pattern = mlines._get_dash_pattern(ls)
        self._dash_pattern = mlines._scale_dashes(*self._unscaled_dash_pattern, self._linewidth)
        self.stale = True

    def set_fill(self, b):
        self._fill = bool(b)
        self._set_facecolor(self._original_facecolor)
        self._set_edgecolor(self._original_edgecolor)
        self.stale = True

    def get_fill(self):
        return self._fill
    fill = property(get_fill, set_fill)

    @_docstring.interpd
    def set_capstyle(self, s):
        cs = CapStyle(s)
        self._capstyle = cs
        self.stale = True

    def get_capstyle(self):
        return self._capstyle.name

    @_docstring.interpd
    def set_joinstyle(self, s):
        js = JoinStyle(s)
        self._joinstyle = js
        self.stale = True

    def get_joinstyle(self):
        return self._joinstyle.name

    def set_hatch(self, hatch):
        mhatch._validate_hatch_pattern(hatch)
        self._hatch = hatch
        self.stale = True

    def get_hatch(self):
        return self._hatch

    def _draw_paths_with_artist_properties(self, renderer, draw_path_args_list):
        renderer.open_group('patch', self.get_gid())
        gc = renderer.new_gc()
        gc.set_foreground(self._edgecolor, isRGBA=True)
        lw = self._linewidth
        if self._edgecolor[3] == 0 or self._linestyle == 'None':
            lw = 0
        gc.set_linewidth(lw)
        gc.set_dashes(*self._dash_pattern)
        gc.set_capstyle(self._capstyle)
        gc.set_joinstyle(self._joinstyle)
        gc.set_antialiased(self._antialiased)
        self._set_gc_clip(gc)
        gc.set_url(self._url)
        gc.set_snap(self.get_snap())
        gc.set_alpha(self._alpha)
        if self._hatch:
            gc.set_hatch(self._hatch)
            gc.set_hatch_color(self._hatch_color)
        if self.get_sketch_params() is not None:
            gc.set_sketch_params(*self.get_sketch_params())
        if self.get_path_effects():
            from matplotlib.patheffects import PathEffectRenderer
            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
        for draw_path_args in draw_path_args_list:
            renderer.draw_path(gc, *draw_path_args)
        gc.restore()
        renderer.close_group('patch')
        self.stale = False

    @artist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        path = self.get_path()
        transform = self.get_transform()
        tpath = transform.transform_path_non_affine(path)
        affine = transform.get_affine()
        self._draw_paths_with_artist_properties(renderer, [(tpath, affine, self._facecolor if self._facecolor[3] else None)])

    def get_path(self):
        raise NotImplementedError('Derived must override')

    def get_window_extent(self, renderer=None):
        return self.get_path().get_extents(self.get_transform())

    def _convert_xy_units(self, xy):
        x = self.convert_xunits(xy[0])
        y = self.convert_yunits(xy[1])
        return (x, y)

class Shadow(Patch):

    def __str__(self):
        return f'Shadow({self.patch})'

    @_docstring.dedent_interpd
    def __init__(self, patch, ox, oy, *, shade=0.7, **kwargs):
        super().__init__()
        self.patch = patch
        (self._ox, self._oy) = (ox, oy)
        self._shadow_transform = transforms.Affine2D()
        self.update_from(self.patch)
        if not 0 <= shade <= 1:
            raise ValueError('shade must be between 0 and 1.')
        color = (1 - shade) * np.asarray(colors.to_rgb(self.patch.get_facecolor()))
        self.update({'facecolor': color, 'edgecolor': color, 'alpha': 0.5, 'zorder': np.nextafter(self.patch.zorder, -np.inf), **kwargs})

    def _update_transform(self, renderer):
        ox = renderer.points_to_pixels(self._ox)
        oy = renderer.points_to_pixels(self._oy)
        self._shadow_transform.clear().translate(ox, oy)

    def get_path(self):
        return self.patch.get_path()

    def get_patch_transform(self):
        return self.patch.get_patch_transform() + self._shadow_transform

    def draw(self, renderer):
        self._update_transform(renderer)
        super().draw(renderer)

class Rectangle(Patch):

    def __str__(self):
        pars = (self._x0, self._y0, self._width, self._height, self.angle)
        fmt = 'Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g)'
        return fmt % pars

    @_docstring.dedent_interpd
    def __init__(self, xy, width, height, *, angle=0.0, rotation_point='xy', **kwargs):
        super().__init__(**kwargs)
        self._x0 = xy[0]
        self._y0 = xy[1]
        self._width = width
        self._height = height
        self.angle = float(angle)
        self.rotation_point = rotation_point
        self._aspect_ratio_correction = 1.0
        self._convert_units()

    def get_path(self):
        return Path.unit_rectangle()

    def _convert_units(self):
        x0 = self.convert_xunits(self._x0)
        y0 = self.convert_yunits(self._y0)
        x1 = self.convert_xunits(self._x0 + self._width)
        y1 = self.convert_yunits(self._y0 + self._height)
        return (x0, y0, x1, y1)

    def get_patch_transform(self):
        bbox = self.get_bbox()
        if self.rotation_point == 'center':
            (width, height) = (bbox.x1 - bbox.x0, bbox.y1 - bbox.y0)
            rotation_point = (bbox.x0 + width / 2.0, bbox.y0 + height / 2.0)
        elif self.rotation_point == 'xy':
            rotation_point = (bbox.x0, bbox.y0)
        else:
            rotation_point = self.rotation_point
        return transforms.BboxTransformTo(bbox) + transforms.Affine2D().translate(-rotation_point[0], -rotation_point[1]).scale(1, self._aspect_ratio_correction).rotate_deg(self.angle).scale(1, 1 / self._aspect_ratio_correction).translate(*rotation_point)

    @property
    def rotation_point(self):
        return self._rotation_point

    @rotation_point.setter
    def rotation_point(self, value):
        if value in ['center', 'xy'] or (isinstance(value, tuple) and len(value) == 2 and isinstance(value[0], Real) and isinstance(value[1], Real)):
            self._rotation_point = value
        else:
            raise ValueError("`rotation_point` must be one of {'xy', 'center', (number, number)}.")

    def get_x(self):
        return self._x0

    def get_y(self):
        return self._y0

    def get_xy(self):
        return (self._x0, self._y0)

    def get_corners(self):
        return self.get_patch_transform().transform([(0, 0), (1, 0), (1, 1), (0, 1)])

    def get_center(self):
        return self.get_patch_transform().transform((0.5, 0.5))

    def get_width(self):
        return self._width

    def get_height(self):
        return self._height

    def get_angle(self):
        return self.angle

    def set_x(self, x):
        self._x0 = x
        self.stale = True

    def set_y(self, y):
        self._y0 = y
        self.stale = True

    def set_angle(self, angle):
        self.angle = angle
        self.stale = True

    def set_xy(self, xy):
        (self._x0, self._y0) = xy
        self.stale = True

    def set_width(self, w):
        self._width = w
        self.stale = True

    def set_height(self, h):
        self._height = h
        self.stale = True

    def set_bounds(self, *args):
        if len(args) == 1:
            (l, b, w, h) = args[0]
        else:
            (l, b, w, h) = args
        self._x0 = l
        self._y0 = b
        self._width = w
        self._height = h
        self.stale = True

    def get_bbox(self):
        return transforms.Bbox.from_extents(*self._convert_units())
    xy = property(get_xy, set_xy)

class RegularPolygon(Patch):

    def __str__(self):
        s = 'RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)'
        return s % (self.xy[0], self.xy[1], self.numvertices, self.radius, self.orientation)

    @_docstring.dedent_interpd
    def __init__(self, xy, numVertices, *, radius=5, orientation=0, **kwargs):
        self.xy = xy
        self.numvertices = numVertices
        self.orientation = orientation
        self.radius = radius
        self._path = Path.unit_regular_polygon(numVertices)
        self._patch_transform = transforms.Affine2D()
        super().__init__(**kwargs)

    def get_path(self):
        return self._path

    def get_patch_transform(self):
        return self._patch_transform.clear().scale(self.radius).rotate(self.orientation).translate(*self.xy)

class PathPatch(Patch):
    _edge_default = True

    def __str__(self):
        s = 'PathPatch%d((%g, %g) ...)'
        return s % (len(self._path.vertices), *tuple(self._path.vertices[0]))

    @_docstring.dedent_interpd
    def __init__(self, path, **kwargs):
        super().__init__(**kwargs)
        self._path = path

    def get_path(self):
        return self._path

    def set_path(self, path):
        self._path = path

class StepPatch(PathPatch):
    _edge_default = False

    @_docstring.dedent_interpd
    def __init__(self, values, edges, *, orientation='vertical', baseline=0, **kwargs):
        self.orientation = orientation
        self._edges = np.asarray(edges)
        self._values = np.asarray(values)
        self._baseline = np.asarray(baseline) if baseline is not None else None
        self._update_path()
        super().__init__(self._path, **kwargs)

    def _update_path(self):
        if np.isnan(np.sum(self._edges)):
            raise ValueError('Nan values in "edges" are disallowed')
        if self._edges.size - 1 != self._values.size:
            raise ValueError(f'Size mismatch between "values" and "edges". Expected `len(values) + 1 == len(edges)`, but `len(values) = {self._values.size}` and `len(edges) = {self._edges.size}`.')
        (verts, codes) = ([np.empty((0, 2))], [np.empty(0, dtype=Path.code_type)])
        _nan_mask = np.isnan(self._values)
        if self._baseline is not None:
            _nan_mask |= np.isnan(self._baseline)
        for (idx0, idx1) in cbook.contiguous_regions(~_nan_mask):
            x = np.repeat(self._edges[idx0:idx1 + 1], 2)
            y = np.repeat(self._values[idx0:idx1], 2)
            if self._baseline is None:
                y = np.concatenate([y[:1], y, y[-1:]])
            elif self._baseline.ndim == 0:
                y = np.concatenate([[self._baseline], y, [self._baseline]])
            elif self._baseline.ndim == 1:
                base = np.repeat(self._baseline[idx0:idx1], 2)[::-1]
                x = np.concatenate([x, x[::-1]])
                y = np.concatenate([base[-1:], y, base[:1], base[:1], base, base[-1:]])
            else:
                raise ValueError('Invalid `baseline` specified')
            if self.orientation == 'vertical':
                xy = np.column_stack([x, y])
            else:
                xy = np.column_stack([y, x])
            verts.append(xy)
            codes.append([Path.MOVETO] + [Path.LINETO] * (len(xy) - 1))
        self._path = Path(np.concatenate(verts), np.concatenate(codes))

    def get_data(self):
        StairData = namedtuple('StairData', 'values edges baseline')
        return StairData(self._values, self._edges, self._baseline)

    def set_data(self, values=None, edges=None, baseline=None):
        if values is None and edges is None and (baseline is None):
            raise ValueError('Must set *values*, *edges* or *baseline*.')
        if values is not None:
            self._values = np.asarray(values)
        if edges is not None:
            self._edges = np.asarray(edges)
        if baseline is not None:
            self._baseline = np.asarray(baseline)
        self._update_path()
        self.stale = True

class Polygon(Patch):

    def __str__(self):
        if len(self._path.vertices):
            s = 'Polygon%d((%g, %g) ...)'
            return s % (len(self._path.vertices), *self._path.vertices[0])
        else:
            return 'Polygon0()'

    @_docstring.dedent_interpd
    def __init__(self, xy, *, closed=True, **kwargs):
        super().__init__(**kwargs)
        self._closed = closed
        self.set_xy(xy)

    def get_path(self):
        return self._path

    def get_closed(self):
        return self._closed

    def set_closed(self, closed):
        if self._closed == bool(closed):
            return
        self._closed = bool(closed)
        self.set_xy(self.get_xy())
        self.stale = True

    def get_xy(self):
        return self._path.vertices

    def set_xy(self, xy):
        xy = np.asarray(xy)
        (nverts, _) = xy.shape
        if self._closed:
            if nverts == 1 or (nverts > 1 and (xy[0] != xy[-1]).any()):
                xy = np.concatenate([xy, [xy[0]]])
        elif nverts > 2 and (xy[0] == xy[-1]).all():
            xy = xy[:-1]
        self._path = Path(xy, closed=self._closed)
        self.stale = True
    xy = property(get_xy, set_xy, doc='The vertices of the path as a (N, 2) array.')

class Wedge(Patch):

    def __str__(self):
        pars = (self.center[0], self.center[1], self.r, self.theta1, self.theta2, self.width)
        fmt = 'Wedge(center=(%g, %g), r=%g, theta1=%g, theta2=%g, width=%s)'
        return fmt % pars

    @_docstring.dedent_interpd
    def __init__(self, center, r, theta1, theta2, *, width=None, **kwargs):
        super().__init__(**kwargs)
        self.center = center
        (self.r, self.width) = (r, width)
        (self.theta1, self.theta2) = (theta1, theta2)
        self._patch_transform = transforms.IdentityTransform()
        self._recompute_path()

    def _recompute_path(self):
        if abs(self.theta2 - self.theta1 - 360) <= 1e-12:
            (theta1, theta2) = (0, 360)
            connector = Path.MOVETO
        else:
            (theta1, theta2) = (self.theta1, self.theta2)
            connector = Path.LINETO
        arc = Path.arc(theta1, theta2)
        if self.width is not None:
            v1 = arc.vertices
            v2 = arc.vertices[::-1] * (self.r - self.width) / self.r
            v = np.concatenate([v1, v2, [(0, 0)]])
            c = [*arc.codes, connector, *arc.codes[1:], Path.CLOSEPOLY]
        else:
            v = np.concatenate([arc.vertices, [(0, 0), (0, 0)]])
            c = [*arc.codes, connector, Path.CLOSEPOLY]
        self._path = Path(v * self.r + self.center, c)

    def set_center(self, center):
        self._path = None
        self.center = center
        self.stale = True

    def set_radius(self, radius):
        self._path = None
        self.r = radius
        self.stale = True

    def set_theta1(self, theta1):
        self._path = None
        self.theta1 = theta1
        self.stale = True

    def set_theta2(self, theta2):
        self._path = None
        self.theta2 = theta2
        self.stale = True

    def set_width(self, width):
        self._path = None
        self.width = width
        self.stale = True

    def get_path(self):
        if self._path is None:
            self._recompute_path()
        return self._path

class Arrow(Patch):

    def __str__(self):
        return 'Arrow()'
    _path = Path._create_closed([[0.0, 0.1], [0.0, -0.1], [0.8, -0.1], [0.8, -0.3], [1.0, 0.0], [0.8, 0.3], [0.8, 0.1]])

    @_docstring.dedent_interpd
    def __init__(self, x, y, dx, dy, *, width=1.0, **kwargs):
        super().__init__(**kwargs)
        self.set_data(x, y, dx, dy, width)

    def get_path(self):
        return self._path

    def get_patch_transform(self):
        return self._patch_transform

    def set_data(self, x=None, y=None, dx=None, dy=None, width=None):
        if x is not None:
            self._x = x
        if y is not None:
            self._y = y
        if dx is not None:
            self._dx = dx
        if dy is not None:
            self._dy = dy
        if width is not None:
            self._width = width
        self._patch_transform = transforms.Affine2D().scale(np.hypot(self._dx, self._dy), self._width).rotate(np.arctan2(self._dy, self._dx)).translate(self._x, self._y).frozen()

class FancyArrow(Polygon):
    _edge_default = True

    def __str__(self):
        return 'FancyArrow()'

    @_docstring.dedent_interpd
    def __init__(self, x, y, dx, dy, *, width=0.001, length_includes_head=False, head_width=None, head_length=None, shape='full', overhang=0, head_starts_at_zero=False, **kwargs):
        self._x = x
        self._y = y
        self._dx = dx
        self._dy = dy
        self._width = width
        self._length_includes_head = length_includes_head
        self._head_width = head_width
        self._head_length = head_length
        self._shape = shape
        self._overhang = overhang
        self._head_starts_at_zero = head_starts_at_zero
        self._make_verts()
        super().__init__(self.verts, closed=True, **kwargs)

    def set_data(self, *, x=None, y=None, dx=None, dy=None, width=None, head_width=None, head_length=None):
        if x is not None:
            self._x = x
        if y is not None:
            self._y = y
        if dx is not None:
            self._dx = dx
        if dy is not None:
            self._dy = dy
        if width is not None:
            self._width = width
        if head_width is not None:
            self._head_width = head_width
        if head_length is not None:
            self._head_length = head_length
        self._make_verts()
        self.set_xy(self.verts)

    def _make_verts(self):
        if self._head_width is None:
            head_width = 3 * self._width
        else:
            head_width = self._head_width
        if self._head_length is None:
            head_length = 1.5 * head_width
        else:
            head_length = self._head_length
        distance = np.hypot(self._dx, self._dy)
        if self._length_includes_head:
            length = distance
        else:
            length = distance + head_length
        if not length:
            self.verts = np.empty([0, 2])
        else:
            (hw, hl) = (head_width, head_length)
            (hs, lw) = (self._overhang, self._width)
            left_half_arrow = np.array([[0.0, 0.0], [-hl, -hw / 2], [-hl * (1 - hs), -lw / 2], [-length, -lw / 2], [-length, 0]])
            if not self._length_includes_head:
                left_half_arrow += [head_length, 0]
            if self._head_starts_at_zero:
                left_half_arrow += [head_length / 2, 0]
            if self._shape == 'left':
                coords = left_half_arrow
            else:
                right_half_arrow = left_half_arrow * [1, -1]
                if self._shape == 'right':
                    coords = right_half_arrow
                elif self._shape == 'full':
                    coords = np.concatenate([left_half_arrow[:-1], right_half_arrow[-2::-1]])
                else:
                    raise ValueError(f'Got unknown shape: {self._shape!r}')
            if distance != 0:
                cx = self._dx / distance
                sx = self._dy / distance
            else:
                (cx, sx) = (0, 1)
            M = [[cx, sx], [-sx, cx]]
            self.verts = np.dot(coords, M) + [self._x + self._dx, self._y + self._dy]
_docstring.interpd.update(FancyArrow='\n'.join((inspect.getdoc(FancyArrow.__init__) or '').splitlines()[2:]))

class CirclePolygon(RegularPolygon):

    def __str__(self):
        s = 'CirclePolygon((%g, %g), radius=%g, resolution=%d)'
        return s % (self.xy[0], self.xy[1], self.radius, self.numvertices)

    @_docstring.dedent_interpd
    def __init__(self, xy, radius=5, *, resolution=20, **kwargs):
        super().__init__(xy, resolution, radius=radius, orientation=0, **kwargs)

class Ellipse(Patch):

    def __str__(self):
        pars = (self._center[0], self._center[1], self.width, self.height, self.angle)
        fmt = 'Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s)'
        return fmt % pars

    @_docstring.dedent_interpd
    def __init__(self, xy, width, height, *, angle=0, **kwargs):
        super().__init__(**kwargs)
        self._center = xy
        (self._width, self._height) = (width, height)
        self._angle = angle
        self._path = Path.unit_circle()
        self._aspect_ratio_correction = 1.0
        self._patch_transform = transforms.IdentityTransform()

    def _recompute_transform(self):
        center = (self.convert_xunits(self._center[0]), self.convert_yunits(self._center[1]))
        width = self.convert_xunits(self._width)
        height = self.convert_yunits(self._height)
        self._patch_transform = transforms.Affine2D().scale(width * 0.5, height * 0.5 * self._aspect_ratio_correction).rotate_deg(self.angle).scale(1, 1 / self._aspect_ratio_correction).translate(*center)

    def get_path(self):
        return self._path

    def get_patch_transform(self):
        self._recompute_transform()
        return self._patch_transform

    def set_center(self, xy):
        self._center = xy
        self.stale = True

    def get_center(self):
        return self._center
    center = property(get_center, set_center)

    def set_width(self, width):
        self._width = width
        self.stale = True

    def get_width(self):
        return self._width
    width = property(get_width, set_width)

    def set_height(self, height):
        self._height = height
        self.stale = True

    def get_height(self):
        return self._height
    height = property(get_height, set_height)

    def set_angle(self, angle):
        self._angle = angle
        self.stale = True

    def get_angle(self):
        return self._angle
    angle = property(get_angle, set_angle)

    def get_corners(self):
        return self.get_patch_transform().transform([(-1, -1), (1, -1), (1, 1), (-1, 1)])

    def get_vertices(self):
        if self.width < self.height:
            ret = self.get_patch_transform().transform([(0, 1), (0, -1)])
        else:
            ret = self.get_patch_transform().transform([(1, 0), (-1, 0)])
        return [tuple(x) for x in ret]

    def get_co_vertices(self):
        if self.width < self.height:
            ret = self.get_patch_transform().transform([(1, 0), (-1, 0)])
        else:
            ret = self.get_patch_transform().transform([(0, 1), (0, -1)])
        return [tuple(x) for x in ret]

class Annulus(Patch):

    @_docstring.dedent_interpd
    def __init__(self, xy, r, width, angle=0.0, **kwargs):
        super().__init__(**kwargs)
        self.set_radii(r)
        self.center = xy
        self.width = width
        self.angle = angle
        self._path = None

    def __str__(self):
        if self.a == self.b:
            r = self.a
        else:
            r = (self.a, self.b)
        return 'Annulus(xy=(%s, %s), r=%s, width=%s, angle=%s)' % (*self.center, r, self.width, self.angle)

    def set_center(self, xy):
        self._center = xy
        self._path = None
        self.stale = True

    def get_center(self):
        return self._center
    center = property(get_center, set_center)

    def set_width(self, width):
        if width > min(self.a, self.b):
            raise ValueError('Width of annulus must be less than or equal to semi-minor axis')
        self._width = width
        self._path = None
        self.stale = True

    def get_width(self):
        return self._width
    width = property(get_width, set_width)

    def set_angle(self, angle):
        self._angle = angle
        self._path = None
        self.stale = True

    def get_angle(self):
        return self._angle
    angle = property(get_angle, set_angle)

    def set_semimajor(self, a):
        self.a = float(a)
        self._path = None
        self.stale = True

    def set_semiminor(self, b):
        self.b = float(b)
        self._path = None
        self.stale = True

    def set_radii(self, r):
        if np.shape(r) == (2,):
            (self.a, self.b) = r
        elif np.shape(r) == ():
            self.a = self.b = float(r)
        else:
            raise ValueError("Parameter 'r' must be one or two floats.")
        self._path = None
        self.stale = True

    def get_radii(self):
        return (self.a, self.b)
    radii = property(get_radii, set_radii)

    def _transform_verts(self, verts, a, b):
        return transforms.Affine2D().scale(*self._convert_xy_units((a, b))).rotate_deg(self.angle).translate(*self._convert_xy_units(self.center)).transform(verts)

    def _recompute_path(self):
        arc = Path.arc(0, 360)
        (a, b, w) = (self.a, self.b, self.width)
        v1 = self._transform_verts(arc.vertices, a, b)
        v2 = self._transform_verts(arc.vertices[::-1], a - w, b - w)
        v = np.vstack([v1, v2, v1[0, :], (0, 0)])
        c = np.hstack([arc.codes, Path.MOVETO, arc.codes[1:], Path.MOVETO, Path.CLOSEPOLY])
        self._path = Path(v, c)

    def get_path(self):
        if self._path is None:
            self._recompute_path()
        return self._path

class Circle(Ellipse):

    def __str__(self):
        pars = (self.center[0], self.center[1], self.radius)
        fmt = 'Circle(xy=(%g, %g), radius=%g)'
        return fmt % pars

    @_docstring.dedent_interpd
    def __init__(self, xy, radius=5, **kwargs):
        super().__init__(xy, radius * 2, radius * 2, **kwargs)
        self.radius = radius

    def set_radius(self, radius):
        self.width = self.height = 2 * radius
        self.stale = True

    def get_radius(self):
        return self.width / 2.0
    radius = property(get_radius, set_radius)

class Arc(Ellipse):

    def __str__(self):
        pars = (self.center[0], self.center[1], self.width, self.height, self.angle, self.theta1, self.theta2)
        fmt = 'Arc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g)'
        return fmt % pars

    @_docstring.dedent_interpd
    def __init__(self, xy, width, height, *, angle=0.0, theta1=0.0, theta2=360.0, **kwargs):
        fill = kwargs.setdefault('fill', False)
        if fill:
            raise ValueError('Arc objects cannot be filled')
        super().__init__(xy, width, height, angle=angle, **kwargs)
        self.theta1 = theta1
        self.theta2 = theta2
        (self._theta1, self._theta2, self._stretched_width, self._stretched_height) = self._theta_stretch()
        self._path = Path.arc(self._theta1, self._theta2)

    @artist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        self._recompute_transform()
        self._update_path()
        data_to_screen_trans = self.get_data_transform()
        (pwidth, pheight) = data_to_screen_trans.transform((self._stretched_width, self._stretched_height)) - data_to_screen_trans.transform((0, 0))
        inv_error = 1.0 / 1.89818e-06 * 0.5
        if pwidth < inv_error and pheight < inv_error:
            return Patch.draw(self, renderer)

        def line_circle_intersect(x0, y0, x1, y1):
            dx = x1 - x0
            dy = y1 - y0
            dr2 = dx * dx + dy * dy
            D = x0 * y1 - x1 * y0
            D2 = D * D
            discrim = dr2 - D2
            if discrim >= 0.0:
                sign_dy = np.copysign(1, dy)
                sqrt_discrim = np.sqrt(discrim)
                return np.array([[(D * dy + sign_dy * dx * sqrt_discrim) / dr2, (-D * dx + abs(dy) * sqrt_discrim) / dr2], [(D * dy - sign_dy * dx * sqrt_discrim) / dr2, (-D * dx - abs(dy) * sqrt_discrim) / dr2]])
            else:
                return np.empty((0, 2))

        def segment_circle_intersect(x0, y0, x1, y1):
            epsilon = 1e-09
            if x1 < x0:
                (x0e, x1e) = (x1, x0)
            else:
                (x0e, x1e) = (x0, x1)
            if y1 < y0:
                (y0e, y1e) = (y1, y0)
            else:
                (y0e, y1e) = (y0, y1)
            xys = line_circle_intersect(x0, y0, x1, y1)
            (xs, ys) = xys.T
            return xys[(x0e - epsilon < xs) & (xs < x1e + epsilon) & (y0e - epsilon < ys) & (ys < y1e + epsilon)]
        box_path_transform = transforms.BboxTransformTo((self.axes or self.get_figure(root=False)).bbox) - self.get_transform()
        box_path = Path.unit_rectangle().transformed(box_path_transform)
        thetas = set()
        for (p0, p1) in zip(box_path.vertices[:-1], box_path.vertices[1:]):
            xy = segment_circle_intersect(*p0, *p1)
            (x, y) = xy.T
            theta = (np.rad2deg(np.arctan2(y, x)) + 360) % 360
            thetas.update(theta[(self._theta1 < theta) & (theta < self._theta2)])
        thetas = sorted(thetas) + [self._theta2]
        last_theta = self._theta1
        theta1_rad = np.deg2rad(self._theta1)
        inside = box_path.contains_point((np.cos(theta1_rad), np.sin(theta1_rad)))
        path_original = self._path
        for theta in thetas:
            if inside:
                self._path = Path.arc(last_theta, theta, 8)
                Patch.draw(self, renderer)
                inside = False
            else:
                inside = True
            last_theta = theta
        self._path = path_original

    def _update_path(self):
        stretched = self._theta_stretch()
        if any((a != b for (a, b) in zip(stretched, (self._theta1, self._theta2, self._stretched_width, self._stretched_height)))):
            (self._theta1, self._theta2, self._stretched_width, self._stretched_height) = stretched
            self._path = Path.arc(self._theta1, self._theta2)

    def _theta_stretch(self):

        def theta_stretch(theta, scale):
            theta = np.deg2rad(theta)
            x = np.cos(theta)
            y = np.sin(theta)
            stheta = np.rad2deg(np.arctan2(scale * y, x))
            return (stheta + 360) % 360
        width = self.convert_xunits(self.width)
        height = self.convert_yunits(self.height)
        if width != height and (not (self.theta1 != self.theta2 and self.theta1 % 360 == self.theta2 % 360)):
            theta1 = theta_stretch(self.theta1, width / height)
            theta2 = theta_stretch(self.theta2, width / height)
            return (theta1, theta2, width, height)
        return (self.theta1, self.theta2, width, height)

def bbox_artist(artist, renderer, props=None, fill=True):
    if props is None:
        props = {}
    props = props.copy()
    pad = props.pop('pad', 4)
    pad = renderer.points_to_pixels(pad)
    bbox = artist.get_window_extent(renderer)
    r = Rectangle(xy=(bbox.x0 - pad / 2, bbox.y0 - pad / 2), width=bbox.width + pad, height=bbox.height + pad, fill=fill, transform=transforms.IdentityTransform(), clip_on=False)
    r.update(props)
    r.draw(renderer)

def draw_bbox(bbox, renderer, color='k', trans=None):
    r = Rectangle(xy=bbox.p0, width=bbox.width, height=bbox.height, edgecolor=color, fill=False, clip_on=False)
    if trans is not None:
        r.set_transform(trans)
    r.draw(renderer)

class _Style:

    def __init_subclass__(cls):
        _docstring.interpd.update({f'{cls.__name__}:table': cls.pprint_styles(), f'{cls.__name__}:table_and_accepts': cls.pprint_styles() + '\n\n    .. ACCEPTS: [' + '|'.join(map(" '{}' ".format, cls._style_list)) + ']'})

    def __new__(cls, stylename, **kwargs):
        _list = stylename.replace(' ', '').split(',')
        _name = _list[0].lower()
        try:
            _cls = cls._style_list[_name]
        except KeyError as err:
            raise ValueError(f'Unknown style: {stylename!r}') from err
        try:
            _args_pair = [cs.split('=') for cs in _list[1:]]
            _args = {k: float(v) for (k, v) in _args_pair}
        except ValueError as err:
            raise ValueError(f'Incorrect style argument: {stylename!r}') from err
        return _cls(**{**_args, **kwargs})

    @classmethod
    def get_styles(cls):
        return cls._style_list

    @classmethod
    def pprint_styles(cls):
        table = [('Class', 'Name', 'Attrs'), *[(cls.__name__, f'``{name}``', str(inspect.signature(cls))[1:-1] or 'None') for (name, cls) in cls._style_list.items()]]
        col_len = [max((len(cell) for cell in column)) for column in zip(*table)]
        table_formatstr = '  '.join(('=' * cl for cl in col_len))
        rst_table = '\n'.join(['', table_formatstr, '  '.join((cell.ljust(cl) for (cell, cl) in zip(table[0], col_len))), table_formatstr, *['  '.join((cell.ljust(cl) for (cell, cl) in zip(row, col_len))) for row in table[1:]], table_formatstr])
        return textwrap.indent(rst_table, prefix=' ' * 4)

    @classmethod
    @_api.deprecated('3.10.0', message='This method is never used internally.', alternative='No replacement.  Please open an issue if you use this.')
    def register(cls, name, style):
        if not issubclass(style, cls._Base):
            raise ValueError(f'{style} must be a subclass of {cls._Base}')
        cls._style_list[name] = style

def _register_style(style_list, cls=None, *, name=None):
    if cls is None:
        return functools.partial(_register_style, style_list, name=name)
    style_list[name or cls.__name__.lower()] = cls
    return cls

@_docstring.dedent_interpd
class BoxStyle(_Style):
    _style_list = {}

    @_register_style(_style_list)
    class Square:

        def __init__(self, pad=0.3):
            self.pad = pad

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            (width, height) = (width + 2 * pad, height + 2 * pad)
            (x0, y0) = (x0 - pad, y0 - pad)
            (x1, y1) = (x0 + width, y0 + height)
            return Path._create_closed([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])

    @_register_style(_style_list)
    class Circle:

        def __init__(self, pad=0.3):
            self.pad = pad

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            (width, height) = (width + 2 * pad, height + 2 * pad)
            (x0, y0) = (x0 - pad, y0 - pad)
            return Path.circle((x0 + width / 2, y0 + height / 2), max(width, height) / 2)

    @_register_style(_style_list)
    class Ellipse:

        def __init__(self, pad=0.3):
            self.pad = pad

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            (width, height) = (width + 2 * pad, height + 2 * pad)
            (x0, y0) = (x0 - pad, y0 - pad)
            a = width / math.sqrt(2)
            b = height / math.sqrt(2)
            trans = Affine2D().scale(a, b).translate(x0 + width / 2, y0 + height / 2)
            return trans.transform_path(Path.unit_circle())

    @_register_style(_style_list)
    class LArrow:

        def __init__(self, pad=0.3):
            self.pad = pad

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            (width, height) = (width + 2 * pad, height + 2 * pad)
            (x0, y0) = (x0 - pad, y0 - pad)
            (x1, y1) = (x0 + width, y0 + height)
            dx = (y1 - y0) / 2
            dxx = dx / 2
            x0 = x0 + pad / 1.4
            return Path._create_closed([(x0 + dxx, y0), (x1, y0), (x1, y1), (x0 + dxx, y1), (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx), (x0 + dxx, y0 - dxx), (x0 + dxx, y0)])

    @_register_style(_style_list)
    class RArrow(LArrow):

        def __call__(self, x0, y0, width, height, mutation_size):
            p = BoxStyle.LArrow.__call__(self, x0, y0, width, height, mutation_size)
            p.vertices[:, 0] = 2 * x0 + width - p.vertices[:, 0]
            return p

    @_register_style(_style_list)
    class DArrow:

        def __init__(self, pad=0.3):
            self.pad = pad

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            height = height + 2 * pad
            (x0, y0) = (x0 - pad, y0 - pad)
            (x1, y1) = (x0 + width, y0 + height)
            dx = (y1 - y0) / 2
            dxx = dx / 2
            x0 = x0 + pad / 1.4
            return Path._create_closed([(x0 + dxx, y0), (x1, y0), (x1, y0 - dxx), (x1 + dx + dxx, y0 + dx), (x1, y1 + dxx), (x1, y1), (x0 + dxx, y1), (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx), (x0 + dxx, y0 - dxx), (x0 + dxx, y0)])

    @_register_style(_style_list)
    class Round:

        def __init__(self, pad=0.3, rounding_size=None):
            self.pad = pad
            self.rounding_size = rounding_size

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            if self.rounding_size:
                dr = mutation_size * self.rounding_size
            else:
                dr = pad
            (width, height) = (width + 2 * pad, height + 2 * pad)
            (x0, y0) = (x0 - pad, y0 - pad)
            (x1, y1) = (x0 + width, y0 + height)
            cp = [(x0 + dr, y0), (x1 - dr, y0), (x1, y0), (x1, y0 + dr), (x1, y1 - dr), (x1, y1), (x1 - dr, y1), (x0 + dr, y1), (x0, y1), (x0, y1 - dr), (x0, y0 + dr), (x0, y0), (x0 + dr, y0), (x0 + dr, y0)]
            com = [Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.CLOSEPOLY]
            return Path(cp, com)

    @_register_style(_style_list)
    class Round4:

        def __init__(self, pad=0.3, rounding_size=None):
            self.pad = pad
            self.rounding_size = rounding_size

        def __call__(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            if self.rounding_size:
                dr = mutation_size * self.rounding_size
            else:
                dr = pad / 2.0
            width = width + 2 * pad - 2 * dr
            height = height + 2 * pad - 2 * dr
            (x0, y0) = (x0 - pad + dr, y0 - pad + dr)
            (x1, y1) = (x0 + width, y0 + height)
            cp = [(x0, y0), (x0 + dr, y0 - dr), (x1 - dr, y0 - dr), (x1, y0), (x1 + dr, y0 + dr), (x1 + dr, y1 - dr), (x1, y1), (x1 - dr, y1 + dr), (x0 + dr, y1 + dr), (x0, y1), (x0 - dr, y1 - dr), (x0 - dr, y0 + dr), (x0, y0), (x0, y0)]
            com = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CLOSEPOLY]
            return Path(cp, com)

    @_register_style(_style_list)
    class Sawtooth:

        def __init__(self, pad=0.3, tooth_size=None):
            self.pad = pad
            self.tooth_size = tooth_size

        def _get_sawtooth_vertices(self, x0, y0, width, height, mutation_size):
            pad = mutation_size * self.pad
            if self.tooth_size is None:
                tooth_size = self.pad * 0.5 * mutation_size
            else:
                tooth_size = self.tooth_size * mutation_size
            hsz = tooth_size / 2
            width = width + 2 * pad - tooth_size
            height = height + 2 * pad - tooth_size
            dsx_n = round((width - tooth_size) / (tooth_size * 2)) * 2
            dsy_n = round((height - tooth_size) / (tooth_size * 2)) * 2
            (x0, y0) = (x0 - pad + hsz, y0 - pad + hsz)
            (x1, y1) = (x0 + width, y0 + height)
            xs = [x0, *np.linspace(x0 + hsz, x1 - hsz, 2 * dsx_n + 1), *([x1, x1 + hsz, x1, x1 - hsz] * dsy_n)[:2 * dsy_n + 2], x1, *np.linspace(x1 - hsz, x0 + hsz, 2 * dsx_n + 1), *([x0, x0 - hsz, x0, x0 + hsz] * dsy_n)[:2 * dsy_n + 2]]
            ys = [*([y0, y0 - hsz, y0, y0 + hsz] * dsx_n)[:2 * dsx_n + 2], y0, *np.linspace(y0 + hsz, y1 - hsz, 2 * dsy_n + 1), *([y1, y1 + hsz, y1, y1 - hsz] * dsx_n)[:2 * dsx_n + 2], y1, *np.linspace(y1 - hsz, y0 + hsz, 2 * dsy_n + 1)]
            return [*zip(xs, ys), (xs[0], ys[0])]

        def __call__(self, x0, y0, width, height, mutation_size):
            saw_vertices = self._get_sawtooth_vertices(x0, y0, width, height, mutation_size)
            return Path(saw_vertices, closed=True)

    @_register_style(_style_list)
    class Roundtooth(Sawtooth):

        def __call__(self, x0, y0, width, height, mutation_size):
            saw_vertices = self._get_sawtooth_vertices(x0, y0, width, height, mutation_size)
            saw_vertices = np.concatenate([saw_vertices, [saw_vertices[0]]])
            codes = [Path.MOVETO] + [Path.CURVE3, Path.CURVE3] * ((len(saw_vertices) - 1) // 2) + [Path.CLOSEPOLY]
            return Path(saw_vertices, codes)

@_docstring.dedent_interpd
class ConnectionStyle(_Style):
    _style_list = {}

    class _Base:

        def _in_patch(self, patch):
            return lambda xy: patch.contains(SimpleNamespace(x=xy[0], y=xy[1]))[0]

        def _clip(self, path, in_start, in_stop):
            if in_start:
                try:
                    (_, path) = split_path_inout(path, in_start)
                except ValueError:
                    pass
            if in_stop:
                try:
                    (path, _) = split_path_inout(path, in_stop)
                except ValueError:
                    pass
            return path

        def __call__(self, posA, posB, shrinkA=2.0, shrinkB=2.0, patchA=None, patchB=None):
            path = self.connect(posA, posB)
            path = self._clip(path, self._in_patch(patchA) if patchA else None, self._in_patch(patchB) if patchB else None)
            path = self._clip(path, inside_circle(*path.vertices[0], shrinkA) if shrinkA else None, inside_circle(*path.vertices[-1], shrinkB) if shrinkB else None)
            return path

    @_register_style(_style_list)
    class Arc3(_Base):

        def __init__(self, rad=0.0):
            self.rad = rad

        def connect(self, posA, posB):
            (x1, y1) = posA
            (x2, y2) = posB
            (x12, y12) = ((x1 + x2) / 2.0, (y1 + y2) / 2.0)
            (dx, dy) = (x2 - x1, y2 - y1)
            f = self.rad
            (cx, cy) = (x12 + f * dy, y12 - f * dx)
            vertices = [(x1, y1), (cx, cy), (x2, y2)]
            codes = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
            return Path(vertices, codes)

    @_register_style(_style_list)
    class Angle3(_Base):

        def __init__(self, angleA=90, angleB=0):
            self.angleA = angleA
            self.angleB = angleB

        def connect(self, posA, posB):
            (x1, y1) = posA
            (x2, y2) = posB
            cosA = math.cos(math.radians(self.angleA))
            sinA = math.sin(math.radians(self.angleA))
            cosB = math.cos(math.radians(self.angleB))
            sinB = math.sin(math.radians(self.angleB))
            (cx, cy) = get_intersection(x1, y1, cosA, sinA, x2, y2, cosB, sinB)
            vertices = [(x1, y1), (cx, cy), (x2, y2)]
            codes = [Path.MOVETO, Path.CURVE3, Path.CURVE3]
            return Path(vertices, codes)

    @_register_style(_style_list)
    class Angle(_Base):

        def __init__(self, angleA=90, angleB=0, rad=0.0):
            self.angleA = angleA
            self.angleB = angleB
            self.rad = rad

        def connect(self, posA, posB):
            (x1, y1) = posA
            (x2, y2) = posB
            cosA = math.cos(math.radians(self.angleA))
            sinA = math.sin(math.radians(self.angleA))
            cosB = math.cos(math.radians(self.angleB))
            sinB = math.sin(math.radians(self.angleB))
            (cx, cy) = get_intersection(x1, y1, cosA, sinA, x2, y2, cosB, sinB)
            vertices = [(x1, y1)]
            codes = [Path.MOVETO]
            if self.rad == 0.0:
                vertices.append((cx, cy))
                codes.append(Path.LINETO)
            else:
                (dx1, dy1) = (x1 - cx, y1 - cy)
                d1 = np.hypot(dx1, dy1)
                f1 = self.rad / d1
                (dx2, dy2) = (x2 - cx, y2 - cy)
                d2 = np.hypot(dx2, dy2)
                f2 = self.rad / d2
                vertices.extend([(cx + dx1 * f1, cy + dy1 * f1), (cx, cy), (cx + dx2 * f2, cy + dy2 * f2)])
                codes.extend([Path.LINETO, Path.CURVE3, Path.CURVE3])
            vertices.append((x2, y2))
            codes.append(Path.LINETO)
            return Path(vertices, codes)

    @_register_style(_style_list)
    class Arc(_Base):

        def __init__(self, angleA=0, angleB=0, armA=None, armB=None, rad=0.0):
            self.angleA = angleA
            self.angleB = angleB
            self.armA = armA
            self.armB = armB
            self.rad = rad

        def connect(self, posA, posB):
            (x1, y1) = posA
            (x2, y2) = posB
            vertices = [(x1, y1)]
            rounded = []
            codes = [Path.MOVETO]
            if self.armA:
                cosA = math.cos(math.radians(self.angleA))
                sinA = math.sin(math.radians(self.angleA))
                d = self.armA - self.rad
                rounded.append((x1 + d * cosA, y1 + d * sinA))
                d = self.armA
                rounded.append((x1 + d * cosA, y1 + d * sinA))
            if self.armB:
                cosB = math.cos(math.radians(self.angleB))
                sinB = math.sin(math.radians(self.angleB))
                (x_armB, y_armB) = (x2 + self.armB * cosB, y2 + self.armB * sinB)
                if rounded:
                    (xp, yp) = rounded[-1]
                    (dx, dy) = (x_armB - xp, y_armB - yp)
                    dd = (dx * dx + dy * dy) ** 0.5
                    rounded.append((xp + self.rad * dx / dd, yp + self.rad * dy / dd))
                    vertices.extend(rounded)
                    codes.extend([Path.LINETO, Path.CURVE3, Path.CURVE3])
                else:
                    (xp, yp) = vertices[-1]
                    (dx, dy) = (x_armB - xp, y_armB - yp)
                    dd = (dx * dx + dy * dy) ** 0.5
                d = dd - self.rad
                rounded = [(xp + d * dx / dd, yp + d * dy / dd), (x_armB, y_armB)]
            if rounded:
                (xp, yp) = rounded[-1]
                (dx, dy) = (x2 - xp, y2 - yp)
                dd = (dx * dx + dy * dy) ** 0.5
                rounded.append((xp + self.rad * dx / dd, yp + self.rad * dy / dd))
                vertices.extend(rounded)
                codes.extend([Path.LINETO, Path.CURVE3, Path.CURVE3])
            vertices.append((x2, y2))
            codes.append(Path.LINETO)
            return Path(vertices, codes)

    @_register_style(_style_list)
    class Bar(_Base):

        def __init__(self, armA=0.0, armB=0.0, fraction=0.3, angle=None):
            self.armA = armA
            self.armB = armB
            self.fraction = fraction
            self.angle = angle

        def connect(self, posA, posB):
            (x1, y1) = posA
            (x20, y20) = (x2, y2) = posB
            theta1 = math.atan2(y2 - y1, x2 - x1)
            (dx, dy) = (x2 - x1, y2 - y1)
            dd = (dx * dx + dy * dy) ** 0.5
            (ddx, ddy) = (dx / dd, dy / dd)
            (armA, armB) = (self.armA, self.armB)
            if self.angle is not None:
                theta0 = np.deg2rad(self.angle)
                dtheta = theta1 - theta0
                dl = dd * math.sin(dtheta)
                dL = dd * math.cos(dtheta)
                (x2, y2) = (x1 + dL * math.cos(theta0), y1 + dL * math.sin(theta0))
                armB = armB - dl
                (dx, dy) = (x2 - x1, y2 - y1)
                dd2 = (dx * dx + dy * dy) ** 0.5
                (ddx, ddy) = (dx / dd2, dy / dd2)
            arm = max(armA, armB)
            f = self.fraction * dd + arm
            (cx1, cy1) = (x1 + f * ddy, y1 - f * ddx)
            (cx2, cy2) = (x2 + f * ddy, y2 - f * ddx)
            vertices = [(x1, y1), (cx1, cy1), (cx2, cy2), (x20, y20)]
            codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO]
            return Path(vertices, codes)

def _point_along_a_line(x0, y0, x1, y1, d):
    (dx, dy) = (x0 - x1, y0 - y1)
    ff = d / (dx * dx + dy * dy) ** 0.5
    (x2, y2) = (x0 - ff * dx, y0 - ff * dy)
    return (x2, y2)

@_docstring.dedent_interpd
class ArrowStyle(_Style):
    _style_list = {}

    class _Base:

        @staticmethod
        def ensure_quadratic_bezier(path):
            segments = list(path.iter_segments())
            if len(segments) != 2 or segments[0][1] != Path.MOVETO or segments[1][1] != Path.CURVE3:
                raise ValueError("'path' is not a valid quadratic Bezier curve")
            return [*segments[0][0], *segments[1][0]]

        def transmute(self, path, mutation_size, linewidth):
            raise NotImplementedError('Derived must override')

        def __call__(self, path, mutation_size, linewidth, aspect_ratio=1.0):
            if aspect_ratio is not None:
                vertices = path.vertices / [1, aspect_ratio]
                path_shrunk = Path(vertices, path.codes)
                (path_mutated, fillable) = self.transmute(path_shrunk, mutation_size, linewidth)
                if np.iterable(fillable):
                    path_list = [Path(p.vertices * [1, aspect_ratio], p.codes) for p in path_mutated]
                    return (path_list, fillable)
                else:
                    return (path_mutated, fillable)
            else:
                return self.transmute(path, mutation_size, linewidth)

    class _Curve(_Base):
        arrow = '-'
        fillbegin = fillend = False

        def __init__(self, head_length=0.4, head_width=0.2, widthA=1.0, widthB=1.0, lengthA=0.2, lengthB=0.2, angleA=0, angleB=0, scaleA=None, scaleB=None):
            (self.head_length, self.head_width) = (head_length, head_width)
            (self.widthA, self.widthB) = (widthA, widthB)
            (self.lengthA, self.lengthB) = (lengthA, lengthB)
            (self.angleA, self.angleB) = (angleA, angleB)
            (self.scaleA, self.scaleB) = (scaleA, scaleB)
            self._beginarrow_head = False
            self._beginarrow_bracket = False
            self._endarrow_head = False
            self._endarrow_bracket = False
            if '-' not in self.arrow:
                raise ValueError("arrow must have the '-' between the two heads")
            (beginarrow, endarrow) = self.arrow.split('-', 1)
            if beginarrow == '<':
                self._beginarrow_head = True
                self._beginarrow_bracket = False
            elif beginarrow == '<|':
                self._beginarrow_head = True
                self._beginarrow_bracket = False
                self.fillbegin = True
            elif beginarrow in (']', '|'):
                self._beginarrow_head = False
                self._beginarrow_bracket = True
            if endarrow == '>':
                self._endarrow_head = True
                self._endarrow_bracket = False
            elif endarrow == '|>':
                self._endarrow_head = True
                self._endarrow_bracket = False
                self.fillend = True
            elif endarrow in ('[', '|'):
                self._endarrow_head = False
                self._endarrow_bracket = True
            super().__init__()

        def _get_arrow_wedge(self, x0, y0, x1, y1, head_dist, cos_t, sin_t, linewidth):
            (dx, dy) = (x0 - x1, y0 - y1)
            cp_distance = np.hypot(dx, dy)
            pad_projected = 0.5 * linewidth / sin_t
            if cp_distance == 0:
                cp_distance = 1
            ddx = pad_projected * dx / cp_distance
            ddy = pad_projected * dy / cp_distance
            dx = dx / cp_distance * head_dist
            dy = dy / cp_distance * head_dist
            (dx1, dy1) = (cos_t * dx + sin_t * dy, -sin_t * dx + cos_t * dy)
            (dx2, dy2) = (cos_t * dx - sin_t * dy, sin_t * dx + cos_t * dy)
            vertices_arrow = [(x1 + ddx + dx1, y1 + ddy + dy1), (x1 + ddx, y1 + ddy), (x1 + ddx + dx2, y1 + ddy + dy2)]
            codes_arrow = [Path.MOVETO, Path.LINETO, Path.LINETO]
            return (vertices_arrow, codes_arrow, ddx, ddy)

        def _get_bracket(self, x0, y0, x1, y1, width, length, angle):
            (cos_t, sin_t) = get_cos_sin(x1, y1, x0, y0)
            from matplotlib.bezier import get_normal_points
            (x1, y1, x2, y2) = get_normal_points(x0, y0, cos_t, sin_t, width)
            (dx, dy) = (length * cos_t, length * sin_t)
            vertices_arrow = [(x1 + dx, y1 + dy), (x1, y1), (x2, y2), (x2 + dx, y2 + dy)]
            codes_arrow = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO]
            if angle:
                trans = transforms.Affine2D().rotate_deg_around(x0, y0, angle)
                vertices_arrow = trans.transform(vertices_arrow)
            return (vertices_arrow, codes_arrow)

        def transmute(self, path, mutation_size, linewidth):
            if self._beginarrow_head or self._endarrow_head:
                head_length = self.head_length * mutation_size
                head_width = self.head_width * mutation_size
                head_dist = np.hypot(head_length, head_width)
                (cos_t, sin_t) = (head_length / head_dist, head_width / head_dist)
            scaleA = mutation_size if self.scaleA is None else self.scaleA
            scaleB = mutation_size if self.scaleB is None else self.scaleB
            (x0, y0) = path.vertices[0]
            (x1, y1) = path.vertices[1]
            has_begin_arrow = self._beginarrow_head and (x0, y0) != (x1, y1)
            (verticesA, codesA, ddxA, ddyA) = self._get_arrow_wedge(x1, y1, x0, y0, head_dist, cos_t, sin_t, linewidth) if has_begin_arrow else ([], [], 0, 0)
            (x2, y2) = path.vertices[-2]
            (x3, y3) = path.vertices[-1]
            has_end_arrow = self._endarrow_head and (x2, y2) != (x3, y3)
            (verticesB, codesB, ddxB, ddyB) = self._get_arrow_wedge(x2, y2, x3, y3, head_dist, cos_t, sin_t, linewidth) if has_end_arrow else ([], [], 0, 0)
            paths = [Path(np.concatenate([[(x0 + ddxA, y0 + ddyA)], path.vertices[1:-1], [(x3 + ddxB, y3 + ddyB)]]), path.codes)]
            fills = [False]
            if has_begin_arrow:
                if self.fillbegin:
                    paths.append(Path([*verticesA, (0, 0)], [*codesA, Path.CLOSEPOLY]))
                    fills.append(True)
                else:
                    paths.append(Path(verticesA, codesA))
                    fills.append(False)
            elif self._beginarrow_bracket:
                (x0, y0) = path.vertices[0]
                (x1, y1) = path.vertices[1]
                (verticesA, codesA) = self._get_bracket(x0, y0, x1, y1, self.widthA * scaleA, self.lengthA * scaleA, self.angleA)
                paths.append(Path(verticesA, codesA))
                fills.append(False)
            if has_end_arrow:
                if self.fillend:
                    fills.append(True)
                    paths.append(Path([*verticesB, (0, 0)], [*codesB, Path.CLOSEPOLY]))
                else:
                    fills.append(False)
                    paths.append(Path(verticesB, codesB))
            elif self._endarrow_bracket:
                (x0, y0) = path.vertices[-1]
                (x1, y1) = path.vertices[-2]
                (verticesB, codesB) = self._get_bracket(x0, y0, x1, y1, self.widthB * scaleB, self.lengthB * scaleB, self.angleB)
                paths.append(Path(verticesB, codesB))
                fills.append(False)
            return (paths, fills)

    @_register_style(_style_list, name='-')
    class Curve(_Curve):

        def __init__(self):
            super().__init__(head_length=0.2, head_width=0.1)

    @_register_style(_style_list, name='<-')
    class CurveA(_Curve):
        arrow = '<-'

    @_register_style(_style_list, name='->')
    class CurveB(_Curve):
        arrow = '->'

    @_register_style(_style_list, name='<->')
    class CurveAB(_Curve):
        arrow = '<->'

    @_register_style(_style_list, name='<|-')
    class CurveFilledA(_Curve):
        arrow = '<|-'

    @_register_style(_style_list, name='-|>')
    class CurveFilledB(_Curve):
        arrow = '-|>'

    @_register_style(_style_list, name='<|-|>')
    class CurveFilledAB(_Curve):
        arrow = '<|-|>'

    @_register_style(_style_list, name=']-')
    class BracketA(_Curve):
        arrow = ']-'

        def __init__(self, widthA=1.0, lengthA=0.2, angleA=0):
            super().__init__(widthA=widthA, lengthA=lengthA, angleA=angleA)

    @_register_style(_style_list, name='-[')
    class BracketB(_Curve):
        arrow = '-['

        def __init__(self, widthB=1.0, lengthB=0.2, angleB=0):
            super().__init__(widthB=widthB, lengthB=lengthB, angleB=angleB)

    @_register_style(_style_list, name=']-[')
    class BracketAB(_Curve):
        arrow = ']-['

        def __init__(self, widthA=1.0, lengthA=0.2, angleA=0, widthB=1.0, lengthB=0.2, angleB=0):
            super().__init__(widthA=widthA, lengthA=lengthA, angleA=angleA, widthB=widthB, lengthB=lengthB, angleB=angleB)

    @_register_style(_style_list, name='|-|')
    class BarAB(_Curve):
        arrow = '|-|'

        def __init__(self, widthA=1.0, angleA=0, widthB=1.0, angleB=0):
            super().__init__(widthA=widthA, lengthA=0, angleA=angleA, widthB=widthB, lengthB=0, angleB=angleB)

    @_register_style(_style_list, name=']->')
    class BracketCurve(_Curve):
        arrow = ']->'

        def __init__(self, widthA=1.0, lengthA=0.2, angleA=None):
            super().__init__(widthA=widthA, lengthA=lengthA, angleA=angleA)

    @_register_style(_style_list, name='<-[')
    class CurveBracket(_Curve):
        arrow = '<-['

        def __init__(self, widthB=1.0, lengthB=0.2, angleB=None):
            super().__init__(widthB=widthB, lengthB=lengthB, angleB=angleB)

    @_register_style(_style_list)
    class Simple(_Base):

        def __init__(self, head_length=0.5, head_width=0.5, tail_width=0.2):
            (self.head_length, self.head_width, self.tail_width) = (head_length, head_width, tail_width)
            super().__init__()

        def transmute(self, path, mutation_size, linewidth):
            (x0, y0, x1, y1, x2, y2) = self.ensure_quadratic_bezier(path)
            head_length = self.head_length * mutation_size
            in_f = inside_circle(x2, y2, head_length)
            arrow_path = [(x0, y0), (x1, y1), (x2, y2)]
            try:
                (arrow_out, arrow_in) = split_bezier_intersecting_with_closedpath(arrow_path, in_f)
            except NonIntersectingPathException:
                (x0, y0) = _point_along_a_line(x2, y2, x1, y1, head_length)
                (x1n, y1n) = (0.5 * (x0 + x2), 0.5 * (y0 + y2))
                arrow_in = [(x0, y0), (x1n, y1n), (x2, y2)]
                arrow_out = None
            head_width = self.head_width * mutation_size
            (head_left, head_right) = make_wedged_bezier2(arrow_in, head_width / 2.0, wm=0.5)
            if arrow_out is not None:
                tail_width = self.tail_width * mutation_size
                (tail_left, tail_right) = get_parallels(arrow_out, tail_width / 2.0)
                patch_path = [(Path.MOVETO, tail_right[0]), (Path.CURVE3, tail_right[1]), (Path.CURVE3, tail_right[2]), (Path.LINETO, head_right[0]), (Path.CURVE3, head_right[1]), (Path.CURVE3, head_right[2]), (Path.CURVE3, head_left[1]), (Path.CURVE3, head_left[0]), (Path.LINETO, tail_left[2]), (Path.CURVE3, tail_left[1]), (Path.CURVE3, tail_left[0]), (Path.LINETO, tail_right[0]), (Path.CLOSEPOLY, tail_right[0])]
            else:
                patch_path = [(Path.MOVETO, head_right[0]), (Path.CURVE3, head_right[1]), (Path.CURVE3, head_right[2]), (Path.CURVE3, head_left[1]), (Path.CURVE3, head_left[0]), (Path.CLOSEPOLY, head_left[0])]
            path = Path([p for (c, p) in patch_path], [c for (c, p) in patch_path])
            return (path, True)

    @_register_style(_style_list)
    class Fancy(_Base):

        def __init__(self, head_length=0.4, head_width=0.4, tail_width=0.4):
            (self.head_length, self.head_width, self.tail_width) = (head_length, head_width, tail_width)
            super().__init__()

        def transmute(self, path, mutation_size, linewidth):
            (x0, y0, x1, y1, x2, y2) = self.ensure_quadratic_bezier(path)
            head_length = self.head_length * mutation_size
            arrow_path = [(x0, y0), (x1, y1), (x2, y2)]
            in_f = inside_circle(x2, y2, head_length)
            try:
                (path_out, path_in) = split_bezier_intersecting_with_closedpath(arrow_path, in_f)
            except NonIntersectingPathException:
                (x0, y0) = _point_along_a_line(x2, y2, x1, y1, head_length)
                (x1n, y1n) = (0.5 * (x0 + x2), 0.5 * (y0 + y2))
                arrow_path = [(x0, y0), (x1n, y1n), (x2, y2)]
                path_head = arrow_path
            else:
                path_head = path_in
            in_f = inside_circle(x2, y2, head_length * 0.8)
            (path_out, path_in) = split_bezier_intersecting_with_closedpath(arrow_path, in_f)
            path_tail = path_out
            head_width = self.head_width * mutation_size
            (head_l, head_r) = make_wedged_bezier2(path_head, head_width / 2.0, wm=0.6)
            tail_width = self.tail_width * mutation_size
            (tail_left, tail_right) = make_wedged_bezier2(path_tail, tail_width * 0.5, w1=1.0, wm=0.6, w2=0.3)
            in_f = inside_circle(x0, y0, tail_width * 0.3)
            (path_in, path_out) = split_bezier_intersecting_with_closedpath(arrow_path, in_f)
            tail_start = path_in[-1]
            (head_right, head_left) = (head_r, head_l)
            patch_path = [(Path.MOVETO, tail_start), (Path.LINETO, tail_right[0]), (Path.CURVE3, tail_right[1]), (Path.CURVE3, tail_right[2]), (Path.LINETO, head_right[0]), (Path.CURVE3, head_right[1]), (Path.CURVE3, head_right[2]), (Path.CURVE3, head_left[1]), (Path.CURVE3, head_left[0]), (Path.LINETO, tail_left[2]), (Path.CURVE3, tail_left[1]), (Path.CURVE3, tail_left[0]), (Path.LINETO, tail_start), (Path.CLOSEPOLY, tail_start)]
            path = Path([p for (c, p) in patch_path], [c for (c, p) in patch_path])
            return (path, True)

    @_register_style(_style_list)
    class Wedge(_Base):

        def __init__(self, tail_width=0.3, shrink_factor=0.5):
            self.tail_width = tail_width
            self.shrink_factor = shrink_factor
            super().__init__()

        def transmute(self, path, mutation_size, linewidth):
            (x0, y0, x1, y1, x2, y2) = self.ensure_quadratic_bezier(path)
            arrow_path = [(x0, y0), (x1, y1), (x2, y2)]
            (b_plus, b_minus) = make_wedged_bezier2(arrow_path, self.tail_width * mutation_size / 2.0, wm=self.shrink_factor)
            patch_path = [(Path.MOVETO, b_plus[0]), (Path.CURVE3, b_plus[1]), (Path.CURVE3, b_plus[2]), (Path.LINETO, b_minus[2]), (Path.CURVE3, b_minus[1]), (Path.CURVE3, b_minus[0]), (Path.CLOSEPOLY, b_minus[0])]
            path = Path([p for (c, p) in patch_path], [c for (c, p) in patch_path])
            return (path, True)

class FancyBboxPatch(Patch):
    _edge_default = True

    def __str__(self):
        s = self.__class__.__name__ + '((%g, %g), width=%g, height=%g)'
        return s % (self._x, self._y, self._width, self._height)

    @_docstring.dedent_interpd
    def __init__(self, xy, width, height, boxstyle='round', *, mutation_scale=1, mutation_aspect=1, **kwargs):
        super().__init__(**kwargs)
        (self._x, self._y) = xy
        self._width = width
        self._height = height
        self.set_boxstyle(boxstyle)
        self._mutation_scale = mutation_scale
        self._mutation_aspect = mutation_aspect
        self.stale = True

    @_docstring.dedent_interpd
    def set_boxstyle(self, boxstyle=None, **kwargs):
        if boxstyle is None:
            return BoxStyle.pprint_styles()
        self._bbox_transmuter = BoxStyle(boxstyle, **kwargs) if isinstance(boxstyle, str) else boxstyle
        self.stale = True

    def get_boxstyle(self):
        return self._bbox_transmuter

    def set_mutation_scale(self, scale):
        self._mutation_scale = scale
        self.stale = True

    def get_mutation_scale(self):
        return self._mutation_scale

    def set_mutation_aspect(self, aspect):
        self._mutation_aspect = aspect
        self.stale = True

    def get_mutation_aspect(self):
        return self._mutation_aspect if self._mutation_aspect is not None else 1

    def get_path(self):
        boxstyle = self.get_boxstyle()
        m_aspect = self.get_mutation_aspect()
        path = boxstyle(self._x, self._y / m_aspect, self._width, self._height / m_aspect, self.get_mutation_scale())
        return Path(path.vertices * [1, m_aspect], path.codes)

    def get_x(self):
        return self._x

    def get_y(self):
        return self._y

    def get_width(self):
        return self._width

    def get_height(self):
        return self._height

    def set_x(self, x):
        self._x = x
        self.stale = True

    def set_y(self, y):
        self._y = y
        self.stale = True

    def set_width(self, w):
        self._width = w
        self.stale = True

    def set_height(self, h):
        self._height = h
        self.stale = True

    def set_bounds(self, *args):
        if len(args) == 1:
            (l, b, w, h) = args[0]
        else:
            (l, b, w, h) = args
        self._x = l
        self._y = b
        self._width = w
        self._height = h
        self.stale = True

    def get_bbox(self):
        return transforms.Bbox.from_bounds(self._x, self._y, self._width, self._height)

class FancyArrowPatch(Patch):
    _edge_default = True

    def __str__(self):
        if self._posA_posB is not None:
            ((x1, y1), (x2, y2)) = self._posA_posB
            return f'{type(self).__name__}(({x1:g}, {y1:g})->({x2:g}, {y2:g}))'
        else:
            return f'{type(self).__name__}({self._path_original})'

    @_docstring.dedent_interpd
    def __init__(self, posA=None, posB=None, *, path=None, arrowstyle='simple', connectionstyle='arc3', patchA=None, patchB=None, shrinkA=2, shrinkB=2, mutation_scale=1, mutation_aspect=1, **kwargs):
        kwargs.setdefault('joinstyle', JoinStyle.round)
        kwargs.setdefault('capstyle', CapStyle.round)
        super().__init__(**kwargs)
        if posA is not None and posB is not None and (path is None):
            self._posA_posB = [posA, posB]
            if connectionstyle is None:
                connectionstyle = 'arc3'
            self.set_connectionstyle(connectionstyle)
        elif posA is None and posB is None and (path is not None):
            self._posA_posB = None
        else:
            raise ValueError('Either posA and posB, or path need to provided')
        self.patchA = patchA
        self.patchB = patchB
        self.shrinkA = shrinkA
        self.shrinkB = shrinkB
        self._path_original = path
        self.set_arrowstyle(arrowstyle)
        self._mutation_scale = mutation_scale
        self._mutation_aspect = mutation_aspect
        self._dpi_cor = 1.0

    def set_positions(self, posA, posB):
        if posA is not None:
            self._posA_posB[0] = posA
        if posB is not None:
            self._posA_posB[1] = posB
        self.stale = True

    def set_patchA(self, patchA):
        self.patchA = patchA
        self.stale = True

    def set_patchB(self, patchB):
        self.patchB = patchB
        self.stale = True

    @_docstring.dedent_interpd
    def set_connectionstyle(self, connectionstyle=None, **kwargs):
        if connectionstyle is None:
            return ConnectionStyle.pprint_styles()
        self._connector = ConnectionStyle(connectionstyle, **kwargs) if isinstance(connectionstyle, str) else connectionstyle
        self.stale = True

    def get_connectionstyle(self):
        return self._connector

    @_docstring.dedent_interpd
    def set_arrowstyle(self, arrowstyle=None, **kwargs):
        if arrowstyle is None:
            return ArrowStyle.pprint_styles()
        self._arrow_transmuter = ArrowStyle(arrowstyle, **kwargs) if isinstance(arrowstyle, str) else arrowstyle
        self.stale = True

    def get_arrowstyle(self):
        return self._arrow_transmuter

    def set_mutation_scale(self, scale):
        self._mutation_scale = scale
        self.stale = True

    def get_mutation_scale(self):
        return self._mutation_scale

    def set_mutation_aspect(self, aspect):
        self._mutation_aspect = aspect
        self.stale = True

    def get_mutation_aspect(self):
        return self._mutation_aspect if self._mutation_aspect is not None else 1

    def get_path(self):
        (_path, fillable) = self._get_path_in_displaycoord()
        if np.iterable(fillable):
            _path = Path.make_compound_path(*_path)
        return self.get_transform().inverted().transform_path(_path)

    def _get_path_in_displaycoord(self):
        dpi_cor = self._dpi_cor
        if self._posA_posB is not None:
            posA = self._convert_xy_units(self._posA_posB[0])
            posB = self._convert_xy_units(self._posA_posB[1])
            (posA, posB) = self.get_transform().transform((posA, posB))
            _path = self.get_connectionstyle()(posA, posB, patchA=self.patchA, patchB=self.patchB, shrinkA=self.shrinkA * dpi_cor, shrinkB=self.shrinkB * dpi_cor)
        else:
            _path = self.get_transform().transform_path(self._path_original)
        (_path, fillable) = self.get_arrowstyle()(_path, self.get_mutation_scale() * dpi_cor, self.get_linewidth() * dpi_cor, self.get_mutation_aspect())
        return (_path, fillable)

    def draw(self, renderer):
        if not self.get_visible():
            return
        self._dpi_cor = renderer.points_to_pixels(1.0)
        (path, fillable) = self._get_path_in_displaycoord()
        if not np.iterable(fillable):
            path = [path]
            fillable = [fillable]
        affine = transforms.IdentityTransform()
        self._draw_paths_with_artist_properties(renderer, [(p, affine, self._facecolor if f and self._facecolor[3] else None) for (p, f) in zip(path, fillable)])

class ConnectionPatch(FancyArrowPatch):

    def __str__(self):
        return 'ConnectionPatch((%g, %g), (%g, %g))' % (self.xy1[0], self.xy1[1], self.xy2[0], self.xy2[1])

    @_docstring.dedent_interpd
    def __init__(self, xyA, xyB, coordsA, coordsB=None, *, axesA=None, axesB=None, arrowstyle='-', connectionstyle='arc3', patchA=None, patchB=None, shrinkA=0.0, shrinkB=0.0, mutation_scale=10.0, mutation_aspect=None, clip_on=False, **kwargs):
        if coordsB is None:
            coordsB = coordsA
        self.xy1 = xyA
        self.xy2 = xyB
        self.coords1 = coordsA
        self.coords2 = coordsB
        self.axesA = axesA
        self.axesB = axesB
        super().__init__(posA=(0, 0), posB=(1, 1), arrowstyle=arrowstyle, connectionstyle=connectionstyle, patchA=patchA, patchB=patchB, shrinkA=shrinkA, shrinkB=shrinkB, mutation_scale=mutation_scale, mutation_aspect=mutation_aspect, clip_on=clip_on, **kwargs)
        self._annotation_clip = None

    def _get_xy(self, xy, s, axes=None):
        s0 = s
        if axes is None:
            axes = self.axes
        xy = np.array(xy)
        fig = self.get_figure(root=False)
        if s in ['figure points', 'axes points']:
            xy *= fig.dpi / 72
            s = s.replace('points', 'pixels')
        elif s == 'figure fraction':
            s = fig.transFigure
        elif s == 'subfigure fraction':
            s = fig.transSubfigure
        elif s == 'axes fraction':
            s = axes.transAxes
        (x, y) = xy
        if s == 'data':
            trans = axes.transData
            x = float(self.convert_xunits(x))
            y = float(self.convert_yunits(y))
            return trans.transform((x, y))
        elif s == 'offset points':
            if self.xycoords == 'offset points':
                return self._get_xy(self.xy, 'data')
            return self._get_xy(self.xy, self.xycoords) + xy * self.get_figure(root=True).dpi / 72
        elif s == 'polar':
            (theta, r) = (x, y)
            x = r * np.cos(theta)
            y = r * np.sin(theta)
            trans = axes.transData
            return trans.transform((x, y))
        elif s == 'figure pixels':
            bb = self.get_figure(root=False).figbbox
            x = bb.x0 + x if x >= 0 else bb.x1 + x
            y = bb.y0 + y if y >= 0 else bb.y1 + y
            return (x, y)
        elif s == 'subfigure pixels':
            bb = self.get_figure(root=False).bbox
            x = bb.x0 + x if x >= 0 else bb.x1 + x
            y = bb.y0 + y if y >= 0 else bb.y1 + y
            return (x, y)
        elif s == 'axes pixels':
            bb = axes.bbox
            x = bb.x0 + x if x >= 0 else bb.x1 + x
            y = bb.y0 + y if y >= 0 else bb.y1 + y
            return (x, y)
        elif isinstance(s, transforms.Transform):
            return s.transform(xy)
        else:
            raise ValueError(f'{s0} is not a valid coordinate transformation')

    def set_annotation_clip(self, b):
        self._annotation_clip = b
        self.stale = True

    def get_annotation_clip(self):
        return self._annotation_clip

    def _get_path_in_displaycoord(self):
        dpi_cor = self._dpi_cor
        posA = self._get_xy(self.xy1, self.coords1, self.axesA)
        posB = self._get_xy(self.xy2, self.coords2, self.axesB)
        path = self.get_connectionstyle()(posA, posB, patchA=self.patchA, patchB=self.patchB, shrinkA=self.shrinkA * dpi_cor, shrinkB=self.shrinkB * dpi_cor)
        (path, fillable) = self.get_arrowstyle()(path, self.get_mutation_scale() * dpi_cor, self.get_linewidth() * dpi_cor, self.get_mutation_aspect())
        return (path, fillable)

    def _check_xy(self, renderer):
        b = self.get_annotation_clip()
        if b or (b is None and self.coords1 == 'data'):
            xy_pixel = self._get_xy(self.xy1, self.coords1, self.axesA)
            if self.axesA is None:
                axes = self.axes
            else:
                axes = self.axesA
            if not axes.contains_point(xy_pixel):
                return False
        if b or (b is None and self.coords2 == 'data'):
            xy_pixel = self._get_xy(self.xy2, self.coords2, self.axesB)
            if self.axesB is None:
                axes = self.axes
            else:
                axes = self.axesB
            if not axes.contains_point(xy_pixel):
                return False
        return True

    def draw(self, renderer):
        if not self.get_visible() or not self._check_xy(renderer):
            return
        super().draw(renderer)

# File: matplotlib-main/lib/matplotlib/path.py
""""""
import copy
from functools import lru_cache
from weakref import WeakValueDictionary
import numpy as np
import matplotlib as mpl
from . import _api, _path
from .cbook import _to_unmasked_float_array, simple_linear_interpolation
from .bezier import BezierSegment

class Path:
    code_type = np.uint8
    STOP = code_type(0)
    MOVETO = code_type(1)
    LINETO = code_type(2)
    CURVE3 = code_type(3)
    CURVE4 = code_type(4)
    CLOSEPOLY = code_type(79)
    NUM_VERTICES_FOR_CODE = {STOP: 1, MOVETO: 1, LINETO: 1, CURVE3: 2, CURVE4: 3, CLOSEPOLY: 1}

    def __init__(self, vertices, codes=None, _interpolation_steps=1, closed=False, readonly=False):
        vertices = _to_unmasked_float_array(vertices)
        _api.check_shape((None, 2), vertices=vertices)
        if codes is not None and len(vertices):
            codes = np.asarray(codes, self.code_type)
            if codes.ndim != 1 or len(codes) != len(vertices):
                raise ValueError(f"'codes' must be a 1D list or array with the same length of 'vertices'. Your vertices have shape {vertices.shape} but your codes have shape {codes.shape}")
            if len(codes) and codes[0] != self.MOVETO:
                raise ValueError(f"The first element of 'code' must be equal to 'MOVETO' ({self.MOVETO}).  Your first code is {codes[0]}")
        elif closed and len(vertices):
            codes = np.empty(len(vertices), dtype=self.code_type)
            codes[0] = self.MOVETO
            codes[1:-1] = self.LINETO
            codes[-1] = self.CLOSEPOLY
        self._vertices = vertices
        self._codes = codes
        self._interpolation_steps = _interpolation_steps
        self._update_values()
        if readonly:
            self._vertices.flags.writeable = False
            if self._codes is not None:
                self._codes.flags.writeable = False
            self._readonly = True
        else:
            self._readonly = False

    @classmethod
    def _fast_from_codes_and_verts(cls, verts, codes, internals_from=None):
        pth = cls.__new__(cls)
        pth._vertices = _to_unmasked_float_array(verts)
        pth._codes = codes
        pth._readonly = False
        if internals_from is not None:
            pth._should_simplify = internals_from._should_simplify
            pth._simplify_threshold = internals_from._simplify_threshold
            pth._interpolation_steps = internals_from._interpolation_steps
        else:
            pth._should_simplify = True
            pth._simplify_threshold = mpl.rcParams['path.simplify_threshold']
            pth._interpolation_steps = 1
        return pth

    @classmethod
    def _create_closed(cls, vertices):
        v = _to_unmasked_float_array(vertices)
        return cls(np.concatenate([v, v[:1]]), closed=True)

    def _update_values(self):
        self._simplify_threshold = mpl.rcParams['path.simplify_threshold']
        self._should_simplify = self._simplify_threshold > 0 and mpl.rcParams['path.simplify'] and (len(self._vertices) >= 128) and (self._codes is None or np.all(self._codes <= Path.LINETO))

    @property
    def vertices(self):
        return self._vertices

    @vertices.setter
    def vertices(self, vertices):
        if self._readonly:
            raise AttributeError("Can't set vertices on a readonly Path")
        self._vertices = vertices
        self._update_values()

    @property
    def codes(self):
        return self._codes

    @codes.setter
    def codes(self, codes):
        if self._readonly:
            raise AttributeError("Can't set codes on a readonly Path")
        self._codes = codes
        self._update_values()

    @property
    def simplify_threshold(self):
        return self._simplify_threshold

    @simplify_threshold.setter
    def simplify_threshold(self, threshold):
        self._simplify_threshold = threshold

    @property
    def should_simplify(self):
        return self._should_simplify

    @should_simplify.setter
    def should_simplify(self, should_simplify):
        self._should_simplify = should_simplify

    @property
    def readonly(self):
        return self._readonly

    def copy(self):
        return copy.copy(self)

    def __deepcopy__(self, memo=None):
        p = copy.deepcopy(super(), memo)
        p._readonly = False
        return p
    deepcopy = __deepcopy__

    @classmethod
    def make_compound_path_from_polys(cls, XY):
        (numpolys, numsides, two) = XY.shape
        if two != 2:
            raise ValueError("The third dimension of 'XY' must be 2")
        stride = numsides + 1
        nverts = numpolys * stride
        verts = np.zeros((nverts, 2))
        codes = np.full(nverts, cls.LINETO, dtype=cls.code_type)
        codes[0::stride] = cls.MOVETO
        codes[numsides::stride] = cls.CLOSEPOLY
        for i in range(numsides):
            verts[i::stride] = XY[:, i]
        return cls(verts, codes)

    @classmethod
    def make_compound_path(cls, *args):
        if not args:
            return Path(np.empty([0, 2], dtype=np.float32))
        vertices = np.concatenate([path.vertices for path in args])
        codes = np.empty(len(vertices), dtype=cls.code_type)
        i = 0
        for path in args:
            size = len(path.vertices)
            if path.codes is None:
                if size:
                    codes[i] = cls.MOVETO
                    codes[i + 1:i + size] = cls.LINETO
            else:
                codes[i:i + size] = path.codes
            i += size
        not_stop_mask = codes != cls.STOP
        return cls(vertices[not_stop_mask], codes[not_stop_mask])

    def __repr__(self):
        return f'Path({self.vertices!r}, {self.codes!r})'

    def __len__(self):
        return len(self.vertices)

    def iter_segments(self, transform=None, remove_nans=True, clip=None, snap=False, stroke_width=1.0, simplify=None, curves=True, sketch=None):
        if not len(self):
            return
        cleaned = self.cleaned(transform=transform, remove_nans=remove_nans, clip=clip, snap=snap, stroke_width=stroke_width, simplify=simplify, curves=curves, sketch=sketch)
        NUM_VERTICES_FOR_CODE = self.NUM_VERTICES_FOR_CODE
        STOP = self.STOP
        vertices = iter(cleaned.vertices)
        codes = iter(cleaned.codes)
        for (curr_vertices, code) in zip(vertices, codes):
            if code == STOP:
                break
            extra_vertices = NUM_VERTICES_FOR_CODE[code] - 1
            if extra_vertices:
                for i in range(extra_vertices):
                    next(codes)
                    curr_vertices = np.append(curr_vertices, next(vertices))
            yield (curr_vertices, code)

    def iter_bezier(self, **kwargs):
        first_vert = None
        prev_vert = None
        for (verts, code) in self.iter_segments(**kwargs):
            if first_vert is None:
                if code != Path.MOVETO:
                    raise ValueError('Malformed path, must start with MOVETO.')
            if code == Path.MOVETO:
                first_vert = verts
                yield (BezierSegment(np.array([first_vert])), code)
            elif code == Path.LINETO:
                yield (BezierSegment(np.array([prev_vert, verts])), code)
            elif code == Path.CURVE3:
                yield (BezierSegment(np.array([prev_vert, verts[:2], verts[2:]])), code)
            elif code == Path.CURVE4:
                yield (BezierSegment(np.array([prev_vert, verts[:2], verts[2:4], verts[4:]])), code)
            elif code == Path.CLOSEPOLY:
                yield (BezierSegment(np.array([prev_vert, first_vert])), code)
            elif code == Path.STOP:
                return
            else:
                raise ValueError(f'Invalid Path.code_type: {code}')
            prev_vert = verts[-2:]

    def _iter_connected_components(self):
        if self.codes is None:
            yield self
        else:
            idxs = np.append((self.codes == Path.MOVETO).nonzero()[0], len(self.codes))
            for sl in map(slice, idxs, idxs[1:]):
                yield Path._fast_from_codes_and_verts(self.vertices[sl], self.codes[sl], self)

    def cleaned(self, transform=None, remove_nans=False, clip=None, *, simplify=False, curves=False, stroke_width=1.0, snap=False, sketch=None):
        (vertices, codes) = _path.cleanup_path(self, transform, remove_nans, clip, snap, stroke_width, simplify, curves, sketch)
        pth = Path._fast_from_codes_and_verts(vertices, codes, self)
        if not simplify:
            pth._should_simplify = False
        return pth

    def transformed(self, transform):
        return Path(transform.transform(self.vertices), self.codes, self._interpolation_steps)

    def contains_point(self, point, transform=None, radius=0.0):
        if transform is not None:
            transform = transform.frozen()
        if transform and (not transform.is_affine):
            self = transform.transform_path(self)
            transform = None
        return _path.point_in_path(point[0], point[1], radius, self, transform)

    def contains_points(self, points, transform=None, radius=0.0):
        if transform is not None:
            transform = transform.frozen()
        result = _path.points_in_path(points, radius, self, transform)
        return result.astype('bool')

    def contains_path(self, path, transform=None):
        if transform is not None:
            transform = transform.frozen()
        return _path.path_in_path(self, None, path, transform)

    def get_extents(self, transform=None, **kwargs):
        from .transforms import Bbox
        if transform is not None:
            self = transform.transform_path(self)
        if self.codes is None:
            xys = self.vertices
        elif len(np.intersect1d(self.codes, [Path.CURVE3, Path.CURVE4])) == 0:
            xys = self.vertices[np.isin(self.codes, [Path.MOVETO, Path.LINETO])]
        else:
            xys = []
            for (curve, code) in self.iter_bezier(**kwargs):
                (_, dzeros) = curve.axis_aligned_extrema()
                xys.append(curve([0, *dzeros, 1]))
            xys = np.concatenate(xys)
        if len(xys):
            return Bbox([xys.min(axis=0), xys.max(axis=0)])
        else:
            return Bbox.null()

    def intersects_path(self, other, filled=True):
        return _path.path_intersects_path(self, other, filled)

    def intersects_bbox(self, bbox, filled=True):
        return _path.path_intersects_rectangle(self, bbox.x0, bbox.y0, bbox.x1, bbox.y1, filled)

    def interpolated(self, steps):
        if steps == 1:
            return self
        vertices = simple_linear_interpolation(self.vertices, steps)
        codes = self.codes
        if codes is not None:
            new_codes = np.full((len(codes) - 1) * steps + 1, Path.LINETO, dtype=self.code_type)
            new_codes[0::steps] = codes
        else:
            new_codes = None
        return Path(vertices, new_codes)

    def to_polygons(self, transform=None, width=0, height=0, closed_only=True):
        if len(self.vertices) == 0:
            return []
        if transform is not None:
            transform = transform.frozen()
        if self.codes is None and (width == 0 or height == 0):
            vertices = self.vertices
            if closed_only:
                if len(vertices) < 3:
                    return []
                elif np.any(vertices[0] != vertices[-1]):
                    vertices = [*vertices, vertices[0]]
            if transform is None:
                return [vertices]
            else:
                return [transform.transform(vertices)]
        return _path.convert_path_to_polygons(self, transform, width, height, closed_only)
    _unit_rectangle = None

    @classmethod
    def unit_rectangle(cls):
        if cls._unit_rectangle is None:
            cls._unit_rectangle = cls([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], closed=True, readonly=True)
        return cls._unit_rectangle
    _unit_regular_polygons = WeakValueDictionary()

    @classmethod
    def unit_regular_polygon(cls, numVertices):
        if numVertices <= 16:
            path = cls._unit_regular_polygons.get(numVertices)
        else:
            path = None
        if path is None:
            theta = 2 * np.pi / numVertices * np.arange(numVertices + 1) + np.pi / 2
            verts = np.column_stack((np.cos(theta), np.sin(theta)))
            path = cls(verts, closed=True, readonly=True)
            if numVertices <= 16:
                cls._unit_regular_polygons[numVertices] = path
        return path
    _unit_regular_stars = WeakValueDictionary()

    @classmethod
    def unit_regular_star(cls, numVertices, innerCircle=0.5):
        if numVertices <= 16:
            path = cls._unit_regular_stars.get((numVertices, innerCircle))
        else:
            path = None
        if path is None:
            ns2 = numVertices * 2
            theta = 2 * np.pi / ns2 * np.arange(ns2 + 1)
            theta += np.pi / 2.0
            r = np.ones(ns2 + 1)
            r[1::2] = innerCircle
            verts = (r * np.vstack((np.cos(theta), np.sin(theta)))).T
            path = cls(verts, closed=True, readonly=True)
            if numVertices <= 16:
                cls._unit_regular_stars[numVertices, innerCircle] = path
        return path

    @classmethod
    def unit_regular_asterisk(cls, numVertices):
        return cls.unit_regular_star(numVertices, 0.0)
    _unit_circle = None

    @classmethod
    def unit_circle(cls):
        if cls._unit_circle is None:
            cls._unit_circle = cls.circle(center=(0, 0), radius=1, readonly=True)
        return cls._unit_circle

    @classmethod
    def circle(cls, center=(0.0, 0.0), radius=1.0, readonly=False):
        MAGIC = 0.2652031
        SQRTHALF = np.sqrt(0.5)
        MAGIC45 = SQRTHALF * MAGIC
        vertices = np.array([[0.0, -1.0], [MAGIC, -1.0], [SQRTHALF - MAGIC45, -SQRTHALF - MAGIC45], [SQRTHALF, -SQRTHALF], [SQRTHALF + MAGIC45, -SQRTHALF + MAGIC45], [1.0, -MAGIC], [1.0, 0.0], [1.0, MAGIC], [SQRTHALF + MAGIC45, SQRTHALF - MAGIC45], [SQRTHALF, SQRTHALF], [SQRTHALF - MAGIC45, SQRTHALF + MAGIC45], [MAGIC, 1.0], [0.0, 1.0], [-MAGIC, 1.0], [-SQRTHALF + MAGIC45, SQRTHALF + MAGIC45], [-SQRTHALF, SQRTHALF], [-SQRTHALF - MAGIC45, SQRTHALF - MAGIC45], [-1.0, MAGIC], [-1.0, 0.0], [-1.0, -MAGIC], [-SQRTHALF - MAGIC45, -SQRTHALF + MAGIC45], [-SQRTHALF, -SQRTHALF], [-SQRTHALF + MAGIC45, -SQRTHALF - MAGIC45], [-MAGIC, -1.0], [0.0, -1.0], [0.0, -1.0]], dtype=float)
        codes = [cls.CURVE4] * 26
        codes[0] = cls.MOVETO
        codes[-1] = cls.CLOSEPOLY
        return Path(vertices * radius + center, codes, readonly=readonly)
    _unit_circle_righthalf = None

    @classmethod
    def unit_circle_righthalf(cls):
        if cls._unit_circle_righthalf is None:
            MAGIC = 0.2652031
            SQRTHALF = np.sqrt(0.5)
            MAGIC45 = SQRTHALF * MAGIC
            vertices = np.array([[0.0, -1.0], [MAGIC, -1.0], [SQRTHALF - MAGIC45, -SQRTHALF - MAGIC45], [SQRTHALF, -SQRTHALF], [SQRTHALF + MAGIC45, -SQRTHALF + MAGIC45], [1.0, -MAGIC], [1.0, 0.0], [1.0, MAGIC], [SQRTHALF + MAGIC45, SQRTHALF - MAGIC45], [SQRTHALF, SQRTHALF], [SQRTHALF - MAGIC45, SQRTHALF + MAGIC45], [MAGIC, 1.0], [0.0, 1.0], [0.0, -1.0]], float)
            codes = np.full(14, cls.CURVE4, dtype=cls.code_type)
            codes[0] = cls.MOVETO
            codes[-1] = cls.CLOSEPOLY
            cls._unit_circle_righthalf = cls(vertices, codes, readonly=True)
        return cls._unit_circle_righthalf

    @classmethod
    def arc(cls, theta1, theta2, n=None, is_wedge=False):
        halfpi = np.pi * 0.5
        eta1 = theta1
        eta2 = theta2 - 360 * np.floor((theta2 - theta1) / 360)
        if theta2 != theta1 and eta2 <= eta1:
            eta2 += 360
        (eta1, eta2) = np.deg2rad([eta1, eta2])
        if n is None:
            n = int(2 ** np.ceil((eta2 - eta1) / halfpi))
        if n < 1:
            raise ValueError('n must be >= 1 or None')
        deta = (eta2 - eta1) / n
        t = np.tan(0.5 * deta)
        alpha = np.sin(deta) * (np.sqrt(4.0 + 3.0 * t * t) - 1) / 3.0
        steps = np.linspace(eta1, eta2, n + 1, True)
        cos_eta = np.cos(steps)
        sin_eta = np.sin(steps)
        xA = cos_eta[:-1]
        yA = sin_eta[:-1]
        xA_dot = -yA
        yA_dot = xA
        xB = cos_eta[1:]
        yB = sin_eta[1:]
        xB_dot = -yB
        yB_dot = xB
        if is_wedge:
            length = n * 3 + 4
            vertices = np.zeros((length, 2), float)
            codes = np.full(length, cls.CURVE4, dtype=cls.code_type)
            vertices[1] = [xA[0], yA[0]]
            codes[0:2] = [cls.MOVETO, cls.LINETO]
            codes[-2:] = [cls.LINETO, cls.CLOSEPOLY]
            vertex_offset = 2
            end = length - 2
        else:
            length = n * 3 + 1
            vertices = np.empty((length, 2), float)
            codes = np.full(length, cls.CURVE4, dtype=cls.code_type)
            vertices[0] = [xA[0], yA[0]]
            codes[0] = cls.MOVETO
            vertex_offset = 1
            end = length
        vertices[vertex_offset:end:3, 0] = xA + alpha * xA_dot
        vertices[vertex_offset:end:3, 1] = yA + alpha * yA_dot
        vertices[vertex_offset + 1:end:3, 0] = xB - alpha * xB_dot
        vertices[vertex_offset + 1:end:3, 1] = yB - alpha * yB_dot
        vertices[vertex_offset + 2:end:3, 0] = xB
        vertices[vertex_offset + 2:end:3, 1] = yB
        return cls(vertices, codes, readonly=True)

    @classmethod
    def wedge(cls, theta1, theta2, n=None):
        return cls.arc(theta1, theta2, n, True)

    @staticmethod
    @lru_cache(8)
    def hatch(hatchpattern, density=6):
        from matplotlib.hatch import get_path
        return get_path(hatchpattern, density) if hatchpattern is not None else None

    def clip_to_bbox(self, bbox, inside=True):
        verts = _path.clip_path_to_rect(self, bbox, inside)
        paths = [Path(poly) for poly in verts]
        return self.make_compound_path(*paths)

def get_path_collection_extents(master_transform, paths, transforms, offsets, offset_transform):
    from .transforms import Bbox
    if len(paths) == 0:
        raise ValueError('No paths provided')
    if len(offsets) == 0:
        _api.warn_deprecated('3.8', message='Calling get_path_collection_extents() with an empty offsets list is deprecated since %(since)s. Support will be removed %(removal)s.')
    (extents, minpos) = _path.get_path_collection_extents(master_transform, paths, np.atleast_3d(transforms), offsets, offset_transform)
    return Bbox.from_extents(*extents, minpos=minpos)

# File: matplotlib-main/lib/matplotlib/patheffects.py
""""""
from matplotlib.backend_bases import RendererBase
from matplotlib import colors as mcolors
from matplotlib import patches as mpatches
from matplotlib import transforms as mtransforms
from matplotlib.path import Path
import numpy as np

class AbstractPathEffect:

    def __init__(self, offset=(0.0, 0.0)):
        self._offset = offset

    def _offset_transform(self, renderer):
        return mtransforms.Affine2D().translate(*map(renderer.points_to_pixels, self._offset))

    def _update_gc(self, gc, new_gc_dict):
        new_gc_dict = new_gc_dict.copy()
        dashes = new_gc_dict.pop('dashes', None)
        if dashes:
            gc.set_dashes(**dashes)
        for (k, v) in new_gc_dict.items():
            set_method = getattr(gc, 'set_' + k, None)
            if not callable(set_method):
                raise AttributeError(f'Unknown property {k}')
            set_method(v)
        return gc

    def draw_path(self, renderer, gc, tpath, affine, rgbFace=None):
        if isinstance(renderer, PathEffectRenderer):
            renderer = renderer._renderer
        return renderer.draw_path(gc, tpath, affine, rgbFace)

class PathEffectRenderer(RendererBase):

    def __init__(self, path_effects, renderer):
        self._path_effects = path_effects
        self._renderer = renderer

    def copy_with_path_effect(self, path_effects):
        return self.__class__(path_effects, self._renderer)

    def __getattribute__(self, name):
        if name in ['flipy', 'get_canvas_width_height', 'new_gc', 'points_to_pixels', '_text2path', 'height', 'width']:
            return getattr(self._renderer, name)
        else:
            return object.__getattribute__(self, name)

    def draw_path(self, gc, tpath, affine, rgbFace=None):
        for path_effect in self._path_effects:
            path_effect.draw_path(self._renderer, gc, tpath, affine, rgbFace)

    def draw_markers(self, gc, marker_path, marker_trans, path, *args, **kwargs):
        if len(self._path_effects) == 1:
            return super().draw_markers(gc, marker_path, marker_trans, path, *args, **kwargs)
        for path_effect in self._path_effects:
            renderer = self.copy_with_path_effect([path_effect])
            renderer.draw_markers(gc, marker_path, marker_trans, path, *args, **kwargs)

    def draw_path_collection(self, gc, master_transform, paths, *args, **kwargs):
        if len(self._path_effects) == 1:
            return super().draw_path_collection(gc, master_transform, paths, *args, **kwargs)
        for path_effect in self._path_effects:
            renderer = self.copy_with_path_effect([path_effect])
            renderer.draw_path_collection(gc, master_transform, paths, *args, **kwargs)

    def open_group(self, s, gid=None):
        return self._renderer.open_group(s, gid)

    def close_group(self, s):
        return self._renderer.close_group(s)

class Normal(AbstractPathEffect):

def _subclass_with_normal(effect_class):

    class withEffect(effect_class):

        def draw_path(self, renderer, gc, tpath, affine, rgbFace):
            super().draw_path(renderer, gc, tpath, affine, rgbFace)
            renderer.draw_path(gc, tpath, affine, rgbFace)
    withEffect.__name__ = f'with{effect_class.__name__}'
    withEffect.__qualname__ = f'with{effect_class.__name__}'
    withEffect.__doc__ = f'\n    A shortcut PathEffect for applying `.{effect_class.__name__}` and then\n    drawing the original Artist.\n\n    With this class you can use ::\n\n        artist.set_path_effects([patheffects.with{effect_class.__name__}()])\n\n    as a shortcut for ::\n\n        artist.set_path_effects([patheffects.{effect_class.__name__}(),\n                                 patheffects.Normal()])\n    '
    withEffect.draw_path.__doc__ = effect_class.draw_path.__doc__
    return withEffect

class Stroke(AbstractPathEffect):

    def __init__(self, offset=(0, 0), **kwargs):
        super().__init__(offset)
        self._gc = kwargs

    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
        gc0 = renderer.new_gc()
        gc0.copy_properties(gc)
        gc0 = self._update_gc(gc0, self._gc)
        renderer.draw_path(gc0, tpath, affine + self._offset_transform(renderer), rgbFace)
        gc0.restore()
withStroke = _subclass_with_normal(effect_class=Stroke)

class SimplePatchShadow(AbstractPathEffect):

    def __init__(self, offset=(2, -2), shadow_rgbFace=None, alpha=None, rho=0.3, **kwargs):
        super().__init__(offset)
        if shadow_rgbFace is None:
            self._shadow_rgbFace = shadow_rgbFace
        else:
            self._shadow_rgbFace = mcolors.to_rgba(shadow_rgbFace)
        if alpha is None:
            alpha = 0.3
        self._alpha = alpha
        self._rho = rho
        self._gc = kwargs

    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
        gc0 = renderer.new_gc()
        gc0.copy_properties(gc)
        if self._shadow_rgbFace is None:
            (r, g, b) = (rgbFace or (1.0, 1.0, 1.0))[:3]
            shadow_rgbFace = (r * self._rho, g * self._rho, b * self._rho)
        else:
            shadow_rgbFace = self._shadow_rgbFace
        gc0.set_foreground('none')
        gc0.set_alpha(self._alpha)
        gc0.set_linewidth(0)
        gc0 = self._update_gc(gc0, self._gc)
        renderer.draw_path(gc0, tpath, affine + self._offset_transform(renderer), shadow_rgbFace)
        gc0.restore()
withSimplePatchShadow = _subclass_with_normal(effect_class=SimplePatchShadow)

class SimpleLineShadow(AbstractPathEffect):

    def __init__(self, offset=(2, -2), shadow_color='k', alpha=0.3, rho=0.3, **kwargs):
        super().__init__(offset)
        if shadow_color is None:
            self._shadow_color = shadow_color
        else:
            self._shadow_color = mcolors.to_rgba(shadow_color)
        self._alpha = alpha
        self._rho = rho
        self._gc = kwargs

    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
        gc0 = renderer.new_gc()
        gc0.copy_properties(gc)
        if self._shadow_color is None:
            (r, g, b) = (gc0.get_foreground() or (1.0, 1.0, 1.0))[:3]
            shadow_rgbFace = (r * self._rho, g * self._rho, b * self._rho)
        else:
            shadow_rgbFace = self._shadow_color
        gc0.set_foreground(shadow_rgbFace)
        gc0.set_alpha(self._alpha)
        gc0 = self._update_gc(gc0, self._gc)
        renderer.draw_path(gc0, tpath, affine + self._offset_transform(renderer))
        gc0.restore()

class PathPatchEffect(AbstractPathEffect):

    def __init__(self, offset=(0, 0), **kwargs):
        super().__init__(offset=offset)
        self.patch = mpatches.PathPatch([], **kwargs)

    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
        self.patch._path = tpath
        self.patch.set_transform(affine + self._offset_transform(renderer))
        self.patch.set_clip_box(gc.get_clip_rectangle())
        clip_path = gc.get_clip_path()
        if clip_path and self.patch.get_clip_path() is None:
            self.patch.set_clip_path(*clip_path)
        self.patch.draw(renderer)

class TickedStroke(AbstractPathEffect):

    def __init__(self, offset=(0, 0), spacing=10.0, angle=45.0, length=np.sqrt(2), **kwargs):
        super().__init__(offset)
        self._spacing = spacing
        self._angle = angle
        self._length = length
        self._gc = kwargs

    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
        gc0 = renderer.new_gc()
        gc0.copy_properties(gc)
        gc0 = self._update_gc(gc0, self._gc)
        trans = affine + self._offset_transform(renderer)
        theta = -np.radians(self._angle)
        trans_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
        spacing_px = renderer.points_to_pixels(self._spacing)
        transpath = affine.transform_path(tpath)
        polys = transpath.to_polygons(closed_only=False)
        for p in polys:
            x = p[:, 0]
            y = p[:, 1]
            if x.size < 2:
                continue
            ds = np.hypot(x[1:] - x[:-1], y[1:] - y[:-1])
            s = np.concatenate(([0.0], np.cumsum(ds)))
            s_total = s[-1]
            num = int(np.ceil(s_total / spacing_px)) - 1
            s_tick = np.linspace(spacing_px / 2, s_total - spacing_px / 2, num)
            x_tick = np.interp(s_tick, s, x)
            y_tick = np.interp(s_tick, s, y)
            delta_s = self._spacing * 0.001
            u = (np.interp(s_tick + delta_s, s, x) - x_tick) / delta_s
            v = (np.interp(s_tick + delta_s, s, y) - y_tick) / delta_s
            n = np.hypot(u, v)
            mask = n == 0
            n[mask] = 1.0
            uv = np.array([u / n, v / n]).T
            uv[mask] = np.array([0, 0]).T
            dxy = np.dot(uv, trans_matrix) * self._length * spacing_px
            x_end = x_tick + dxy[:, 0]
            y_end = y_tick + dxy[:, 1]
            xyt = np.empty((2 * num, 2), dtype=x_tick.dtype)
            xyt[0::2, 0] = x_tick
            xyt[1::2, 0] = x_end
            xyt[0::2, 1] = y_tick
            xyt[1::2, 1] = y_end
            codes = np.tile([Path.MOVETO, Path.LINETO], num)
            h = Path(xyt, codes)
            renderer.draw_path(gc0, h, affine.inverted() + trans, rgbFace)
        gc0.restore()
withTickedStroke = _subclass_with_normal(effect_class=TickedStroke)

# File: matplotlib-main/lib/matplotlib/projections/__init__.py
""""""
from .. import axes, _docstring
from .geo import AitoffAxes, HammerAxes, LambertAxes, MollweideAxes
from .polar import PolarAxes
try:
    from mpl_toolkits.mplot3d import Axes3D
except Exception:
    import warnings
    warnings.warn('Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.')
    Axes3D = None

class ProjectionRegistry:

    def __init__(self):
        self._all_projection_types = {}

    def register(self, *projections):
        for projection in projections:
            name = projection.name
            self._all_projection_types[name] = projection

    def get_projection_class(self, name):
        return self._all_projection_types[name]

    def get_projection_names(self):
        return sorted(self._all_projection_types)
projection_registry = ProjectionRegistry()
projection_registry.register(axes.Axes, PolarAxes, AitoffAxes, HammerAxes, LambertAxes, MollweideAxes)
if Axes3D is not None:
    projection_registry.register(Axes3D)
else:
    del Axes3D

def register_projection(cls):
    projection_registry.register(cls)

def get_projection_class(projection=None):
    if projection is None:
        projection = 'rectilinear'
    try:
        return projection_registry.get_projection_class(projection)
    except KeyError as err:
        raise ValueError('Unknown projection %r' % projection) from err
get_projection_names = projection_registry.get_projection_names
_docstring.interpd.update(projection_names=get_projection_names())

# File: matplotlib-main/lib/matplotlib/projections/geo.py
import numpy as np
import matplotlib as mpl
from matplotlib import _api
from matplotlib.axes import Axes
import matplotlib.axis as maxis
from matplotlib.patches import Circle
from matplotlib.path import Path
import matplotlib.spines as mspines
from matplotlib.ticker import Formatter, NullLocator, FixedLocator, NullFormatter
from matplotlib.transforms import Affine2D, BboxTransformTo, Transform

class GeoAxes(Axes):

    class ThetaFormatter(Formatter):

        def __init__(self, round_to=1.0):
            self._round_to = round_to

        def __call__(self, x, pos=None):
            degrees = round(np.rad2deg(x) / self._round_to) * self._round_to
            return f'{degrees:0.0f}°'
    RESOLUTION = 75

    def _init_axis(self):
        self.xaxis = maxis.XAxis(self, clear=False)
        self.yaxis = maxis.YAxis(self, clear=False)
        self.spines['geo'].register_axis(self.yaxis)

    def clear(self):
        super().clear()
        self.set_longitude_grid(30)
        self.set_latitude_grid(15)
        self.set_longitude_grid_ends(75)
        self.xaxis.set_minor_locator(NullLocator())
        self.yaxis.set_minor_locator(NullLocator())
        self.xaxis.set_ticks_position('none')
        self.yaxis.set_ticks_position('none')
        self.yaxis.set_tick_params(label1On=True)
        self.grid(mpl.rcParams['axes.grid'])
        Axes.set_xlim(self, -np.pi, np.pi)
        Axes.set_ylim(self, -np.pi / 2.0, np.pi / 2.0)

    def _set_lim_and_transforms(self):
        self.transProjection = self._get_core_transform(self.RESOLUTION)
        self.transAffine = self._get_affine_transform()
        self.transAxes = BboxTransformTo(self.bbox)
        self.transData = self.transProjection + self.transAffine + self.transAxes
        self._xaxis_pretransform = Affine2D().scale(1, self._longitude_cap * 2).translate(0, -self._longitude_cap)
        self._xaxis_transform = self._xaxis_pretransform + self.transData
        self._xaxis_text1_transform = Affine2D().scale(1, 0) + self.transData + Affine2D().translate(0, 4)
        self._xaxis_text2_transform = Affine2D().scale(1, 0) + self.transData + Affine2D().translate(0, -4)
        yaxis_stretch = Affine2D().scale(np.pi * 2, 1).translate(-np.pi, 0)
        yaxis_space = Affine2D().scale(1, 1.1)
        self._yaxis_transform = yaxis_stretch + self.transData
        yaxis_text_base = yaxis_stretch + self.transProjection + (yaxis_space + self.transAffine + self.transAxes)
        self._yaxis_text1_transform = yaxis_text_base + Affine2D().translate(-8, 0)
        self._yaxis_text2_transform = yaxis_text_base + Affine2D().translate(8, 0)

    def _get_affine_transform(self):
        transform = self._get_core_transform(1)
        (xscale, _) = transform.transform((np.pi, 0))
        (_, yscale) = transform.transform((0, np.pi / 2))
        return Affine2D().scale(0.5 / xscale, 0.5 / yscale).translate(0.5, 0.5)

    def get_xaxis_transform(self, which='grid'):
        _api.check_in_list(['tick1', 'tick2', 'grid'], which=which)
        return self._xaxis_transform

    def get_xaxis_text1_transform(self, pad):
        return (self._xaxis_text1_transform, 'bottom', 'center')

    def get_xaxis_text2_transform(self, pad):
        return (self._xaxis_text2_transform, 'top', 'center')

    def get_yaxis_transform(self, which='grid'):
        _api.check_in_list(['tick1', 'tick2', 'grid'], which=which)
        return self._yaxis_transform

    def get_yaxis_text1_transform(self, pad):
        return (self._yaxis_text1_transform, 'center', 'right')

    def get_yaxis_text2_transform(self, pad):
        return (self._yaxis_text2_transform, 'center', 'left')

    def _gen_axes_patch(self):
        return Circle((0.5, 0.5), 0.5)

    def _gen_axes_spines(self):
        return {'geo': mspines.Spine.circular_spine(self, (0.5, 0.5), 0.5)}

    def set_yscale(self, *args, **kwargs):
        if args[0] != 'linear':
            raise NotImplementedError
    set_xscale = set_yscale

    def set_xlim(self, *args, **kwargs):
        raise TypeError('Changing axes limits of a geographic projection is not supported.  Please consider using Cartopy.')
    set_ylim = set_xlim
    set_xbound = set_xlim
    set_ybound = set_ylim

    def invert_xaxis(self):
        raise TypeError('Changing axes limits of a geographic projection is not supported.  Please consider using Cartopy.')
    invert_yaxis = invert_xaxis

    def format_coord(self, lon, lat):
        (lon, lat) = np.rad2deg([lon, lat])
        ns = 'N' if lat >= 0.0 else 'S'
        ew = 'E' if lon >= 0.0 else 'W'
        return '%f°%s, %f°%s' % (abs(lat), ns, abs(lon), ew)

    def set_longitude_grid(self, degrees):
        grid = np.arange(-180 + degrees, 180, degrees)
        self.xaxis.set_major_locator(FixedLocator(np.deg2rad(grid)))
        self.xaxis.set_major_formatter(self.ThetaFormatter(degrees))

    def set_latitude_grid(self, degrees):
        grid = np.arange(-90 + degrees, 90, degrees)
        self.yaxis.set_major_locator(FixedLocator(np.deg2rad(grid)))
        self.yaxis.set_major_formatter(self.ThetaFormatter(degrees))

    def set_longitude_grid_ends(self, degrees):
        self._longitude_cap = np.deg2rad(degrees)
        self._xaxis_pretransform.clear().scale(1.0, self._longitude_cap * 2.0).translate(0.0, -self._longitude_cap)

    def get_data_ratio(self):
        return 1.0

    def can_zoom(self):
        return False

    def can_pan(self):
        return False

    def start_pan(self, x, y, button):
        pass

    def end_pan(self):
        pass

    def drag_pan(self, button, key, x, y):
        pass

class _GeoTransform(Transform):
    input_dims = output_dims = 2

    def __init__(self, resolution):
        super().__init__()
        self._resolution = resolution

    def __str__(self):
        return f'{type(self).__name__}({self._resolution})'

    def transform_path_non_affine(self, path):
        ipath = path.interpolated(self._resolution)
        return Path(self.transform(ipath.vertices), ipath.codes)

class AitoffAxes(GeoAxes):
    name = 'aitoff'

    class AitoffTransform(_GeoTransform):

        def transform_non_affine(self, values):
            (longitude, latitude) = values.T
            half_long = longitude / 2.0
            cos_latitude = np.cos(latitude)
            alpha = np.arccos(cos_latitude * np.cos(half_long))
            sinc_alpha = np.sinc(alpha / np.pi)
            x = cos_latitude * np.sin(half_long) / sinc_alpha
            y = np.sin(latitude) / sinc_alpha
            return np.column_stack([x, y])

        def inverted(self):
            return AitoffAxes.InvertedAitoffTransform(self._resolution)

    class InvertedAitoffTransform(_GeoTransform):

        def transform_non_affine(self, values):
            return np.full_like(values, np.nan)

        def inverted(self):
            return AitoffAxes.AitoffTransform(self._resolution)

    def __init__(self, *args, **kwargs):
        self._longitude_cap = np.pi / 2.0
        super().__init__(*args, **kwargs)
        self.set_aspect(0.5, adjustable='box', anchor='C')
        self.clear()

    def _get_core_transform(self, resolution):
        return self.AitoffTransform(resolution)

class HammerAxes(GeoAxes):
    name = 'hammer'

    class HammerTransform(_GeoTransform):

        def transform_non_affine(self, values):
            (longitude, latitude) = values.T
            half_long = longitude / 2.0
            cos_latitude = np.cos(latitude)
            sqrt2 = np.sqrt(2.0)
            alpha = np.sqrt(1.0 + cos_latitude * np.cos(half_long))
            x = 2.0 * sqrt2 * (cos_latitude * np.sin(half_long)) / alpha
            y = sqrt2 * np.sin(latitude) / alpha
            return np.column_stack([x, y])

        def inverted(self):
            return HammerAxes.InvertedHammerTransform(self._resolution)

    class InvertedHammerTransform(_GeoTransform):

        def transform_non_affine(self, values):
            (x, y) = values.T
            z = np.sqrt(1 - (x / 4) ** 2 - (y / 2) ** 2)
            longitude = 2 * np.arctan(z * x / (2 * (2 * z ** 2 - 1)))
            latitude = np.arcsin(y * z)
            return np.column_stack([longitude, latitude])

        def inverted(self):
            return HammerAxes.HammerTransform(self._resolution)

    def __init__(self, *args, **kwargs):
        self._longitude_cap = np.pi / 2.0
        super().__init__(*args, **kwargs)
        self.set_aspect(0.5, adjustable='box', anchor='C')
        self.clear()

    def _get_core_transform(self, resolution):
        return self.HammerTransform(resolution)

class MollweideAxes(GeoAxes):
    name = 'mollweide'

    class MollweideTransform(_GeoTransform):

        def transform_non_affine(self, values):

            def d(theta):
                delta = -(theta + np.sin(theta) - pi_sin_l) / (1 + np.cos(theta))
                return (delta, np.abs(delta) > 0.001)
            (longitude, latitude) = values.T
            clat = np.pi / 2 - np.abs(latitude)
            ihigh = clat < 0.087
            ilow = ~ihigh
            aux = np.empty(latitude.shape, dtype=float)
            if ilow.any():
                pi_sin_l = np.pi * np.sin(latitude[ilow])
                theta = 2.0 * latitude[ilow]
                (delta, large_delta) = d(theta)
                while np.any(large_delta):
                    theta[large_delta] += delta[large_delta]
                    (delta, large_delta) = d(theta)
                aux[ilow] = theta / 2
            if ihigh.any():
                e = clat[ihigh]
                d = 0.5 * (3 * np.pi * e ** 2) ** (1.0 / 3)
                aux[ihigh] = (np.pi / 2 - d) * np.sign(latitude[ihigh])
            xy = np.empty(values.shape, dtype=float)
            xy[:, 0] = 2.0 * np.sqrt(2.0) / np.pi * longitude * np.cos(aux)
            xy[:, 1] = np.sqrt(2.0) * np.sin(aux)
            return xy

        def inverted(self):
            return MollweideAxes.InvertedMollweideTransform(self._resolution)

    class InvertedMollweideTransform(_GeoTransform):

        def transform_non_affine(self, values):
            (x, y) = values.T
            theta = np.arcsin(y / np.sqrt(2))
            longitude = np.pi / (2 * np.sqrt(2)) * x / np.cos(theta)
            latitude = np.arcsin((2 * theta + np.sin(2 * theta)) / np.pi)
            return np.column_stack([longitude, latitude])

        def inverted(self):
            return MollweideAxes.MollweideTransform(self._resolution)

    def __init__(self, *args, **kwargs):
        self._longitude_cap = np.pi / 2.0
        super().__init__(*args, **kwargs)
        self.set_aspect(0.5, adjustable='box', anchor='C')
        self.clear()

    def _get_core_transform(self, resolution):
        return self.MollweideTransform(resolution)

class LambertAxes(GeoAxes):
    name = 'lambert'

    class LambertTransform(_GeoTransform):

        def __init__(self, center_longitude, center_latitude, resolution):
            _GeoTransform.__init__(self, resolution)
            self._center_longitude = center_longitude
            self._center_latitude = center_latitude

        def transform_non_affine(self, values):
            (longitude, latitude) = values.T
            clong = self._center_longitude
            clat = self._center_latitude
            cos_lat = np.cos(latitude)
            sin_lat = np.sin(latitude)
            diff_long = longitude - clong
            cos_diff_long = np.cos(diff_long)
            inner_k = np.maximum(1 + np.sin(clat) * sin_lat + np.cos(clat) * cos_lat * cos_diff_long, 1e-15)
            k = np.sqrt(2 / inner_k)
            x = k * cos_lat * np.sin(diff_long)
            y = k * (np.cos(clat) * sin_lat - np.sin(clat) * cos_lat * cos_diff_long)
            return np.column_stack([x, y])

        def inverted(self):
            return LambertAxes.InvertedLambertTransform(self._center_longitude, self._center_latitude, self._resolution)

    class InvertedLambertTransform(_GeoTransform):

        def __init__(self, center_longitude, center_latitude, resolution):
            _GeoTransform.__init__(self, resolution)
            self._center_longitude = center_longitude
            self._center_latitude = center_latitude

        def transform_non_affine(self, values):
            (x, y) = values.T
            clong = self._center_longitude
            clat = self._center_latitude
            p = np.maximum(np.hypot(x, y), 1e-09)
            c = 2 * np.arcsin(0.5 * p)
            sin_c = np.sin(c)
            cos_c = np.cos(c)
            latitude = np.arcsin(cos_c * np.sin(clat) + y * sin_c * np.cos(clat) / p)
            longitude = clong + np.arctan(x * sin_c / (p * np.cos(clat) * cos_c - y * np.sin(clat) * sin_c))
            return np.column_stack([longitude, latitude])

        def inverted(self):
            return LambertAxes.LambertTransform(self._center_longitude, self._center_latitude, self._resolution)

    def __init__(self, *args, center_longitude=0, center_latitude=0, **kwargs):
        self._longitude_cap = np.pi / 2
        self._center_longitude = center_longitude
        self._center_latitude = center_latitude
        super().__init__(*args, **kwargs)
        self.set_aspect('equal', adjustable='box', anchor='C')
        self.clear()

    def clear(self):
        super().clear()
        self.yaxis.set_major_formatter(NullFormatter())

    def _get_core_transform(self, resolution):
        return self.LambertTransform(self._center_longitude, self._center_latitude, resolution)

    def _get_affine_transform(self):
        return Affine2D().scale(0.25).translate(0.5, 0.5)

# File: matplotlib-main/lib/matplotlib/projections/polar.py
import math
import types
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
from matplotlib.axes import Axes
import matplotlib.axis as maxis
import matplotlib.markers as mmarkers
import matplotlib.patches as mpatches
from matplotlib.path import Path
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
from matplotlib.spines import Spine

def _apply_theta_transforms_warn():
    _api.warn_deprecated('3.9', message='Passing `apply_theta_transforms=True` (the default) is deprecated since Matplotlib %(since)s. Support for this will be removed in Matplotlib %(removal)s. To prevent this warning, set `apply_theta_transforms=False`, and make sure to shift theta values before being passed to this transform.')

class PolarTransform(mtransforms.Transform):
    input_dims = output_dims = 2

    def __init__(self, axis=None, use_rmin=True, *, apply_theta_transforms=True, scale_transform=None):
        super().__init__()
        self._axis = axis
        self._use_rmin = use_rmin
        self._apply_theta_transforms = apply_theta_transforms
        self._scale_transform = scale_transform
        if apply_theta_transforms:
            _apply_theta_transforms_warn()
    __str__ = mtransforms._make_str_method('_axis', use_rmin='_use_rmin', apply_theta_transforms='_apply_theta_transforms')

    def _get_rorigin(self):
        return self._scale_transform.transform((0, self._axis.get_rorigin()))[1]

    def transform_non_affine(self, values):
        (theta, r) = np.transpose(values)
        if self._apply_theta_transforms and self._axis is not None:
            theta *= self._axis.get_theta_direction()
            theta += self._axis.get_theta_offset()
        if self._use_rmin and self._axis is not None:
            r = (r - self._get_rorigin()) * self._axis.get_rsign()
        r = np.where(r >= 0, r, np.nan)
        return np.column_stack([r * np.cos(theta), r * np.sin(theta)])

    def transform_path_non_affine(self, path):
        if not len(path) or path._interpolation_steps == 1:
            return Path(self.transform_non_affine(path.vertices), path.codes)
        xys = []
        codes = []
        last_t = last_r = None
        for (trs, c) in path.iter_segments():
            trs = trs.reshape((-1, 2))
            if c == Path.LINETO:
                ((t, r),) = trs
                if t == last_t:
                    xys.extend(self.transform_non_affine(trs))
                    codes.append(Path.LINETO)
                elif r == last_r:
                    (last_td, td) = np.rad2deg([last_t, t])
                    if self._use_rmin and self._axis is not None:
                        r = (r - self._get_rorigin()) * self._axis.get_rsign()
                    if last_td <= td:
                        while td - last_td > 360:
                            arc = Path.arc(last_td, last_td + 360)
                            xys.extend(arc.vertices[1:] * r)
                            codes.extend(arc.codes[1:])
                            last_td += 360
                        arc = Path.arc(last_td, td)
                        xys.extend(arc.vertices[1:] * r)
                        codes.extend(arc.codes[1:])
                    else:
                        while last_td - td > 360:
                            arc = Path.arc(last_td - 360, last_td)
                            xys.extend(arc.vertices[::-1][1:] * r)
                            codes.extend(arc.codes[1:])
                            last_td -= 360
                        arc = Path.arc(td, last_td)
                        xys.extend(arc.vertices[::-1][1:] * r)
                        codes.extend(arc.codes[1:])
                else:
                    trs = cbook.simple_linear_interpolation(np.vstack([(last_t, last_r), trs]), path._interpolation_steps)[1:]
                    xys.extend(self.transform_non_affine(trs))
                    codes.extend([Path.LINETO] * len(trs))
            else:
                xys.extend(self.transform_non_affine(trs))
                codes.extend([c] * len(trs))
            (last_t, last_r) = trs[-1]
        return Path(xys, codes)

    def inverted(self):
        return PolarAxes.InvertedPolarTransform(self._axis, self._use_rmin, apply_theta_transforms=self._apply_theta_transforms)

class PolarAffine(mtransforms.Affine2DBase):

    def __init__(self, scale_transform, limits):
        super().__init__()
        self._scale_transform = scale_transform
        self._limits = limits
        self.set_children(scale_transform, limits)
        self._mtx = None
    __str__ = mtransforms._make_str_method('_scale_transform', '_limits')

    def get_matrix(self):
        if self._invalid:
            limits_scaled = self._limits.transformed(self._scale_transform)
            yscale = limits_scaled.ymax - limits_scaled.ymin
            affine = mtransforms.Affine2D().scale(0.5 / yscale).translate(0.5, 0.5)
            self._mtx = affine.get_matrix()
            self._inverted = None
            self._invalid = 0
        return self._mtx

class InvertedPolarTransform(mtransforms.Transform):
    input_dims = output_dims = 2

    def __init__(self, axis=None, use_rmin=True, *, apply_theta_transforms=True):
        super().__init__()
        self._axis = axis
        self._use_rmin = use_rmin
        self._apply_theta_transforms = apply_theta_transforms
        if apply_theta_transforms:
            _apply_theta_transforms_warn()
    __str__ = mtransforms._make_str_method('_axis', use_rmin='_use_rmin', apply_theta_transforms='_apply_theta_transforms')

    def transform_non_affine(self, values):
        (x, y) = values.T
        r = np.hypot(x, y)
        theta = (np.arctan2(y, x) + 2 * np.pi) % (2 * np.pi)
        if self._apply_theta_transforms and self._axis is not None:
            theta -= self._axis.get_theta_offset()
            theta *= self._axis.get_theta_direction()
            theta %= 2 * np.pi
        if self._use_rmin and self._axis is not None:
            r += self._axis.get_rorigin()
            r *= self._axis.get_rsign()
        return np.column_stack([theta, r])

    def inverted(self):
        return PolarAxes.PolarTransform(self._axis, self._use_rmin, apply_theta_transforms=self._apply_theta_transforms)

class ThetaFormatter(mticker.Formatter):

    def __call__(self, x, pos=None):
        (vmin, vmax) = self.axis.get_view_interval()
        d = np.rad2deg(abs(vmax - vmin))
        digits = max(-int(np.log10(d) - 1.5), 0)
        return f'{np.rad2deg(x):0.{digits}f}°'

class _AxisWrapper:

    def __init__(self, axis):
        self._axis = axis

    def get_view_interval(self):
        return np.rad2deg(self._axis.get_view_interval())

    def set_view_interval(self, vmin, vmax):
        self._axis.set_view_interval(*np.deg2rad((vmin, vmax)))

    def get_minpos(self):
        return np.rad2deg(self._axis.get_minpos())

    def get_data_interval(self):
        return np.rad2deg(self._axis.get_data_interval())

    def set_data_interval(self, vmin, vmax):
        self._axis.set_data_interval(*np.deg2rad((vmin, vmax)))

    def get_tick_space(self):
        return self._axis.get_tick_space()

class ThetaLocator(mticker.Locator):

    def __init__(self, base):
        self.base = base
        self.axis = self.base.axis = _AxisWrapper(self.base.axis)

    def set_axis(self, axis):
        self.axis = _AxisWrapper(axis)
        self.base.set_axis(self.axis)

    def __call__(self):
        lim = self.axis.get_view_interval()
        if _is_full_circle_deg(lim[0], lim[1]):
            return np.deg2rad(min(lim)) + np.arange(8) * 2 * np.pi / 8
        else:
            return np.deg2rad(self.base())

    def view_limits(self, vmin, vmax):
        (vmin, vmax) = np.rad2deg((vmin, vmax))
        return np.deg2rad(self.base.view_limits(vmin, vmax))

class ThetaTick(maxis.XTick):

    def __init__(self, axes, *args, **kwargs):
        self._text1_translate = mtransforms.ScaledTranslation(0, 0, axes.get_figure(root=False).dpi_scale_trans)
        self._text2_translate = mtransforms.ScaledTranslation(0, 0, axes.get_figure(root=False).dpi_scale_trans)
        super().__init__(axes, *args, **kwargs)
        self.label1.set(rotation_mode='anchor', transform=self.label1.get_transform() + self._text1_translate)
        self.label2.set(rotation_mode='anchor', transform=self.label2.get_transform() + self._text2_translate)

    def _apply_params(self, **kwargs):
        super()._apply_params(**kwargs)
        trans = self.label1.get_transform()
        if not trans.contains_branch(self._text1_translate):
            self.label1.set_transform(trans + self._text1_translate)
        trans = self.label2.get_transform()
        if not trans.contains_branch(self._text2_translate):
            self.label2.set_transform(trans + self._text2_translate)

    def _update_padding(self, pad, angle):
        padx = pad * np.cos(angle) / 72
        pady = pad * np.sin(angle) / 72
        self._text1_translate._t = (padx, pady)
        self._text1_translate.invalidate()
        self._text2_translate._t = (-padx, -pady)
        self._text2_translate.invalidate()

    def update_position(self, loc):
        super().update_position(loc)
        axes = self.axes
        angle = loc * axes.get_theta_direction() + axes.get_theta_offset()
        text_angle = np.rad2deg(angle) % 360 - 90
        angle -= np.pi / 2
        marker = self.tick1line.get_marker()
        if marker in (mmarkers.TICKUP, '|'):
            trans = mtransforms.Affine2D().scale(1, 1).rotate(angle)
        elif marker == mmarkers.TICKDOWN:
            trans = mtransforms.Affine2D().scale(1, -1).rotate(angle)
        else:
            trans = self.tick1line._marker._transform
        self.tick1line._marker._transform = trans
        marker = self.tick2line.get_marker()
        if marker in (mmarkers.TICKUP, '|'):
            trans = mtransforms.Affine2D().scale(1, 1).rotate(angle)
        elif marker == mmarkers.TICKDOWN:
            trans = mtransforms.Affine2D().scale(1, -1).rotate(angle)
        else:
            trans = self.tick2line._marker._transform
        self.tick2line._marker._transform = trans
        (mode, user_angle) = self._labelrotation
        if mode == 'default':
            text_angle = user_angle
        else:
            if text_angle > 90:
                text_angle -= 180
            elif text_angle < -90:
                text_angle += 180
            text_angle += user_angle
        self.label1.set_rotation(text_angle)
        self.label2.set_rotation(text_angle)
        pad = self._pad + 7
        self._update_padding(pad, self._loc * axes.get_theta_direction() + axes.get_theta_offset())

class ThetaAxis(maxis.XAxis):
    __name__ = 'thetaaxis'
    axis_name = 'theta'
    _tick_class = ThetaTick

    def _wrap_locator_formatter(self):
        self.set_major_locator(ThetaLocator(self.get_major_locator()))
        self.set_major_formatter(ThetaFormatter())
        self.isDefault_majloc = True
        self.isDefault_majfmt = True

    def clear(self):
        super().clear()
        self.set_ticks_position('none')
        self._wrap_locator_formatter()

    def _set_scale(self, value, **kwargs):
        if value != 'linear':
            raise NotImplementedError('The xscale cannot be set on a polar plot')
        super()._set_scale(value, **kwargs)
        self.get_major_locator().set_params(steps=[1, 1.5, 3, 4.5, 9, 10])
        self._wrap_locator_formatter()

    def _copy_tick_props(self, src, dest):
        if src is None or dest is None:
            return
        super()._copy_tick_props(src, dest)
        trans = dest._get_text1_transform()[0]
        dest.label1.set_transform(trans + dest._text1_translate)
        trans = dest._get_text2_transform()[0]
        dest.label2.set_transform(trans + dest._text2_translate)

class RadialLocator(mticker.Locator):

    def __init__(self, base, axes=None):
        self.base = base
        self._axes = axes

    def set_axis(self, axis):
        self.base.set_axis(axis)

    def __call__(self):
        if self._axes:
            if _is_full_circle_rad(*self._axes.viewLim.intervalx):
                rorigin = self._axes.get_rorigin() * self._axes.get_rsign()
                if self._axes.get_rmin() <= rorigin:
                    return [tick for tick in self.base() if tick > rorigin]
        return self.base()

    def _zero_in_bounds(self):
        (vmin, vmax) = self._axes.yaxis._scale.limit_range_for_scale(0, 1, 1e-05)
        return vmin == 0

    def nonsingular(self, vmin, vmax):
        if self._zero_in_bounds() and (vmin, vmax) == (-np.inf, np.inf):
            return (0, 1)
        else:
            return self.base.nonsingular(vmin, vmax)

    def view_limits(self, vmin, vmax):
        (vmin, vmax) = self.base.view_limits(vmin, vmax)
        if self._zero_in_bounds() and vmax > vmin:
            vmin = min(0, vmin)
        return mtransforms.nonsingular(vmin, vmax)

class _ThetaShift(mtransforms.ScaledTranslation):

    def __init__(self, axes, pad, mode):
        super().__init__(pad, pad, axes.get_figure(root=False).dpi_scale_trans)
        self.set_children(axes._realViewLim)
        self.axes = axes
        self.mode = mode
        self.pad = pad
    __str__ = mtransforms._make_str_method('axes', 'pad', 'mode')

    def get_matrix(self):
        if self._invalid:
            if self.mode == 'rlabel':
                angle = np.deg2rad(self.axes.get_rlabel_position() * self.axes.get_theta_direction()) + self.axes.get_theta_offset() - np.pi / 2
            elif self.mode == 'min':
                angle = self.axes._realViewLim.xmin - np.pi / 2
            elif self.mode == 'max':
                angle = self.axes._realViewLim.xmax + np.pi / 2
            self._t = (self.pad * np.cos(angle) / 72, self.pad * np.sin(angle) / 72)
        return super().get_matrix()

class RadialTick(maxis.YTick):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.label1.set_rotation_mode('anchor')
        self.label2.set_rotation_mode('anchor')

    def _determine_anchor(self, mode, angle, start):
        if mode == 'auto':
            if start:
                if -90 <= angle <= 90:
                    return ('left', 'center')
                else:
                    return ('right', 'center')
            elif -90 <= angle <= 90:
                return ('right', 'center')
            else:
                return ('left', 'center')
        elif start:
            if angle < -68.5:
                return ('center', 'top')
            elif angle < -23.5:
                return ('left', 'top')
            elif angle < 22.5:
                return ('left', 'center')
            elif angle < 67.5:
                return ('left', 'bottom')
            elif angle < 112.5:
                return ('center', 'bottom')
            elif angle < 157.5:
                return ('right', 'bottom')
            elif angle < 202.5:
                return ('right', 'center')
            elif angle < 247.5:
                return ('right', 'top')
            else:
                return ('center', 'top')
        elif angle < -68.5:
            return ('center', 'bottom')
        elif angle < -23.5:
            return ('right', 'bottom')
        elif angle < 22.5:
            return ('right', 'center')
        elif angle < 67.5:
            return ('right', 'top')
        elif angle < 112.5:
            return ('center', 'top')
        elif angle < 157.5:
            return ('left', 'top')
        elif angle < 202.5:
            return ('left', 'center')
        elif angle < 247.5:
            return ('left', 'bottom')
        else:
            return ('center', 'bottom')

    def update_position(self, loc):
        super().update_position(loc)
        axes = self.axes
        thetamin = axes.get_thetamin()
        thetamax = axes.get_thetamax()
        direction = axes.get_theta_direction()
        offset_rad = axes.get_theta_offset()
        offset = np.rad2deg(offset_rad)
        full = _is_full_circle_deg(thetamin, thetamax)
        if full:
            angle = (axes.get_rlabel_position() * direction + offset) % 360 - 90
            tick_angle = 0
        else:
            angle = (thetamin * direction + offset) % 360 - 90
            if direction > 0:
                tick_angle = np.deg2rad(angle)
            else:
                tick_angle = np.deg2rad(angle + 180)
        text_angle = (angle + 90) % 180 - 90
        (mode, user_angle) = self._labelrotation
        if mode == 'auto':
            text_angle += user_angle
        else:
            text_angle = user_angle
        if full:
            ha = self.label1.get_horizontalalignment()
            va = self.label1.get_verticalalignment()
        else:
            (ha, va) = self._determine_anchor(mode, angle, direction > 0)
        self.label1.set_horizontalalignment(ha)
        self.label1.set_verticalalignment(va)
        self.label1.set_rotation(text_angle)
        marker = self.tick1line.get_marker()
        if marker == mmarkers.TICKLEFT:
            trans = mtransforms.Affine2D().rotate(tick_angle)
        elif marker == '_':
            trans = mtransforms.Affine2D().rotate(tick_angle + np.pi / 2)
        elif marker == mmarkers.TICKRIGHT:
            trans = mtransforms.Affine2D().scale(-1, 1).rotate(tick_angle)
        else:
            trans = self.tick1line._marker._transform
        self.tick1line._marker._transform = trans
        if full:
            self.label2.set_visible(False)
            self.tick2line.set_visible(False)
        angle = (thetamax * direction + offset) % 360 - 90
        if direction > 0:
            tick_angle = np.deg2rad(angle)
        else:
            tick_angle = np.deg2rad(angle + 180)
        text_angle = (angle + 90) % 180 - 90
        (mode, user_angle) = self._labelrotation
        if mode == 'auto':
            text_angle += user_angle
        else:
            text_angle = user_angle
        (ha, va) = self._determine_anchor(mode, angle, direction < 0)
        self.label2.set_ha(ha)
        self.label2.set_va(va)
        self.label2.set_rotation(text_angle)
        marker = self.tick2line.get_marker()
        if marker == mmarkers.TICKLEFT:
            trans = mtransforms.Affine2D().rotate(tick_angle)
        elif marker == '_':
            trans = mtransforms.Affine2D().rotate(tick_angle + np.pi / 2)
        elif marker == mmarkers.TICKRIGHT:
            trans = mtransforms.Affine2D().scale(-1, 1).rotate(tick_angle)
        else:
            trans = self.tick2line._marker._transform
        self.tick2line._marker._transform = trans

class RadialAxis(maxis.YAxis):
    __name__ = 'radialaxis'
    axis_name = 'radius'
    _tick_class = RadialTick

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.sticky_edges.y.append(0)

    def _wrap_locator_formatter(self):
        self.set_major_locator(RadialLocator(self.get_major_locator(), self.axes))
        self.isDefault_majloc = True

    def clear(self):
        super().clear()
        self.set_ticks_position('none')
        self._wrap_locator_formatter()

    def _set_scale(self, value, **kwargs):
        super()._set_scale(value, **kwargs)
        self._wrap_locator_formatter()

def _is_full_circle_deg(thetamin, thetamax):
    return abs(abs(thetamax - thetamin) - 360.0) < 1e-12

def _is_full_circle_rad(thetamin, thetamax):
    return abs(abs(thetamax - thetamin) - 2 * np.pi) < 1.74e-14

class _WedgeBbox(mtransforms.Bbox):

    def __init__(self, center, viewLim, originLim, **kwargs):
        super().__init__([[0, 0], [1, 1]], **kwargs)
        self._center = center
        self._viewLim = viewLim
        self._originLim = originLim
        self.set_children(viewLim, originLim)
    __str__ = mtransforms._make_str_method('_center', '_viewLim', '_originLim')

    def get_points(self):
        if self._invalid:
            points = self._viewLim.get_points().copy()
            points[:, 0] *= 180 / np.pi
            if points[0, 0] > points[1, 0]:
                points[:, 0] = points[::-1, 0]
            points[:, 1] -= self._originLim.y0
            rscale = 0.5 / points[1, 1]
            points[:, 1] *= rscale
            width = min(points[1, 1] - points[0, 1], 0.5)
            wedge = mpatches.Wedge(self._center, points[1, 1], points[0, 0], points[1, 0], width=width)
            self.update_from_path(wedge.get_path())
            (w, h) = self._points[1] - self._points[0]
            deltah = max(w - h, 0) / 2
            deltaw = max(h - w, 0) / 2
            self._points += np.array([[-deltaw, -deltah], [deltaw, deltah]])
            self._invalid = 0
        return self._points

class PolarAxes(Axes):
    name = 'polar'

    def __init__(self, *args, theta_offset=0, theta_direction=1, rlabel_position=22.5, **kwargs):
        self._default_theta_offset = theta_offset
        self._default_theta_direction = theta_direction
        self._default_rlabel_position = np.deg2rad(rlabel_position)
        super().__init__(*args, **kwargs)
        self.use_sticky_edges = True
        self.set_aspect('equal', adjustable='box', anchor='C')
        self.clear()

    def clear(self):
        super().clear()
        self.title.set_y(1.05)
        start = self.spines.get('start', None)
        if start:
            start.set_visible(False)
        end = self.spines.get('end', None)
        if end:
            end.set_visible(False)
        self.set_xlim(0.0, 2 * np.pi)
        self.grid(mpl.rcParams['polaraxes.grid'])
        inner = self.spines.get('inner', None)
        if inner:
            inner.set_visible(False)
        self.set_rorigin(None)
        self.set_theta_offset(self._default_theta_offset)
        self.set_theta_direction(self._default_theta_direction)

    def _init_axis(self):
        self.xaxis = ThetaAxis(self, clear=False)
        self.yaxis = RadialAxis(self, clear=False)
        self.spines['polar'].register_axis(self.yaxis)

    def _set_lim_and_transforms(self):
        self._originViewLim = mtransforms.LockableBbox(self.viewLim)
        self._direction = mtransforms.Affine2D().scale(self._default_theta_direction, 1.0)
        self._theta_offset = mtransforms.Affine2D().translate(self._default_theta_offset, 0.0)
        self.transShift = self._direction + self._theta_offset
        self._realViewLim = mtransforms.TransformedBbox(self.viewLim, self.transShift)
        self.transScale = mtransforms.TransformWrapper(mtransforms.IdentityTransform())
        self.axesLim = _WedgeBbox((0.5, 0.5), self._realViewLim, self._originViewLim)
        self.transWedge = mtransforms.BboxTransformFrom(self.axesLim)
        self.transAxes = mtransforms.BboxTransformTo(self.bbox)
        self.transProjection = self.PolarTransform(self, apply_theta_transforms=False, scale_transform=self.transScale)
        self.transProjection.set_children(self._originViewLim)
        self.transProjectionAffine = self.PolarAffine(self.transScale, self._originViewLim)
        self.transData = self.transScale + self.transShift + self.transProjection + (self.transProjectionAffine + self.transWedge + self.transAxes)
        self._xaxis_transform = mtransforms.blended_transform_factory(mtransforms.IdentityTransform(), mtransforms.BboxTransformTo(self.viewLim)) + self.transData
        flipr_transform = mtransforms.Affine2D().translate(0.0, -0.5).scale(1.0, -1.0).translate(0.0, 0.5)
        self._xaxis_text_transform = flipr_transform + self._xaxis_transform
        self._yaxis_transform = mtransforms.blended_transform_factory(mtransforms.BboxTransformTo(self.viewLim), mtransforms.IdentityTransform()) + self.transData
        self._r_label_position = mtransforms.Affine2D().translate(self._default_rlabel_position, 0.0)
        self._yaxis_text_transform = mtransforms.TransformWrapper(self._r_label_position + self.transData)

    def get_xaxis_transform(self, which='grid'):
        _api.check_in_list(['tick1', 'tick2', 'grid'], which=which)
        return self._xaxis_transform

    def get_xaxis_text1_transform(self, pad):
        return (self._xaxis_text_transform, 'center', 'center')

    def get_xaxis_text2_transform(self, pad):
        return (self._xaxis_text_transform, 'center', 'center')

    def get_yaxis_transform(self, which='grid'):
        if which in ('tick1', 'tick2'):
            return self._yaxis_text_transform
        elif which == 'grid':
            return self._yaxis_transform
        else:
            _api.check_in_list(['tick1', 'tick2', 'grid'], which=which)

    def get_yaxis_text1_transform(self, pad):
        (thetamin, thetamax) = self._realViewLim.intervalx
        if _is_full_circle_rad(thetamin, thetamax):
            return (self._yaxis_text_transform, 'bottom', 'left')
        elif self.get_theta_direction() > 0:
            halign = 'left'
            pad_shift = _ThetaShift(self, pad, 'min')
        else:
            halign = 'right'
            pad_shift = _ThetaShift(self, pad, 'max')
        return (self._yaxis_text_transform + pad_shift, 'center', halign)

    def get_yaxis_text2_transform(self, pad):
        if self.get_theta_direction() > 0:
            halign = 'right'
            pad_shift = _ThetaShift(self, pad, 'max')
        else:
            halign = 'left'
            pad_shift = _ThetaShift(self, pad, 'min')
        return (self._yaxis_text_transform + pad_shift, 'center', halign)

    def draw(self, renderer):
        self._unstale_viewLim()
        (thetamin, thetamax) = np.rad2deg(self._realViewLim.intervalx)
        if thetamin > thetamax:
            (thetamin, thetamax) = (thetamax, thetamin)
        (rmin, rmax) = (self._realViewLim.intervaly - self.get_rorigin()) * self.get_rsign()
        if isinstance(self.patch, mpatches.Wedge):
            center = self.transWedge.transform((0.5, 0.5))
            self.patch.set_center(center)
            self.patch.set_theta1(thetamin)
            self.patch.set_theta2(thetamax)
            (edge, _) = self.transWedge.transform((1, 0))
            radius = edge - center[0]
            width = min(radius * (rmax - rmin) / rmax, radius)
            self.patch.set_radius(radius)
            self.patch.set_width(width)
            inner_width = radius - width
            inner = self.spines.get('inner', None)
            if inner:
                inner.set_visible(inner_width != 0.0)
        visible = not _is_full_circle_deg(thetamin, thetamax)
        start = self.spines.get('start', None)
        end = self.spines.get('end', None)
        if start:
            start.set_visible(visible)
        if end:
            end.set_visible(visible)
        if visible:
            yaxis_text_transform = self._yaxis_transform
        else:
            yaxis_text_transform = self._r_label_position + self.transData
        if self._yaxis_text_transform != yaxis_text_transform:
            self._yaxis_text_transform.set(yaxis_text_transform)
            self.yaxis.reset_ticks()
            self.yaxis.set_clip_path(self.patch)
        super().draw(renderer)

    def _gen_axes_patch(self):
        return mpatches.Wedge((0.5, 0.5), 0.5, 0.0, 360.0)

    def _gen_axes_spines(self):
        spines = {'polar': Spine.arc_spine(self, 'top', (0.5, 0.5), 0.5, 0, 360), 'start': Spine.linear_spine(self, 'left'), 'end': Spine.linear_spine(self, 'right'), 'inner': Spine.arc_spine(self, 'bottom', (0.5, 0.5), 0.0, 0, 360)}
        spines['polar'].set_transform(self.transWedge + self.transAxes)
        spines['inner'].set_transform(self.transWedge + self.transAxes)
        spines['start'].set_transform(self._yaxis_transform)
        spines['end'].set_transform(self._yaxis_transform)
        return spines

    def set_thetamax(self, thetamax):
        self.viewLim.x1 = np.deg2rad(thetamax)

    def get_thetamax(self):
        return np.rad2deg(self.viewLim.xmax)

    def set_thetamin(self, thetamin):
        self.viewLim.x0 = np.deg2rad(thetamin)

    def get_thetamin(self):
        return np.rad2deg(self.viewLim.xmin)

    def set_thetalim(self, *args, **kwargs):
        orig_lim = self.get_xlim()
        if 'thetamin' in kwargs:
            kwargs['xmin'] = np.deg2rad(kwargs.pop('thetamin'))
        if 'thetamax' in kwargs:
            kwargs['xmax'] = np.deg2rad(kwargs.pop('thetamax'))
        (new_min, new_max) = self.set_xlim(*args, **kwargs)
        if abs(new_max - new_min) > 2 * np.pi:
            self.set_xlim(orig_lim)
            raise ValueError('The angle range must be less than a full circle')
        return tuple(np.rad2deg((new_min, new_max)))

    def set_theta_offset(self, offset):
        mtx = self._theta_offset.get_matrix()
        mtx[0, 2] = offset
        self._theta_offset.invalidate()

    def get_theta_offset(self):
        return self._theta_offset.get_matrix()[0, 2]

    def set_theta_zero_location(self, loc, offset=0.0):
        mapping = {'N': np.pi * 0.5, 'NW': np.pi * 0.75, 'W': np.pi, 'SW': np.pi * 1.25, 'S': np.pi * 1.5, 'SE': np.pi * 1.75, 'E': 0, 'NE': np.pi * 0.25}
        return self.set_theta_offset(mapping[loc] + np.deg2rad(offset))

    def set_theta_direction(self, direction):
        mtx = self._direction.get_matrix()
        if direction in ('clockwise', -1):
            mtx[0, 0] = -1
        elif direction in ('counterclockwise', 'anticlockwise', 1):
            mtx[0, 0] = 1
        else:
            _api.check_in_list([-1, 1, 'clockwise', 'counterclockwise', 'anticlockwise'], direction=direction)
        self._direction.invalidate()

    def get_theta_direction(self):
        return self._direction.get_matrix()[0, 0]

    def set_rmax(self, rmax):
        self.viewLim.y1 = rmax

    def get_rmax(self):
        return self.viewLim.ymax

    def set_rmin(self, rmin):
        self.viewLim.y0 = rmin

    def get_rmin(self):
        return self.viewLim.ymin

    def set_rorigin(self, rorigin):
        self._originViewLim.locked_y0 = rorigin

    def get_rorigin(self):
        return self._originViewLim.y0

    def get_rsign(self):
        return np.sign(self._originViewLim.y1 - self._originViewLim.y0)

    def set_rlim(self, bottom=None, top=None, *, emit=True, auto=False, **kwargs):
        if 'rmin' in kwargs:
            if bottom is None:
                bottom = kwargs.pop('rmin')
            else:
                raise ValueError('Cannot supply both positional "bottom"argument and kwarg "rmin"')
        if 'rmax' in kwargs:
            if top is None:
                top = kwargs.pop('rmax')
            else:
                raise ValueError('Cannot supply both positional "top"argument and kwarg "rmax"')
        return self.set_ylim(bottom=bottom, top=top, emit=emit, auto=auto, **kwargs)

    def get_rlabel_position(self):
        return np.rad2deg(self._r_label_position.get_matrix()[0, 2])

    def set_rlabel_position(self, value):
        self._r_label_position.clear().translate(np.deg2rad(value), 0.0)

    def set_yscale(self, *args, **kwargs):
        super().set_yscale(*args, **kwargs)
        self.yaxis.set_major_locator(self.RadialLocator(self.yaxis.get_major_locator(), self))

    def set_rscale(self, *args, **kwargs):
        return Axes.set_yscale(self, *args, **kwargs)

    def set_rticks(self, *args, **kwargs):
        return Axes.set_yticks(self, *args, **kwargs)

    def set_thetagrids(self, angles, labels=None, fmt=None, **kwargs):
        angles = self.convert_yunits(angles)
        angles = np.deg2rad(angles)
        self.set_xticks(angles)
        if labels is not None:
            self.set_xticklabels(labels)
        elif fmt is not None:
            self.xaxis.set_major_formatter(mticker.FormatStrFormatter(fmt))
        for t in self.xaxis.get_ticklabels():
            t._internal_update(kwargs)
        return (self.xaxis.get_ticklines(), self.xaxis.get_ticklabels())

    def set_rgrids(self, radii, labels=None, angle=None, fmt=None, **kwargs):
        radii = self.convert_xunits(radii)
        radii = np.asarray(radii)
        self.set_yticks(radii)
        if labels is not None:
            self.set_yticklabels(labels)
        elif fmt is not None:
            self.yaxis.set_major_formatter(mticker.FormatStrFormatter(fmt))
        if angle is None:
            angle = self.get_rlabel_position()
        self.set_rlabel_position(angle)
        for t in self.yaxis.get_ticklabels():
            t._internal_update(kwargs)
        return (self.yaxis.get_gridlines(), self.yaxis.get_ticklabels())

    def format_coord(self, theta, r):
        screen_xy = self.transData.transform((theta, r))
        screen_xys = screen_xy + np.stack(np.meshgrid([-1, 0, 1], [-1, 0, 1])).reshape((2, -1)).T
        (ts, rs) = self.transData.inverted().transform(screen_xys).T
        delta_t = abs((ts - theta + np.pi) % (2 * np.pi) - np.pi).max()
        delta_t_halfturns = delta_t / np.pi
        delta_t_degrees = delta_t_halfturns * 180
        delta_r = abs(rs - r).max()
        if theta < 0:
            theta += 2 * np.pi
        theta_halfturns = theta / np.pi
        theta_degrees = theta_halfturns * 180

        def format_sig(value, delta, opt, fmt):
            prec = max(0, -math.floor(math.log10(delta))) if fmt == 'f' else cbook._g_sig_digits(value, delta)
            return f'{value:-{opt}.{prec}{fmt}}'
        if self.fmt_ydata is None:
            r_label = format_sig(r, delta_r, '#', 'g')
        else:
            r_label = self.format_ydata(r)
        if self.fmt_xdata is None:
            return 'θ={}π ({}°), r={}'.format(format_sig(theta_halfturns, delta_t_halfturns, '', 'f'), format_sig(theta_degrees, delta_t_degrees, '', 'f'), r_label)
        else:
            return 'θ={}, r={}'.format(self.format_xdata(theta), r_label)

    def get_data_ratio(self):
        return 1.0

    def can_zoom(self):
        return False

    def can_pan(self):
        return True

    def start_pan(self, x, y, button):
        angle = np.deg2rad(self.get_rlabel_position())
        mode = ''
        if button == 1:
            epsilon = np.pi / 45.0
            (t, r) = self.transData.inverted().transform((x, y))
            if angle - epsilon <= t <= angle + epsilon:
                mode = 'drag_r_labels'
        elif button == 3:
            mode = 'zoom'
        self._pan_start = types.SimpleNamespace(rmax=self.get_rmax(), trans=self.transData.frozen(), trans_inverse=self.transData.inverted().frozen(), r_label_angle=self.get_rlabel_position(), x=x, y=y, mode=mode)

    def end_pan(self):
        del self._pan_start

    def drag_pan(self, button, key, x, y):
        p = self._pan_start
        if p.mode == 'drag_r_labels':
            ((startt, startr), (t, r)) = p.trans_inverse.transform([(p.x, p.y), (x, y)])
            dt = np.rad2deg(startt - t)
            self.set_rlabel_position(p.r_label_angle - dt)
            (trans, vert1, horiz1) = self.get_yaxis_text1_transform(0.0)
            (trans, vert2, horiz2) = self.get_yaxis_text2_transform(0.0)
            for t in self.yaxis.majorTicks + self.yaxis.minorTicks:
                t.label1.set_va(vert1)
                t.label1.set_ha(horiz1)
                t.label2.set_va(vert2)
                t.label2.set_ha(horiz2)
        elif p.mode == 'zoom':
            ((startt, startr), (t, r)) = p.trans_inverse.transform([(p.x, p.y), (x, y)])
            scale = r / startr
            self.set_rmax(p.rmax / scale)
PolarAxes.PolarTransform = PolarTransform
PolarAxes.PolarAffine = PolarAffine
PolarAxes.InvertedPolarTransform = InvertedPolarTransform
PolarAxes.ThetaFormatter = ThetaFormatter
PolarAxes.RadialLocator = RadialLocator
PolarAxes.ThetaLocator = ThetaLocator

# File: matplotlib-main/lib/matplotlib/pylab.py
""""""
from matplotlib.cbook import flatten, silent_list
import matplotlib as mpl
from matplotlib.dates import date2num, num2date, datestr2num, drange, DateFormatter, DateLocator, RRuleLocator, YearLocator, MonthLocator, WeekdayLocator, DayLocator, HourLocator, MinuteLocator, SecondLocator, rrule, MO, TU, WE, TH, FR, SA, SU, YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY, relativedelta
from matplotlib.mlab import detrend, detrend_linear, detrend_mean, detrend_none, window_hanning, window_none
from matplotlib import cbook, mlab, pyplot as plt
from matplotlib.pyplot import *
from numpy import *
from numpy.fft import *
from numpy.random import *
from numpy.linalg import *
import numpy as np
import numpy.ma as ma
import datetime
bytes = __import__('builtins').bytes
abs = __import__('builtins').abs
bool = __import__('builtins').bool
max = __import__('builtins').max
min = __import__('builtins').min
pow = __import__('builtins').pow
round = __import__('builtins').round

# File: matplotlib-main/lib/matplotlib/pyplot.py
""""""
from __future__ import annotations
from contextlib import AbstractContextManager, ExitStack
from enum import Enum
import functools
import importlib
import inspect
import logging
import sys
import threading
import time
from typing import TYPE_CHECKING, cast, overload
from cycler import cycler
import matplotlib
import matplotlib.colorbar
import matplotlib.image
from matplotlib import _api
from matplotlib import cm as cm, get_backend as get_backend, rcParams as rcParams
from matplotlib import style as style
from matplotlib import _pylab_helpers
from matplotlib import interactive
from matplotlib import cbook
from matplotlib import _docstring
from matplotlib.backend_bases import FigureCanvasBase, FigureManagerBase, MouseButton
from matplotlib.figure import Figure, FigureBase, figaspect
from matplotlib.gridspec import GridSpec, SubplotSpec
from matplotlib import rcsetup, rcParamsDefault, rcParamsOrig
from matplotlib.artist import Artist
from matplotlib.axes import Axes
from matplotlib.axes import Subplot
from matplotlib.backends import BackendFilter, backend_registry
from matplotlib.projections import PolarAxes
from matplotlib import mlab
from matplotlib.scale import get_scale_names
from matplotlib.cm import _colormaps
from matplotlib.colors import _color_sequences, Colormap
import numpy as np
if TYPE_CHECKING:
    from collections.abc import Callable, Hashable, Iterable, Sequence
    import datetime
    import pathlib
    import os
    from typing import Any, BinaryIO, Literal, TypeVar
    from typing_extensions import ParamSpec
    import PIL.Image
    from numpy.typing import ArrayLike
    import matplotlib.axes
    import matplotlib.artist
    import matplotlib.backend_bases
    from matplotlib.axis import Tick
    from matplotlib.axes._base import _AxesBase
    from matplotlib.backend_bases import RendererBase, Event
    from matplotlib.cm import ScalarMappable
    from matplotlib.contour import ContourSet, QuadContourSet
    from matplotlib.collections import Collection, LineCollection, PolyCollection, PathCollection, EventCollection, QuadMesh
    from matplotlib.colorbar import Colorbar
    from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer
    from matplotlib.figure import SubFigure
    from matplotlib.legend import Legend
    from matplotlib.mlab import GaussianKDE
    from matplotlib.image import AxesImage, FigureImage
    from matplotlib.patches import FancyArrow, StepPatch, Wedge
    from matplotlib.quiver import Barbs, Quiver, QuiverKey
    from matplotlib.scale import ScaleBase
    from matplotlib.transforms import Transform, Bbox
    from matplotlib.typing import ColorType, LineStyleType, MarkerType, HashableList
    from matplotlib.widgets import SubplotTool
    _P = ParamSpec('_P')
    _R = TypeVar('_R')
    _T = TypeVar('_T')
from matplotlib.colors import Normalize
from matplotlib.lines import Line2D, AxLine
from matplotlib.text import Text, Annotation
from matplotlib.patches import Arrow, Circle, Rectangle
from matplotlib.patches import Polygon
from matplotlib.widgets import Button, Slider, Widget
from .ticker import TickHelper, Formatter, FixedFormatter, NullFormatter, FuncFormatter, FormatStrFormatter, ScalarFormatter, LogFormatter, LogFormatterExponent, LogFormatterMathtext, Locator, IndexLocator, FixedLocator, NullLocator, LinearLocator, LogLocator, AutoLocator, MultipleLocator, MaxNLocator
_log = logging.getLogger(__name__)
colormaps = _colormaps
color_sequences = _color_sequences

@overload
def _copy_docstring_and_deprecators(method: Any, func: Literal[None]=None) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
    ...

@overload
def _copy_docstring_and_deprecators(method: Any, func: Callable[_P, _R]) -> Callable[_P, _R]:
    ...

def _copy_docstring_and_deprecators(method: Any, func: Callable[_P, _R] | None=None) -> Callable[[Callable[_P, _R]], Callable[_P, _R]] | Callable[_P, _R]:
    if func is None:
        return cast('Callable[[Callable[_P, _R]], Callable[_P, _R]]', functools.partial(_copy_docstring_and_deprecators, method))
    decorators: list[Callable[[Callable[_P, _R]], Callable[_P, _R]]] = [_docstring.copy(method)]
    while hasattr(method, '__wrapped__'):
        potential_decorator = _api.deprecation.DECORATORS.get(method)
        if potential_decorator:
            decorators.append(potential_decorator)
        method = method.__wrapped__
    for decorator in decorators[::-1]:
        func = decorator(func)
    _add_pyplot_note(func, method)
    return func
_NO_PYPLOT_NOTE = ['FigureBase._gci', '_AxesBase._sci', 'Artist.findobj']

def _add_pyplot_note(func, wrapped_func):
    if not func.__doc__:
        return
    qualname = wrapped_func.__qualname__
    if qualname in _NO_PYPLOT_NOTE:
        return
    wrapped_func_is_method = True
    if '.' not in qualname:
        wrapped_func_is_method = False
        link = f'{wrapped_func.__module__}.{qualname}'
    elif qualname.startswith('Axes.'):
        link = '.axes.' + qualname
    elif qualname.startswith('_AxesBase.'):
        link = '.axes.Axes' + qualname[9:]
    elif qualname.startswith('Figure.'):
        link = '.' + qualname
    elif qualname.startswith('FigureBase.'):
        link = '.Figure' + qualname[10:]
    elif qualname.startswith('FigureCanvasBase.'):
        link = '.' + qualname
    else:
        raise RuntimeError(f'Wrapped method from unexpected class: {qualname}')
    if wrapped_func_is_method:
        message = f'This is the :ref:`pyplot wrapper <pyplot_interface>` for `{link}`.'
    else:
        message = f'This is equivalent to `{link}`.'
    doc = inspect.cleandoc(func.__doc__)
    if '\nNotes\n-----' in doc:
        (before, after) = doc.split('\nNotes\n-----', 1)
    elif (index := doc.find('\nReferences\n----------')) != -1:
        (before, after) = (doc[:index], doc[index:])
    elif (index := doc.find('\nExamples\n--------')) != -1:
        (before, after) = (doc[:index], doc[index:])
    else:
        before = doc + '\n'
        after = ''
    func.__doc__ = f'{before}\nNotes\n-----\n\n.. note::\n\n    {message}\n{after}'
_ReplDisplayHook = Enum('_ReplDisplayHook', ['NONE', 'PLAIN', 'IPYTHON'])
_REPL_DISPLAYHOOK = _ReplDisplayHook.NONE

def _draw_all_if_interactive() -> None:
    if matplotlib.is_interactive():
        draw_all()

def install_repl_displayhook() -> None:
    global _REPL_DISPLAYHOOK
    if _REPL_DISPLAYHOOK is _ReplDisplayHook.IPYTHON:
        return
    mod_ipython = sys.modules.get('IPython')
    if not mod_ipython:
        _REPL_DISPLAYHOOK = _ReplDisplayHook.PLAIN
        return
    ip = mod_ipython.get_ipython()
    if not ip:
        _REPL_DISPLAYHOOK = _ReplDisplayHook.PLAIN
        return
    ip.events.register('post_execute', _draw_all_if_interactive)
    _REPL_DISPLAYHOOK = _ReplDisplayHook.IPYTHON
    if mod_ipython.version_info[:2] < (8, 24):
        from IPython.core.pylabtools import backend2gui
        ipython_gui_name = backend2gui.get(get_backend())
    else:
        (_, ipython_gui_name) = backend_registry.resolve_backend(get_backend())
    if ipython_gui_name:
        ip.enable_gui(ipython_gui_name)

def uninstall_repl_displayhook() -> None:
    global _REPL_DISPLAYHOOK
    if _REPL_DISPLAYHOOK is _ReplDisplayHook.IPYTHON:
        from IPython import get_ipython
        ip = get_ipython()
        ip.events.unregister('post_execute', _draw_all_if_interactive)
    _REPL_DISPLAYHOOK = _ReplDisplayHook.NONE
draw_all = _pylab_helpers.Gcf.draw_all

@_copy_docstring_and_deprecators(matplotlib.set_loglevel)
def set_loglevel(*args, **kwargs) -> None:
    return matplotlib.set_loglevel(*args, **kwargs)

@_copy_docstring_and_deprecators(Artist.findobj)
def findobj(o: Artist | None=None, match: Callable[[Artist], bool] | type[Artist] | None=None, include_self: bool=True) -> list[Artist]:
    if o is None:
        o = gcf()
    return o.findobj(match, include_self=include_self)
_backend_mod: type[matplotlib.backend_bases._Backend] | None = None

def _get_backend_mod() -> type[matplotlib.backend_bases._Backend]:
    if _backend_mod is None:
        switch_backend(rcParams._get('backend'))
    return cast(type[matplotlib.backend_bases._Backend], _backend_mod)

def switch_backend(newbackend: str) -> None:
    global _backend_mod
    import matplotlib.backends
    if newbackend is rcsetup._auto_backend_sentinel:
        current_framework = cbook._get_running_interactive_framework()
        if current_framework and (backend := backend_registry.backend_for_gui_framework(current_framework)):
            candidates = [backend]
        else:
            candidates = []
        candidates += ['macosx', 'qtagg', 'gtk4agg', 'gtk3agg', 'tkagg', 'wxagg']
        for candidate in candidates:
            try:
                switch_backend(candidate)
            except ImportError:
                continue
            else:
                rcParamsOrig['backend'] = candidate
                return
        else:
            switch_backend('agg')
            rcParamsOrig['backend'] = 'agg'
            return
    old_backend = rcParams._get('backend')
    module = backend_registry.load_backend_module(newbackend)
    canvas_class = module.FigureCanvas
    required_framework = canvas_class.required_interactive_framework
    if required_framework is not None:
        current_framework = cbook._get_running_interactive_framework()
        if current_framework and required_framework and (current_framework != required_framework):
            raise ImportError('Cannot load backend {!r} which requires the {!r} interactive framework, as {!r} is currently running'.format(newbackend, required_framework, current_framework))
    new_figure_manager = getattr(module, 'new_figure_manager', None)
    show = getattr(module, 'show', None)

    class backend_mod(matplotlib.backend_bases._Backend):
        locals().update(vars(module))
    if new_figure_manager is None:

        def new_figure_manager_given_figure(num, figure):
            return canvas_class.new_manager(figure, num)

        def new_figure_manager(num, *args, FigureClass=Figure, **kwargs):
            fig = FigureClass(*args, **kwargs)
            return new_figure_manager_given_figure(num, fig)

        def draw_if_interactive() -> None:
            if matplotlib.is_interactive():
                manager = _pylab_helpers.Gcf.get_active()
                if manager:
                    manager.canvas.draw_idle()
        backend_mod.new_figure_manager_given_figure = new_figure_manager_given_figure
        backend_mod.new_figure_manager = new_figure_manager
        backend_mod.draw_if_interactive = draw_if_interactive
    manager_class = getattr(canvas_class, 'manager_class', None)
    manager_pyplot_show = inspect.getattr_static(manager_class, 'pyplot_show', None)
    base_pyplot_show = inspect.getattr_static(FigureManagerBase, 'pyplot_show', None)
    if show is None or (manager_pyplot_show is not None and manager_pyplot_show != base_pyplot_show):
        if not manager_pyplot_show:
            raise ValueError(f'Backend {newbackend} defines neither FigureCanvas.manager_class nor a toplevel show function')
        _pyplot_show = cast('Any', manager_class).pyplot_show
        backend_mod.show = _pyplot_show
    _log.debug('Loaded backend %s version %s.', newbackend, backend_mod.backend_version)
    if newbackend in ('ipympl', 'widget'):
        import importlib.metadata as im
        from matplotlib import _parse_to_version_info
        try:
            module_version = im.version('ipympl')
            if _parse_to_version_info(module_version) < (0, 9, 4):
                newbackend = 'module://ipympl.backend_nbagg'
        except im.PackageNotFoundError:
            pass
    rcParams['backend'] = rcParamsDefault['backend'] = newbackend
    _backend_mod = backend_mod
    for func_name in ['new_figure_manager', 'draw_if_interactive', 'show']:
        globals()[func_name].__signature__ = inspect.signature(getattr(backend_mod, func_name))
    matplotlib.backends.backend = newbackend
    if not cbook._str_equal(old_backend, newbackend):
        if get_fignums():
            _api.warn_deprecated('3.8', message="Auto-close()ing of figures upon backend switching is deprecated since %(since)s and will be removed %(removal)s.  To suppress this warning, explicitly call plt.close('all') first.")
        close('all')
    install_repl_displayhook()

def _warn_if_gui_out_of_main_thread() -> None:
    warn = False
    canvas_class = cast(type[FigureCanvasBase], _get_backend_mod().FigureCanvas)
    if canvas_class.required_interactive_framework:
        if hasattr(threading, 'get_native_id'):
            if threading.get_native_id() != threading.main_thread().native_id:
                warn = True
        elif threading.current_thread() is not threading.main_thread():
            warn = True
    if warn:
        _api.warn_external('Starting a Matplotlib GUI outside of the main thread will likely fail.')

def new_figure_manager(*args, **kwargs):
    _warn_if_gui_out_of_main_thread()
    return _get_backend_mod().new_figure_manager(*args, **kwargs)

def draw_if_interactive(*args, **kwargs):
    return _get_backend_mod().draw_if_interactive(*args, **kwargs)

def show(*args, **kwargs) -> None:
    _warn_if_gui_out_of_main_thread()
    return _get_backend_mod().show(*args, **kwargs)

def isinteractive() -> bool:
    return matplotlib.is_interactive()

def ioff() -> AbstractContextManager:
    stack = ExitStack()
    stack.callback(ion if isinteractive() else ioff)
    matplotlib.interactive(False)
    uninstall_repl_displayhook()
    return stack

def ion() -> AbstractContextManager:
    stack = ExitStack()
    stack.callback(ion if isinteractive() else ioff)
    matplotlib.interactive(True)
    install_repl_displayhook()
    return stack

def pause(interval: float) -> None:
    manager = _pylab_helpers.Gcf.get_active()
    if manager is not None:
        canvas = manager.canvas
        if canvas.figure.stale:
            canvas.draw_idle()
        show(block=False)
        canvas.start_event_loop(interval)
    else:
        time.sleep(interval)

@_copy_docstring_and_deprecators(matplotlib.rc)
def rc(group: str, **kwargs) -> None:
    matplotlib.rc(group, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.rc_context)
def rc_context(rc: dict[str, Any] | None=None, fname: str | pathlib.Path | os.PathLike | None=None) -> AbstractContextManager[None]:
    return matplotlib.rc_context(rc, fname)

@_copy_docstring_and_deprecators(matplotlib.rcdefaults)
def rcdefaults() -> None:
    matplotlib.rcdefaults()
    if matplotlib.is_interactive():
        draw_all()

@_copy_docstring_and_deprecators(matplotlib.artist.getp)
def getp(obj, *args, **kwargs):
    return matplotlib.artist.getp(obj, *args, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.artist.get)
def get(obj, *args, **kwargs):
    return matplotlib.artist.get(obj, *args, **kwargs)

@_copy_docstring_and_deprecators(matplotlib.artist.setp)
def setp(obj, *args, **kwargs):
    return matplotlib.artist.setp(obj, *args, **kwargs)

def xkcd(scale: float=1, length: float=100, randomness: float=2) -> ExitStack:
    if rcParams['text.usetex']:
        raise RuntimeError('xkcd mode is not compatible with text.usetex = True')
    stack = ExitStack()
    stack.callback(rcParams._update_raw, rcParams.copy())
    from matplotlib import patheffects
    rcParams.update({'font.family': ['xkcd', 'xkcd Script', 'Comic Neue', 'Comic Sans MS'], 'font.size': 14.0, 'path.sketch': (scale, length, randomness), 'path.effects': [patheffects.withStroke(linewidth=4, foreground='w')], 'axes.linewidth': 1.5, 'lines.linewidth': 2.0, 'figure.facecolor': 'white', 'grid.linewidth': 0.0, 'axes.grid': False, 'axes.unicode_minus': False, 'axes.edgecolor': 'black', 'xtick.major.size': 8, 'xtick.major.width': 3, 'ytick.major.size': 8, 'ytick.major.width': 3})
    return stack

def figure(num: int | str | Figure | SubFigure | None=None, figsize: tuple[float, float] | None=None, dpi: float | None=None, *, facecolor: ColorType | None=None, edgecolor: ColorType | None=None, frameon: bool=True, FigureClass: type[Figure]=Figure, clear: bool=False, **kwargs) -> Figure:
    allnums = get_fignums()
    if isinstance(num, FigureBase):
        root_fig = num.get_figure(root=True)
        if root_fig.canvas.manager is None:
            raise ValueError('The passed figure is not managed by pyplot')
        elif any([figsize, dpi, facecolor, edgecolor, not frameon, kwargs]) and root_fig.canvas.manager.num in allnums:
            _api.warn_external(f'Ignoring specified arguments in this call because figure with num: {root_fig.canvas.manager.num} already exists')
        _pylab_helpers.Gcf.set_active(root_fig.canvas.manager)
        return root_fig
    next_num = max(allnums) + 1 if allnums else 1
    fig_label = ''
    if num is None:
        num = next_num
    else:
        if any([figsize, dpi, facecolor, edgecolor, not frameon, kwargs]) and num in allnums:
            _api.warn_external(f'Ignoring specified arguments in this call because figure with num: {num} already exists')
        if isinstance(num, str):
            fig_label = num
            all_labels = get_figlabels()
            if fig_label not in all_labels:
                if fig_label == 'all':
                    _api.warn_external("close('all') closes all existing figures.")
                num = next_num
            else:
                inum = all_labels.index(fig_label)
                num = allnums[inum]
        else:
            num = int(num)
    manager = _pylab_helpers.Gcf.get_fig_manager(num)
    if manager is None:
        max_open_warning = rcParams['figure.max_open_warning']
        if len(allnums) == max_open_warning >= 1:
            _api.warn_external(f'More than {max_open_warning} figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.', RuntimeWarning)
        manager = new_figure_manager(num, figsize=figsize, dpi=dpi, facecolor=facecolor, edgecolor=edgecolor, frameon=frameon, FigureClass=FigureClass, **kwargs)
        fig = manager.canvas.figure
        if fig_label:
            fig.set_label(fig_label)
        for hookspecs in rcParams['figure.hooks']:
            (module_name, dotted_name) = hookspecs.split(':')
            obj: Any = importlib.import_module(module_name)
            for part in dotted_name.split('.'):
                obj = getattr(obj, part)
            obj(fig)
        _pylab_helpers.Gcf._set_new_active_manager(manager)
        draw_if_interactive()
        if _REPL_DISPLAYHOOK is _ReplDisplayHook.PLAIN:
            fig.stale_callback = _auto_draw_if_interactive
    if clear:
        manager.canvas.figure.clear()
    return manager.canvas.figure

def _auto_draw_if_interactive(fig, val):
    if val and matplotlib.is_interactive() and (not fig.canvas.is_saving()) and (not fig.canvas._is_idle_drawing):
        with fig.canvas._idle_draw_cntx():
            fig.canvas.draw_idle()

def gcf() -> Figure:
    manager = _pylab_helpers.Gcf.get_active()
    if manager is not None:
        return manager.canvas.figure
    else:
        return figure()

def fignum_exists(num: int | str) -> bool:
    return _pylab_helpers.Gcf.has_fignum(num) if isinstance(num, int) else num in get_figlabels()

def get_fignums() -> list[int]:
    return sorted(_pylab_helpers.Gcf.figs)

def get_figlabels() -> list[Any]:
    managers = _pylab_helpers.Gcf.get_all_fig_managers()
    managers.sort(key=lambda m: m.num)
    return [m.canvas.figure.get_label() for m in managers]

def get_current_fig_manager() -> FigureManagerBase | None:
    return gcf().canvas.manager

@_copy_docstring_and_deprecators(FigureCanvasBase.mpl_connect)
def connect(s: str, func: Callable[[Event], Any]) -> int:
    return gcf().canvas.mpl_connect(s, func)

@_copy_docstring_and_deprecators(FigureCanvasBase.mpl_disconnect)
def disconnect(cid: int) -> None:
    gcf().canvas.mpl_disconnect(cid)

def close(fig: None | int | str | Figure | Literal['all']=None) -> None:
    if fig is None:
        manager = _pylab_helpers.Gcf.get_active()
        if manager is None:
            return
        else:
            _pylab_helpers.Gcf.destroy(manager)
    elif fig == 'all':
        _pylab_helpers.Gcf.destroy_all()
    elif isinstance(fig, int):
        _pylab_helpers.Gcf.destroy(fig)
    elif hasattr(fig, 'int'):
        _pylab_helpers.Gcf.destroy(fig.int)
    elif isinstance(fig, str):
        all_labels = get_figlabels()
        if fig in all_labels:
            num = get_fignums()[all_labels.index(fig)]
            _pylab_helpers.Gcf.destroy(num)
    elif isinstance(fig, Figure):
        _pylab_helpers.Gcf.destroy_fig(fig)
    else:
        raise TypeError('close() argument must be a Figure, an int, a string, or None, not %s' % type(fig))

def clf() -> None:
    gcf().clear()

def draw() -> None:
    gcf().canvas.draw_idle()

@_copy_docstring_and_deprecators(Figure.savefig)
def savefig(*args, **kwargs) -> None:
    fig = gcf()
    res = fig.savefig(*args, **kwargs)
    fig.canvas.draw_idle()
    return res

def figlegend(*args, **kwargs) -> Legend:
    return gcf().legend(*args, **kwargs)
if Figure.legend.__doc__:
    figlegend.__doc__ = Figure.legend.__doc__.replace(' legend(', ' figlegend(').replace('fig.legend(', 'plt.figlegend(').replace('ax.plot(', 'plt.plot(')

@_docstring.dedent_interpd
def axes(arg: None | tuple[float, float, float, float]=None, **kwargs) -> matplotlib.axes.Axes:
    fig = gcf()
    pos = kwargs.pop('position', None)
    if arg is None:
        if pos is None:
            return fig.add_subplot(**kwargs)
        else:
            return fig.add_axes(pos, **kwargs)
    else:
        return fig.add_axes(arg, **kwargs)

def delaxes(ax: matplotlib.axes.Axes | None=None) -> None:
    if ax is None:
        ax = gca()
    ax.remove()

def sca(ax: Axes) -> None:
    fig = ax.get_figure(root=False)
    figure(fig)
    fig.sca(ax)

def cla() -> None:
    return gca().cla()

@_docstring.dedent_interpd
def subplot(*args, **kwargs) -> Axes:
    unset = object()
    projection = kwargs.get('projection', unset)
    polar = kwargs.pop('polar', unset)
    if polar is not unset and polar:
        if projection is not unset and projection != 'polar':
            raise ValueError(f'polar={polar}, yet projection={projection!r}. Only one of these arguments should be supplied.')
        kwargs['projection'] = projection = 'polar'
    if len(args) == 0:
        args = (1, 1, 1)
    if len(args) >= 3 and isinstance(args[2], bool):
        _api.warn_external('The subplot index argument to subplot() appears to be a boolean. Did you intend to use subplots()?')
    if 'nrows' in kwargs or 'ncols' in kwargs:
        raise TypeError("subplot() got an unexpected keyword argument 'ncols' and/or 'nrows'.  Did you intend to call subplots()?")
    fig = gcf()
    key = SubplotSpec._from_subplot_args(fig, args)
    for ax in fig.axes:
        if ax.get_subplotspec() == key and (kwargs == {} or ax._projection_init == fig._process_projection_requirements(**kwargs)):
            break
    else:
        ax = fig.add_subplot(*args, **kwargs)
    fig.sca(ax)
    return ax

@overload
def subplots(nrows: Literal[1]=..., ncols: Literal[1]=..., *, sharex: bool | Literal['none', 'all', 'row', 'col']=..., sharey: bool | Literal['none', 'all', 'row', 'col']=..., squeeze: Literal[True]=..., width_ratios: Sequence[float] | None=..., height_ratios: Sequence[float] | None=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., **fig_kw) -> tuple[Figure, Axes]:
    ...

@overload
def subplots(nrows: int=..., ncols: int=..., *, sharex: bool | Literal['none', 'all', 'row', 'col']=..., sharey: bool | Literal['none', 'all', 'row', 'col']=..., squeeze: Literal[False], width_ratios: Sequence[float] | None=..., height_ratios: Sequence[float] | None=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., **fig_kw) -> tuple[Figure, np.ndarray]:
    ...

@overload
def subplots(nrows: int=..., ncols: int=..., *, sharex: bool | Literal['none', 'all', 'row', 'col']=..., sharey: bool | Literal['none', 'all', 'row', 'col']=..., squeeze: bool=..., width_ratios: Sequence[float] | None=..., height_ratios: Sequence[float] | None=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., **fig_kw) -> tuple[Figure, Any]:
    ...

def subplots(nrows: int=1, ncols: int=1, *, sharex: bool | Literal['none', 'all', 'row', 'col']=False, sharey: bool | Literal['none', 'all', 'row', 'col']=False, squeeze: bool=True, width_ratios: Sequence[float] | None=None, height_ratios: Sequence[float] | None=None, subplot_kw: dict[str, Any] | None=None, gridspec_kw: dict[str, Any] | None=None, **fig_kw) -> tuple[Figure, Any]:
    fig = figure(**fig_kw)
    axs = fig.subplots(nrows=nrows, ncols=ncols, sharex=sharex, sharey=sharey, squeeze=squeeze, subplot_kw=subplot_kw, gridspec_kw=gridspec_kw, height_ratios=height_ratios, width_ratios=width_ratios)
    return (fig, axs)

@overload
def subplot_mosaic(mosaic: str, *, sharex: bool=..., sharey: bool=..., width_ratios: ArrayLike | None=..., height_ratios: ArrayLike | None=..., empty_sentinel: str=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., per_subplot_kw: dict[str | tuple[str, ...], dict[str, Any]] | None=..., **fig_kw: Any) -> tuple[Figure, dict[str, matplotlib.axes.Axes]]:
    ...

@overload
def subplot_mosaic(mosaic: list[HashableList[_T]], *, sharex: bool=..., sharey: bool=..., width_ratios: ArrayLike | None=..., height_ratios: ArrayLike | None=..., empty_sentinel: _T=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., per_subplot_kw: dict[_T | tuple[_T, ...], dict[str, Any]] | None=..., **fig_kw: Any) -> tuple[Figure, dict[_T, matplotlib.axes.Axes]]:
    ...

@overload
def subplot_mosaic(mosaic: list[HashableList[Hashable]], *, sharex: bool=..., sharey: bool=..., width_ratios: ArrayLike | None=..., height_ratios: ArrayLike | None=..., empty_sentinel: Any=..., subplot_kw: dict[str, Any] | None=..., gridspec_kw: dict[str, Any] | None=..., per_subplot_kw: dict[Hashable | tuple[Hashable, ...], dict[str, Any]] | None=..., **fig_kw: Any) -> tuple[Figure, dict[Hashable, matplotlib.axes.Axes]]:
    ...

def subplot_mosaic(mosaic: str | list[HashableList[_T]] | list[HashableList[Hashable]], *, sharex: bool=False, sharey: bool=False, width_ratios: ArrayLike | None=None, height_ratios: ArrayLike | None=None, empty_sentinel: Any='.', subplot_kw: dict[str, Any] | None=None, gridspec_kw: dict[str, Any] | None=None, per_subplot_kw: dict[str | tuple[str, ...], dict[str, Any]] | dict[_T | tuple[_T, ...], dict[str, Any]] | dict[Hashable | tuple[Hashable, ...], dict[str, Any]] | None=None, **fig_kw: Any) -> tuple[Figure, dict[str, matplotlib.axes.Axes]] | tuple[Figure, dict[_T, matplotlib.axes.Axes]] | tuple[Figure, dict[Hashable, matplotlib.axes.Axes]]:
    fig = figure(**fig_kw)
    ax_dict = fig.subplot_mosaic(mosaic, sharex=sharex, sharey=sharey, height_ratios=height_ratios, width_ratios=width_ratios, subplot_kw=subplot_kw, gridspec_kw=gridspec_kw, empty_sentinel=empty_sentinel, per_subplot_kw=per_subplot_kw)
    return (fig, ax_dict)

def subplot2grid(shape: tuple[int, int], loc: tuple[int, int], rowspan: int=1, colspan: int=1, fig: Figure | None=None, **kwargs) -> matplotlib.axes.Axes:
    if fig is None:
        fig = gcf()
    (rows, cols) = shape
    gs = GridSpec._check_gridspec_exists(fig, rows, cols)
    subplotspec = gs.new_subplotspec(loc, rowspan=rowspan, colspan=colspan)
    return fig.add_subplot(subplotspec, **kwargs)

def twinx(ax: matplotlib.axes.Axes | None=None) -> _AxesBase:
    if ax is None:
        ax = gca()
    ax1 = ax.twinx()
    return ax1

def twiny(ax: matplotlib.axes.Axes | None=None) -> _AxesBase:
    if ax is None:
        ax = gca()
    ax1 = ax.twiny()
    return ax1

def subplot_tool(targetfig: Figure | None=None) -> SubplotTool | None:
    if targetfig is None:
        targetfig = gcf()
    tb = targetfig.canvas.manager.toolbar
    if hasattr(tb, 'configure_subplots'):
        from matplotlib.backend_bases import NavigationToolbar2
        return cast(NavigationToolbar2, tb).configure_subplots()
    elif hasattr(tb, 'trigger_tool'):
        from matplotlib.backend_bases import ToolContainerBase
        cast(ToolContainerBase, tb).trigger_tool('subplots')
        return None
    else:
        raise ValueError('subplot_tool can only be launched for figures with an associated toolbar')

def box(on: bool | None=None) -> None:
    ax = gca()
    if on is None:
        on = not ax.get_frame_on()
    ax.set_frame_on(on)

def xlim(*args, **kwargs) -> tuple[float, float]:
    ax = gca()
    if not args and (not kwargs):
        return ax.get_xlim()
    ret = ax.set_xlim(*args, **kwargs)
    return ret

def ylim(*args, **kwargs) -> tuple[float, float]:
    ax = gca()
    if not args and (not kwargs):
        return ax.get_ylim()
    ret = ax.set_ylim(*args, **kwargs)
    return ret

def xticks(ticks: ArrayLike | None=None, labels: Sequence[str] | None=None, *, minor: bool=False, **kwargs) -> tuple[list[Tick] | np.ndarray, list[Text]]:
    ax = gca()
    locs: list[Tick] | np.ndarray
    if ticks is None:
        locs = ax.get_xticks(minor=minor)
        if labels is not None:
            raise TypeError("xticks(): Parameter 'labels' can't be set without setting 'ticks'")
    else:
        locs = ax.set_xticks(ticks, minor=minor)
    labels_out: list[Text] = []
    if labels is None:
        labels_out = ax.get_xticklabels(minor=minor)
        for l in labels_out:
            l._internal_update(kwargs)
    else:
        labels_out = ax.set_xticklabels(labels, minor=minor, **kwargs)
    return (locs, labels_out)

def yticks(ticks: ArrayLike | None=None, labels: Sequence[str] | None=None, *, minor: bool=False, **kwargs) -> tuple[list[Tick] | np.ndarray, list[Text]]:
    ax = gca()
    locs: list[Tick] | np.ndarray
    if ticks is None:
        locs = ax.get_yticks(minor=minor)
        if labels is not None:
            raise TypeError("yticks(): Parameter 'labels' can't be set without setting 'ticks'")
    else:
        locs = ax.set_yticks(ticks, minor=minor)
    labels_out: list[Text] = []
    if labels is None:
        labels_out = ax.get_yticklabels(minor=minor)
        for l in labels_out:
            l._internal_update(kwargs)
    else:
        labels_out = ax.set_yticklabels(labels, minor=minor, **kwargs)
    return (locs, labels_out)

def rgrids(radii: ArrayLike | None=None, labels: Sequence[str | Text] | None=None, angle: float | None=None, fmt: str | None=None, **kwargs) -> tuple[list[Line2D], list[Text]]:
    ax = gca()
    if not isinstance(ax, PolarAxes):
        raise RuntimeError('rgrids only defined for polar Axes')
    if all((p is None for p in [radii, labels, angle, fmt])) and (not kwargs):
        lines_out: list[Line2D] = ax.yaxis.get_gridlines()
        labels_out: list[Text] = ax.yaxis.get_ticklabels()
    elif radii is None:
        raise TypeError("'radii' cannot be None when other parameters are passed")
    else:
        (lines_out, labels_out) = ax.set_rgrids(radii, labels=labels, angle=angle, fmt=fmt, **kwargs)
    return (lines_out, labels_out)

def thetagrids(angles: ArrayLike | None=None, labels: Sequence[str | Text] | None=None, fmt: str | None=None, **kwargs) -> tuple[list[Line2D], list[Text]]:
    ax = gca()
    if not isinstance(ax, PolarAxes):
        raise RuntimeError('thetagrids only defined for polar Axes')
    if all((param is None for param in [angles, labels, fmt])) and (not kwargs):
        lines_out: list[Line2D] = ax.xaxis.get_ticklines()
        labels_out: list[Text] = ax.xaxis.get_ticklabels()
    elif angles is None:
        raise TypeError("'angles' cannot be None when other parameters are passed")
    else:
        (lines_out, labels_out) = ax.set_thetagrids(angles, labels=labels, fmt=fmt, **kwargs)
    return (lines_out, labels_out)

@_api.deprecated('3.7', pending=True)
def get_plot_commands() -> list[str]:
    NON_PLOT_COMMANDS = {'connect', 'disconnect', 'get_current_fig_manager', 'ginput', 'new_figure_manager', 'waitforbuttonpress'}
    return [name for name in _get_pyplot_commands() if name not in NON_PLOT_COMMANDS]

def _get_pyplot_commands() -> list[str]:
    exclude = {'colormaps', 'colors', 'get_plot_commands', *colormaps}
    this_module = inspect.getmodule(get_plot_commands)
    return sorted((name for (name, obj) in globals().items() if not name.startswith('_') and name not in exclude and inspect.isfunction(obj) and (inspect.getmodule(obj) is this_module)))

@_copy_docstring_and_deprecators(Figure.colorbar)
def colorbar(mappable: ScalarMappable | None=None, cax: matplotlib.axes.Axes | None=None, ax: matplotlib.axes.Axes | Iterable[matplotlib.axes.Axes] | None=None, **kwargs) -> Colorbar:
    if mappable is None:
        mappable = gci()
        if mappable is None:
            raise RuntimeError('No mappable was found to use for colorbar creation. First define a mappable such as an image (with imshow) or a contour set (with contourf).')
    ret = gcf().colorbar(mappable, cax=cax, ax=ax, **kwargs)
    return ret

def clim(vmin: float | None=None, vmax: float | None=None) -> None:
    im = gci()
    if im is None:
        raise RuntimeError('You must first define an image, e.g., with imshow')
    im.set_clim(vmin, vmax)

def get_cmap(name: Colormap | str | None=None, lut: int | None=None) -> Colormap:
    if name is None:
        name = rcParams['image.cmap']
    if isinstance(name, Colormap):
        return name
    _api.check_in_list(sorted(_colormaps), name=name)
    if lut is None:
        return _colormaps[name]
    else:
        return _colormaps[name].resampled(lut)

def set_cmap(cmap: Colormap | str) -> None:
    cmap = get_cmap(cmap)
    rc('image', cmap=cmap.name)
    im = gci()
    if im is not None:
        im.set_cmap(cmap)

@_copy_docstring_and_deprecators(matplotlib.image.imread)
def imread(fname: str | pathlib.Path | BinaryIO, format: str | None=None) -> np.ndarray:
    return matplotlib.image.imread(fname, format)

@_copy_docstring_and_deprecators(matplotlib.image.imsave)
def imsave(fname: str | os.PathLike | BinaryIO, arr: ArrayLike, **kwargs) -> None:
    matplotlib.image.imsave(fname, arr, **kwargs)

def matshow(A: ArrayLike, fignum: None | int=None, **kwargs) -> AxesImage:
    A = np.asanyarray(A)
    if fignum == 0:
        ax = gca()
    else:
        fig = figure(fignum, figsize=figaspect(A))
        ax = fig.add_axes((0.15, 0.09, 0.775, 0.775))
    im = ax.matshow(A, **kwargs)
    sci(im)
    return im

def polar(*args, **kwargs) -> list[Line2D]:
    if gcf().get_axes():
        ax = gca()
        if not isinstance(ax, PolarAxes):
            _api.warn_external('Trying to create polar plot on an Axes that does not have a polar projection.')
    else:
        ax = axes(projection='polar')
    return ax.plot(*args, **kwargs)
if rcParams['backend_fallback'] and rcParams._get_backend_or_none() in set(backend_registry.list_builtin(BackendFilter.INTERACTIVE)) - {'webagg', 'nbagg'} and cbook._get_running_interactive_framework():
    rcParams._set('backend', rcsetup._auto_backend_sentinel)

@_copy_docstring_and_deprecators(Figure.figimage)
def figimage(X: ArrayLike, xo: int=0, yo: int=0, alpha: float | None=None, norm: str | Normalize | None=None, cmap: str | Colormap | None=None, vmin: float | None=None, vmax: float | None=None, origin: Literal['upper', 'lower'] | None=None, resize: bool=False, **kwargs) -> FigureImage:
    return gcf().figimage(X, xo=xo, yo=yo, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin, resize=resize, **kwargs)

@_copy_docstring_and_deprecators(Figure.text)
def figtext(x: float, y: float, s: str, fontdict: dict[str, Any] | None=None, **kwargs) -> Text:
    return gcf().text(x, y, s, fontdict=fontdict, **kwargs)

@_copy_docstring_and_deprecators(Figure.gca)
def gca() -> Axes:
    return gcf().gca()

@_copy_docstring_and_deprecators(Figure._gci)
def gci() -> ScalarMappable | None:
    return gcf()._gci()

@_copy_docstring_and_deprecators(Figure.ginput)
def ginput(n: int=1, timeout: float=30, show_clicks: bool=True, mouse_add: MouseButton=MouseButton.LEFT, mouse_pop: MouseButton=MouseButton.RIGHT, mouse_stop: MouseButton=MouseButton.MIDDLE) -> list[tuple[int, int]]:
    return gcf().ginput(n=n, timeout=timeout, show_clicks=show_clicks, mouse_add=mouse_add, mouse_pop=mouse_pop, mouse_stop=mouse_stop)

@_copy_docstring_and_deprecators(Figure.subplots_adjust)
def subplots_adjust(left: float | None=None, bottom: float | None=None, right: float | None=None, top: float | None=None, wspace: float | None=None, hspace: float | None=None) -> None:
    gcf().subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace)

@_copy_docstring_and_deprecators(Figure.suptitle)
def suptitle(t: str, **kwargs) -> Text:
    return gcf().suptitle(t, **kwargs)

@_copy_docstring_and_deprecators(Figure.tight_layout)
def tight_layout(*, pad: float=1.08, h_pad: float | None=None, w_pad: float | None=None, rect: tuple[float, float, float, float] | None=None) -> None:
    gcf().tight_layout(pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)

@_copy_docstring_and_deprecators(Figure.waitforbuttonpress)
def waitforbuttonpress(timeout: float=-1) -> None | bool:
    return gcf().waitforbuttonpress(timeout=timeout)

@_copy_docstring_and_deprecators(Axes.acorr)
def acorr(x: ArrayLike, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, LineCollection | Line2D, Line2D | None]:
    return gca().acorr(x, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.angle_spectrum)
def angle_spectrum(x: ArrayLike, Fs: float | None=None, Fc: int | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, Line2D]:
    return gca().angle_spectrum(x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.annotate)
def annotate(text: str, xy: tuple[float, float], xytext: tuple[float, float] | None=None, xycoords: str | Artist | Transform | Callable[[RendererBase], Bbox | Transform] | tuple[float, float]='data', textcoords: str | Artist | Transform | Callable[[RendererBase], Bbox | Transform] | tuple[float, float] | None=None, arrowprops: dict[str, Any] | None=None, annotation_clip: bool | None=None, **kwargs) -> Annotation:
    return gca().annotate(text, xy, xytext=xytext, xycoords=xycoords, textcoords=textcoords, arrowprops=arrowprops, annotation_clip=annotation_clip, **kwargs)

@_copy_docstring_and_deprecators(Axes.arrow)
def arrow(x: float, y: float, dx: float, dy: float, **kwargs) -> FancyArrow:
    return gca().arrow(x, y, dx, dy, **kwargs)

@_copy_docstring_and_deprecators(Axes.autoscale)
def autoscale(enable: bool=True, axis: Literal['both', 'x', 'y']='both', tight: bool | None=None) -> None:
    gca().autoscale(enable=enable, axis=axis, tight=tight)

@_copy_docstring_and_deprecators(Axes.axhline)
def axhline(y: float=0, xmin: float=0, xmax: float=1, **kwargs) -> Line2D:
    return gca().axhline(y=y, xmin=xmin, xmax=xmax, **kwargs)

@_copy_docstring_and_deprecators(Axes.axhspan)
def axhspan(ymin: float, ymax: float, xmin: float=0, xmax: float=1, **kwargs) -> Rectangle:
    return gca().axhspan(ymin, ymax, xmin=xmin, xmax=xmax, **kwargs)

@_copy_docstring_and_deprecators(Axes.axis)
def axis(arg: tuple[float, float, float, float] | bool | str | None=None, /, *, emit: bool=True, **kwargs) -> tuple[float, float, float, float]:
    return gca().axis(arg, emit=emit, **kwargs)

@_copy_docstring_and_deprecators(Axes.axline)
def axline(xy1: tuple[float, float], xy2: tuple[float, float] | None=None, *, slope: float | None=None, **kwargs) -> AxLine:
    return gca().axline(xy1, xy2=xy2, slope=slope, **kwargs)

@_copy_docstring_and_deprecators(Axes.axvline)
def axvline(x: float=0, ymin: float=0, ymax: float=1, **kwargs) -> Line2D:
    return gca().axvline(x=x, ymin=ymin, ymax=ymax, **kwargs)

@_copy_docstring_and_deprecators(Axes.axvspan)
def axvspan(xmin: float, xmax: float, ymin: float=0, ymax: float=1, **kwargs) -> Rectangle:
    return gca().axvspan(xmin, xmax, ymin=ymin, ymax=ymax, **kwargs)

@_copy_docstring_and_deprecators(Axes.bar)
def bar(x: float | ArrayLike, height: float | ArrayLike, width: float | ArrayLike=0.8, bottom: float | ArrayLike | None=None, *, align: Literal['center', 'edge']='center', data=None, **kwargs) -> BarContainer:
    return gca().bar(x, height, width=width, bottom=bottom, align=align, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.barbs)
def barbs(*args, data=None, **kwargs) -> Barbs:
    return gca().barbs(*args, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.barh)
def barh(y: float | ArrayLike, width: float | ArrayLike, height: float | ArrayLike=0.8, left: float | ArrayLike | None=None, *, align: Literal['center', 'edge']='center', data=None, **kwargs) -> BarContainer:
    return gca().barh(y, width, height=height, left=left, align=align, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.bar_label)
def bar_label(container: BarContainer, labels: ArrayLike | None=None, *, fmt: str | Callable[[float], str]='%g', label_type: Literal['center', 'edge']='edge', padding: float=0, **kwargs) -> list[Annotation]:
    return gca().bar_label(container, labels=labels, fmt=fmt, label_type=label_type, padding=padding, **kwargs)

@_copy_docstring_and_deprecators(Axes.boxplot)
def boxplot(x: ArrayLike | Sequence[ArrayLike], notch: bool | None=None, sym: str | None=None, vert: bool | None=None, orientation: Literal['vertical', 'horizontal']='vertical', whis: float | tuple[float, float] | None=None, positions: ArrayLike | None=None, widths: float | ArrayLike | None=None, patch_artist: bool | None=None, bootstrap: int | None=None, usermedians: ArrayLike | None=None, conf_intervals: ArrayLike | None=None, meanline: bool | None=None, showmeans: bool | None=None, showcaps: bool | None=None, showbox: bool | None=None, showfliers: bool | None=None, boxprops: dict[str, Any] | None=None, tick_labels: Sequence[str] | None=None, flierprops: dict[str, Any] | None=None, medianprops: dict[str, Any] | None=None, meanprops: dict[str, Any] | None=None, capprops: dict[str, Any] | None=None, whiskerprops: dict[str, Any] | None=None, manage_ticks: bool=True, autorange: bool=False, zorder: float | None=None, capwidths: float | ArrayLike | None=None, label: Sequence[str] | None=None, *, data=None) -> dict[str, Any]:
    return gca().boxplot(x, notch=notch, sym=sym, vert=vert, orientation=orientation, whis=whis, positions=positions, widths=widths, patch_artist=patch_artist, bootstrap=bootstrap, usermedians=usermedians, conf_intervals=conf_intervals, meanline=meanline, showmeans=showmeans, showcaps=showcaps, showbox=showbox, showfliers=showfliers, boxprops=boxprops, tick_labels=tick_labels, flierprops=flierprops, medianprops=medianprops, meanprops=meanprops, capprops=capprops, whiskerprops=whiskerprops, manage_ticks=manage_ticks, autorange=autorange, zorder=zorder, capwidths=capwidths, label=label, **{'data': data} if data is not None else {})

@_copy_docstring_and_deprecators(Axes.broken_barh)
def broken_barh(xranges: Sequence[tuple[float, float]], yrange: tuple[float, float], *, data=None, **kwargs) -> PolyCollection:
    return gca().broken_barh(xranges, yrange, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.clabel)
def clabel(CS: ContourSet, levels: ArrayLike | None=None, **kwargs) -> list[Text]:
    return gca().clabel(CS, levels=levels, **kwargs)

@_copy_docstring_and_deprecators(Axes.cohere)
def cohere(x: ArrayLike, y: ArrayLike, NFFT: int=256, Fs: float=2, Fc: int=0, detrend: Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike]=mlab.detrend_none, window: Callable[[ArrayLike], ArrayLike] | ArrayLike=mlab.window_hanning, noverlap: int=0, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided']='default', scale_by_freq: bool | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray]:
    return gca().cohere(x, y, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.contour)
def contour(*args, data=None, **kwargs) -> QuadContourSet:
    __ret = gca().contour(*args, **{'data': data} if data is not None else {}, **kwargs)
    if __ret._A is not None:
        sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.contourf)
def contourf(*args, data=None, **kwargs) -> QuadContourSet:
    __ret = gca().contourf(*args, **{'data': data} if data is not None else {}, **kwargs)
    if __ret._A is not None:
        sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.csd)
def csd(x: ArrayLike, y: ArrayLike, NFFT: int | None=None, Fs: float | None=None, Fc: int | None=None, detrend: Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, noverlap: int | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, scale_by_freq: bool | None=None, return_line: bool | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, Line2D]:
    return gca().csd(x, y, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, return_line=return_line, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.ecdf)
def ecdf(x: ArrayLike, weights: ArrayLike | None=None, *, complementary: bool=False, orientation: Literal['vertical', 'horizonatal']='vertical', compress: bool=False, data=None, **kwargs) -> Line2D:
    return gca().ecdf(x, weights=weights, complementary=complementary, orientation=orientation, compress=compress, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.errorbar)
def errorbar(x: float | ArrayLike, y: float | ArrayLike, yerr: float | ArrayLike | None=None, xerr: float | ArrayLike | None=None, fmt: str='', ecolor: ColorType | None=None, elinewidth: float | None=None, capsize: float | None=None, barsabove: bool=False, lolims: bool | ArrayLike=False, uplims: bool | ArrayLike=False, xlolims: bool | ArrayLike=False, xuplims: bool | ArrayLike=False, errorevery: int | tuple[int, int]=1, capthick: float | None=None, *, data=None, **kwargs) -> ErrorbarContainer:
    return gca().errorbar(x, y, yerr=yerr, xerr=xerr, fmt=fmt, ecolor=ecolor, elinewidth=elinewidth, capsize=capsize, barsabove=barsabove, lolims=lolims, uplims=uplims, xlolims=xlolims, xuplims=xuplims, errorevery=errorevery, capthick=capthick, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.eventplot)
def eventplot(positions: ArrayLike | Sequence[ArrayLike], orientation: Literal['horizontal', 'vertical']='horizontal', lineoffsets: float | Sequence[float]=1, linelengths: float | Sequence[float]=1, linewidths: float | Sequence[float] | None=None, colors: ColorType | Sequence[ColorType] | None=None, alpha: float | Sequence[float] | None=None, linestyles: LineStyleType | Sequence[LineStyleType]='solid', *, data=None, **kwargs) -> EventCollection:
    return gca().eventplot(positions, orientation=orientation, lineoffsets=lineoffsets, linelengths=linelengths, linewidths=linewidths, colors=colors, alpha=alpha, linestyles=linestyles, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.fill)
def fill(*args, data=None, **kwargs) -> list[Polygon]:
    return gca().fill(*args, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.fill_between)
def fill_between(x: ArrayLike, y1: ArrayLike | float, y2: ArrayLike | float=0, where: Sequence[bool] | None=None, interpolate: bool=False, step: Literal['pre', 'post', 'mid'] | None=None, *, data=None, **kwargs) -> PolyCollection:
    return gca().fill_between(x, y1, y2=y2, where=where, interpolate=interpolate, step=step, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.fill_betweenx)
def fill_betweenx(y: ArrayLike, x1: ArrayLike | float, x2: ArrayLike | float=0, where: Sequence[bool] | None=None, step: Literal['pre', 'post', 'mid'] | None=None, interpolate: bool=False, *, data=None, **kwargs) -> PolyCollection:
    return gca().fill_betweenx(y, x1, x2=x2, where=where, step=step, interpolate=interpolate, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.grid)
def grid(visible: bool | None=None, which: Literal['major', 'minor', 'both']='major', axis: Literal['both', 'x', 'y']='both', **kwargs) -> None:
    gca().grid(visible=visible, which=which, axis=axis, **kwargs)

@_copy_docstring_and_deprecators(Axes.hexbin)
def hexbin(x: ArrayLike, y: ArrayLike, C: ArrayLike | None=None, gridsize: int | tuple[int, int]=100, bins: Literal['log'] | int | Sequence[float] | None=None, xscale: Literal['linear', 'log']='linear', yscale: Literal['linear', 'log']='linear', extent: tuple[float, float, float, float] | None=None, cmap: str | Colormap | None=None, norm: str | Normalize | None=None, vmin: float | None=None, vmax: float | None=None, alpha: float | None=None, linewidths: float | None=None, edgecolors: Literal['face', 'none'] | ColorType='face', reduce_C_function: Callable[[np.ndarray | list[float]], float]=np.mean, mincnt: int | None=None, marginals: bool=False, *, data=None, **kwargs) -> PolyCollection:
    __ret = gca().hexbin(x, y, C=C, gridsize=gridsize, bins=bins, xscale=xscale, yscale=yscale, extent=extent, cmap=cmap, norm=norm, vmin=vmin, vmax=vmax, alpha=alpha, linewidths=linewidths, edgecolors=edgecolors, reduce_C_function=reduce_C_function, mincnt=mincnt, marginals=marginals, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.hist)
def hist(x: ArrayLike | Sequence[ArrayLike], bins: int | Sequence[float] | str | None=None, range: tuple[float, float] | None=None, density: bool=False, weights: ArrayLike | None=None, cumulative: bool | float=False, bottom: ArrayLike | float | None=None, histtype: Literal['bar', 'barstacked', 'step', 'stepfilled']='bar', align: Literal['left', 'mid', 'right']='mid', orientation: Literal['vertical', 'horizontal']='vertical', rwidth: float | None=None, log: bool=False, color: ColorType | Sequence[ColorType] | None=None, label: str | Sequence[str] | None=None, stacked: bool=False, *, data=None, **kwargs) -> tuple[np.ndarray | list[np.ndarray], np.ndarray, BarContainer | Polygon | list[BarContainer | Polygon]]:
    return gca().hist(x, bins=bins, range=range, density=density, weights=weights, cumulative=cumulative, bottom=bottom, histtype=histtype, align=align, orientation=orientation, rwidth=rwidth, log=log, color=color, label=label, stacked=stacked, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.stairs)
def stairs(values: ArrayLike, edges: ArrayLike | None=None, *, orientation: Literal['vertical', 'horizontal']='vertical', baseline: float | ArrayLike | None=0, fill: bool=False, data=None, **kwargs) -> StepPatch:
    return gca().stairs(values, edges=edges, orientation=orientation, baseline=baseline, fill=fill, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.hist2d)
def hist2d(x: ArrayLike, y: ArrayLike, bins: None | int | tuple[int, int] | ArrayLike | tuple[ArrayLike, ArrayLike]=10, range: ArrayLike | None=None, density: bool=False, weights: ArrayLike | None=None, cmin: float | None=None, cmax: float | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, np.ndarray, QuadMesh]:
    __ret = gca().hist2d(x, y, bins=bins, range=range, density=density, weights=weights, cmin=cmin, cmax=cmax, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret[-1])
    return __ret

@_copy_docstring_and_deprecators(Axes.hlines)
def hlines(y: float | ArrayLike, xmin: float | ArrayLike, xmax: float | ArrayLike, colors: ColorType | Sequence[ColorType] | None=None, linestyles: LineStyleType='solid', label: str='', *, data=None, **kwargs) -> LineCollection:
    return gca().hlines(y, xmin, xmax, colors=colors, linestyles=linestyles, label=label, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.imshow)
def imshow(X: ArrayLike | PIL.Image.Image, cmap: str | Colormap | None=None, norm: str | Normalize | None=None, *, aspect: Literal['equal', 'auto'] | float | None=None, interpolation: str | None=None, alpha: float | ArrayLike | None=None, vmin: float | None=None, vmax: float | None=None, origin: Literal['upper', 'lower'] | None=None, extent: tuple[float, float, float, float] | None=None, interpolation_stage: Literal['data', 'rgba', 'auto'] | None=None, filternorm: bool=True, filterrad: float=4.0, resample: bool | None=None, url: str | None=None, data=None, **kwargs) -> AxesImage:
    __ret = gca().imshow(X, cmap=cmap, norm=norm, aspect=aspect, interpolation=interpolation, alpha=alpha, vmin=vmin, vmax=vmax, origin=origin, extent=extent, interpolation_stage=interpolation_stage, filternorm=filternorm, filterrad=filterrad, resample=resample, url=url, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.legend)
def legend(*args, **kwargs) -> Legend:
    return gca().legend(*args, **kwargs)

@_copy_docstring_and_deprecators(Axes.locator_params)
def locator_params(axis: Literal['both', 'x', 'y']='both', tight: bool | None=None, **kwargs) -> None:
    gca().locator_params(axis=axis, tight=tight, **kwargs)

@_copy_docstring_and_deprecators(Axes.loglog)
def loglog(*args, **kwargs) -> list[Line2D]:
    return gca().loglog(*args, **kwargs)

@_copy_docstring_and_deprecators(Axes.magnitude_spectrum)
def magnitude_spectrum(x: ArrayLike, Fs: float | None=None, Fc: int | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, scale: Literal['default', 'linear', 'dB'] | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, Line2D]:
    return gca().magnitude_spectrum(x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, scale=scale, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.margins)
def margins(*margins: float, x: float | None=None, y: float | None=None, tight: bool | None=True) -> tuple[float, float] | None:
    return gca().margins(*margins, x=x, y=y, tight=tight)

@_copy_docstring_and_deprecators(Axes.minorticks_off)
def minorticks_off() -> None:
    gca().minorticks_off()

@_copy_docstring_and_deprecators(Axes.minorticks_on)
def minorticks_on() -> None:
    gca().minorticks_on()

@_copy_docstring_and_deprecators(Axes.pcolor)
def pcolor(*args: ArrayLike, shading: Literal['flat', 'nearest', 'auto'] | None=None, alpha: float | None=None, norm: str | Normalize | None=None, cmap: str | Colormap | None=None, vmin: float | None=None, vmax: float | None=None, data=None, **kwargs) -> Collection:
    __ret = gca().pcolor(*args, shading=shading, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, vmax=vmax, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.pcolormesh)
def pcolormesh(*args: ArrayLike, alpha: float | None=None, norm: str | Normalize | None=None, cmap: str | Colormap | None=None, vmin: float | None=None, vmax: float | None=None, shading: Literal['flat', 'nearest', 'gouraud', 'auto'] | None=None, antialiased: bool=False, data=None, **kwargs) -> QuadMesh:
    __ret = gca().pcolormesh(*args, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, vmax=vmax, shading=shading, antialiased=antialiased, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.phase_spectrum)
def phase_spectrum(x: ArrayLike, Fs: float | None=None, Fc: int | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, Line2D]:
    return gca().phase_spectrum(x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.pie)
def pie(x: ArrayLike, explode: ArrayLike | None=None, labels: Sequence[str] | None=None, colors: ColorType | Sequence[ColorType] | None=None, autopct: str | Callable[[float], str] | None=None, pctdistance: float=0.6, shadow: bool=False, labeldistance: float | None=1.1, startangle: float=0, radius: float=1, counterclock: bool=True, wedgeprops: dict[str, Any] | None=None, textprops: dict[str, Any] | None=None, center: tuple[float, float]=(0, 0), frame: bool=False, rotatelabels: bool=False, *, normalize: bool=True, hatch: str | Sequence[str] | None=None, data=None) -> tuple[list[Wedge], list[Text]] | tuple[list[Wedge], list[Text], list[Text]]:
    return gca().pie(x, explode=explode, labels=labels, colors=colors, autopct=autopct, pctdistance=pctdistance, shadow=shadow, labeldistance=labeldistance, startangle=startangle, radius=radius, counterclock=counterclock, wedgeprops=wedgeprops, textprops=textprops, center=center, frame=frame, rotatelabels=rotatelabels, normalize=normalize, hatch=hatch, **{'data': data} if data is not None else {})

@_copy_docstring_and_deprecators(Axes.plot)
def plot(*args: float | ArrayLike | str, scalex: bool=True, scaley: bool=True, data=None, **kwargs) -> list[Line2D]:
    return gca().plot(*args, scalex=scalex, scaley=scaley, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.plot_date)
def plot_date(x: ArrayLike, y: ArrayLike, fmt: str='o', tz: str | datetime.tzinfo | None=None, xdate: bool=True, ydate: bool=False, *, data=None, **kwargs) -> list[Line2D]:
    return gca().plot_date(x, y, fmt=fmt, tz=tz, xdate=xdate, ydate=ydate, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.psd)
def psd(x: ArrayLike, NFFT: int | None=None, Fs: float | None=None, Fc: int | None=None, detrend: Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, noverlap: int | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, scale_by_freq: bool | None=None, return_line: bool | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, Line2D]:
    return gca().psd(x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, return_line=return_line, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.quiver)
def quiver(*args, data=None, **kwargs) -> Quiver:
    __ret = gca().quiver(*args, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.quiverkey)
def quiverkey(Q: Quiver, X: float, Y: float, U: float, label: str, **kwargs) -> QuiverKey:
    return gca().quiverkey(Q, X, Y, U, label, **kwargs)

@_copy_docstring_and_deprecators(Axes.scatter)
def scatter(x: float | ArrayLike, y: float | ArrayLike, s: float | ArrayLike | None=None, c: ArrayLike | Sequence[ColorType] | ColorType | None=None, marker: MarkerType | None=None, cmap: str | Colormap | None=None, norm: str | Normalize | None=None, vmin: float | None=None, vmax: float | None=None, alpha: float | None=None, linewidths: float | Sequence[float] | None=None, *, edgecolors: Literal['face', 'none'] | ColorType | Sequence[ColorType] | None=None, plotnonfinite: bool=False, data=None, **kwargs) -> PathCollection:
    __ret = gca().scatter(x, y, s=s, c=c, marker=marker, cmap=cmap, norm=norm, vmin=vmin, vmax=vmax, alpha=alpha, linewidths=linewidths, edgecolors=edgecolors, plotnonfinite=plotnonfinite, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.semilogx)
def semilogx(*args, **kwargs) -> list[Line2D]:
    return gca().semilogx(*args, **kwargs)

@_copy_docstring_and_deprecators(Axes.semilogy)
def semilogy(*args, **kwargs) -> list[Line2D]:
    return gca().semilogy(*args, **kwargs)

@_copy_docstring_and_deprecators(Axes.specgram)
def specgram(x: ArrayLike, NFFT: int | None=None, Fs: float | None=None, Fc: int | None=None, detrend: Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None=None, window: Callable[[ArrayLike], ArrayLike] | ArrayLike | None=None, noverlap: int | None=None, cmap: str | Colormap | None=None, xextent: tuple[float, float] | None=None, pad_to: int | None=None, sides: Literal['default', 'onesided', 'twosided'] | None=None, scale_by_freq: bool | None=None, mode: Literal['default', 'psd', 'magnitude', 'angle', 'phase'] | None=None, scale: Literal['default', 'linear', 'dB'] | None=None, vmin: float | None=None, vmax: float | None=None, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, np.ndarray, AxesImage]:
    __ret = gca().specgram(x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, cmap=cmap, xextent=xextent, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode=mode, scale=scale, vmin=vmin, vmax=vmax, **{'data': data} if data is not None else {}, **kwargs)
    sci(__ret[-1])
    return __ret

@_copy_docstring_and_deprecators(Axes.spy)
def spy(Z: ArrayLike, precision: float | Literal['present']=0, marker: str | None=None, markersize: float | None=None, aspect: Literal['equal', 'auto'] | float | None='equal', origin: Literal['upper', 'lower']='upper', **kwargs) -> AxesImage:
    __ret = gca().spy(Z, precision=precision, marker=marker, markersize=markersize, aspect=aspect, origin=origin, **kwargs)
    if isinstance(__ret, cm.ScalarMappable):
        sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.stackplot)
def stackplot(x, *args, labels=(), colors=None, hatch=None, baseline='zero', data=None, **kwargs):
    return gca().stackplot(x, *args, labels=labels, colors=colors, hatch=hatch, baseline=baseline, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.stem)
def stem(*args: ArrayLike | str, linefmt: str | None=None, markerfmt: str | None=None, basefmt: str | None=None, bottom: float=0, label: str | None=None, orientation: Literal['vertical', 'horizontal']='vertical', data=None) -> StemContainer:
    return gca().stem(*args, linefmt=linefmt, markerfmt=markerfmt, basefmt=basefmt, bottom=bottom, label=label, orientation=orientation, **{'data': data} if data is not None else {})

@_copy_docstring_and_deprecators(Axes.step)
def step(x: ArrayLike, y: ArrayLike, *args, where: Literal['pre', 'post', 'mid']='pre', data=None, **kwargs) -> list[Line2D]:
    return gca().step(x, y, *args, where=where, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.streamplot)
def streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', broken_streamlines=True, *, data=None):
    __ret = gca().streamplot(x, y, u, v, density=density, linewidth=linewidth, color=color, cmap=cmap, norm=norm, arrowsize=arrowsize, arrowstyle=arrowstyle, minlength=minlength, transform=transform, zorder=zorder, start_points=start_points, maxlength=maxlength, integration_direction=integration_direction, broken_streamlines=broken_streamlines, **{'data': data} if data is not None else {})
    sci(__ret.lines)
    return __ret

@_copy_docstring_and_deprecators(Axes.table)
def table(cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs):
    return gca().table(cellText=cellText, cellColours=cellColours, cellLoc=cellLoc, colWidths=colWidths, rowLabels=rowLabels, rowColours=rowColours, rowLoc=rowLoc, colLabels=colLabels, colColours=colColours, colLoc=colLoc, loc=loc, bbox=bbox, edges=edges, **kwargs)

@_copy_docstring_and_deprecators(Axes.text)
def text(x: float, y: float, s: str, fontdict: dict[str, Any] | None=None, **kwargs) -> Text:
    return gca().text(x, y, s, fontdict=fontdict, **kwargs)

@_copy_docstring_and_deprecators(Axes.tick_params)
def tick_params(axis: Literal['both', 'x', 'y']='both', **kwargs) -> None:
    gca().tick_params(axis=axis, **kwargs)

@_copy_docstring_and_deprecators(Axes.ticklabel_format)
def ticklabel_format(*, axis: Literal['both', 'x', 'y']='both', style: Literal['', 'sci', 'scientific', 'plain'] | None=None, scilimits: tuple[int, int] | None=None, useOffset: bool | float | None=None, useLocale: bool | None=None, useMathText: bool | None=None) -> None:
    gca().ticklabel_format(axis=axis, style=style, scilimits=scilimits, useOffset=useOffset, useLocale=useLocale, useMathText=useMathText)

@_copy_docstring_and_deprecators(Axes.tricontour)
def tricontour(*args, **kwargs):
    __ret = gca().tricontour(*args, **kwargs)
    if __ret._A is not None:
        sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.tricontourf)
def tricontourf(*args, **kwargs):
    __ret = gca().tricontourf(*args, **kwargs)
    if __ret._A is not None:
        sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.tripcolor)
def tripcolor(*args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs):
    __ret = gca().tripcolor(*args, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, vmax=vmax, shading=shading, facecolors=facecolors, **kwargs)
    sci(__ret)
    return __ret

@_copy_docstring_and_deprecators(Axes.triplot)
def triplot(*args, **kwargs):
    return gca().triplot(*args, **kwargs)

@_copy_docstring_and_deprecators(Axes.violinplot)
def violinplot(dataset: ArrayLike | Sequence[ArrayLike], positions: ArrayLike | None=None, vert: bool | None=None, orientation: Literal['vertical', 'horizontal']='vertical', widths: float | ArrayLike=0.5, showmeans: bool=False, showextrema: bool=True, showmedians: bool=False, quantiles: Sequence[float | Sequence[float]] | None=None, points: int=100, bw_method: Literal['scott', 'silverman'] | float | Callable[[GaussianKDE], float] | None=None, side: Literal['both', 'low', 'high']='both', *, data=None) -> dict[str, Collection]:
    return gca().violinplot(dataset, positions=positions, vert=vert, orientation=orientation, widths=widths, showmeans=showmeans, showextrema=showextrema, showmedians=showmedians, quantiles=quantiles, points=points, bw_method=bw_method, side=side, **{'data': data} if data is not None else {})

@_copy_docstring_and_deprecators(Axes.vlines)
def vlines(x: float | ArrayLike, ymin: float | ArrayLike, ymax: float | ArrayLike, colors: ColorType | Sequence[ColorType] | None=None, linestyles: LineStyleType='solid', label: str='', *, data=None, **kwargs) -> LineCollection:
    return gca().vlines(x, ymin, ymax, colors=colors, linestyles=linestyles, label=label, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes.xcorr)
def xcorr(x: ArrayLike, y: ArrayLike, normed: bool=True, detrend: Callable[[ArrayLike], ArrayLike]=mlab.detrend_none, usevlines: bool=True, maxlags: int=10, *, data=None, **kwargs) -> tuple[np.ndarray, np.ndarray, LineCollection | Line2D, Line2D | None]:
    return gca().xcorr(x, y, normed=normed, detrend=detrend, usevlines=usevlines, maxlags=maxlags, **{'data': data} if data is not None else {}, **kwargs)

@_copy_docstring_and_deprecators(Axes._sci)
def sci(im: ScalarMappable) -> None:
    gca()._sci(im)

@_copy_docstring_and_deprecators(Axes.set_title)
def title(label: str, fontdict: dict[str, Any] | None=None, loc: Literal['left', 'center', 'right'] | None=None, pad: float | None=None, *, y: float | None=None, **kwargs) -> Text:
    return gca().set_title(label, fontdict=fontdict, loc=loc, pad=pad, y=y, **kwargs)

@_copy_docstring_and_deprecators(Axes.set_xlabel)
def xlabel(xlabel: str, fontdict: dict[str, Any] | None=None, labelpad: float | None=None, *, loc: Literal['left', 'center', 'right'] | None=None, **kwargs) -> Text:
    return gca().set_xlabel(xlabel, fontdict=fontdict, labelpad=labelpad, loc=loc, **kwargs)

@_copy_docstring_and_deprecators(Axes.set_ylabel)
def ylabel(ylabel: str, fontdict: dict[str, Any] | None=None, labelpad: float | None=None, *, loc: Literal['bottom', 'center', 'top'] | None=None, **kwargs) -> Text:
    return gca().set_ylabel(ylabel, fontdict=fontdict, labelpad=labelpad, loc=loc, **kwargs)

@_copy_docstring_and_deprecators(Axes.set_xscale)
def xscale(value: str | ScaleBase, **kwargs) -> None:
    gca().set_xscale(value, **kwargs)

@_copy_docstring_and_deprecators(Axes.set_yscale)
def yscale(value: str | ScaleBase, **kwargs) -> None:
    gca().set_yscale(value, **kwargs)

def autumn() -> None:
    set_cmap('autumn')

def bone() -> None:
    set_cmap('bone')

def cool() -> None:
    set_cmap('cool')

def copper() -> None:
    set_cmap('copper')

def flag() -> None:
    set_cmap('flag')

def gray() -> None:
    set_cmap('gray')

def hot() -> None:
    set_cmap('hot')

def hsv() -> None:
    set_cmap('hsv')

def jet() -> None:
    set_cmap('jet')

def pink() -> None:
    set_cmap('pink')

def prism() -> None:
    set_cmap('prism')

def spring() -> None:
    set_cmap('spring')

def summer() -> None:
    set_cmap('summer')

def winter() -> None:
    set_cmap('winter')

def magma() -> None:
    set_cmap('magma')

def inferno() -> None:
    set_cmap('inferno')

def plasma() -> None:
    set_cmap('plasma')

def viridis() -> None:
    set_cmap('viridis')

def nipy_spectral() -> None:
    set_cmap('nipy_spectral')

# File: matplotlib-main/lib/matplotlib/quiver.py
""""""
import math
import numpy as np
from numpy import ma
from matplotlib import _api, cbook, _docstring
import matplotlib.artist as martist
import matplotlib.collections as mcollections
from matplotlib.patches import CirclePolygon
import matplotlib.text as mtext
import matplotlib.transforms as transforms
_quiver_doc = '\nPlot a 2D field of arrows.\n\nCall signature::\n\n  quiver([X, Y], U, V, [C], /, **kwargs)\n\n*X*, *Y* define the arrow locations, *U*, *V* define the arrow directions, and\n*C* optionally sets the color. The arguments *X*, *Y*, *U*, *V*, *C* are\npositional-only.\n\n**Arrow length**\n\nThe default settings auto-scales the length of the arrows to a reasonable size.\nTo change this behavior see the *scale* and *scale_units* parameters.\n\n**Arrow shape**\n\nThe arrow shape is determined by *width*, *headwidth*, *headlength* and\n*headaxislength*. See the notes below.\n\n**Arrow styling**\n\nEach arrow is internally represented by a filled polygon with a default edge\nlinewidth of 0. As a result, an arrow is rather a filled area, not a line with\na head, and `.PolyCollection` properties like *linewidth*, *edgecolor*,\n*facecolor*, etc. act accordingly.\n\n\nParameters\n----------\nX, Y : 1D or 2D array-like, optional\n    The x and y coordinates of the arrow locations.\n\n    If not given, they will be generated as a uniform integer meshgrid based\n    on the dimensions of *U* and *V*.\n\n    If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n    using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n    must match the column and row dimensions of *U* and *V*.\n\nU, V : 1D or 2D array-like\n    The x and y direction components of the arrow vectors. The interpretation\n    of these components (in data or in screen space) depends on *angles*.\n\n    *U* and *V* must have the same number of elements, matching the number of\n    arrow locations in *X*, *Y*. *U* and *V* may be masked. Locations masked\n    in any of *U*, *V*, and *C* will not be drawn.\n\nC : 1D or 2D array-like, optional\n    Numeric data that defines the arrow colors by colormapping via *norm* and\n    *cmap*.\n\n    This does not support explicit colors. If you want to set colors directly,\n    use *color* instead.  The size of *C* must match the number of arrow\n    locations.\n\nangles : {\'uv\', \'xy\'} or array-like, default: \'uv\'\n    Method for determining the angle of the arrows.\n\n    - \'uv\': Arrow direction in screen coordinates. Use this if the arrows\n      symbolize a quantity that is not based on *X*, *Y* data coordinates.\n\n      If *U* == *V* the orientation of the arrow on the plot is 45 degrees\n      counter-clockwise from the horizontal axis (positive to the right).\n\n    - \'xy\': Arrow direction in data coordinates, i.e. the arrows point from\n      (x, y) to (x+u, y+v). Use this e.g. for plotting a gradient field.\n\n    - Arbitrary angles may be specified explicitly as an array of values\n      in degrees, counter-clockwise from the horizontal axis.\n\n      In this case *U*, *V* is only used to determine the length of the\n      arrows.\n\n    Note: inverting a data axis will correspondingly invert the\n    arrows only with ``angles=\'xy\'``.\n\npivot : {\'tail\', \'mid\', \'middle\', \'tip\'}, default: \'tail\'\n    The part of the arrow that is anchored to the *X*, *Y* grid. The arrow\n    rotates about this point.\n\n    \'mid\' is a synonym for \'middle\'.\n\nscale : float, optional\n    Scales the length of the arrow inversely.\n\n    Number of data units per arrow length unit, e.g., m/s per plot width; a\n    smaller scale parameter makes the arrow longer. Default is *None*.\n\n    If *None*, a simple autoscaling algorithm is used, based on the average\n    vector length and the number of vectors. The arrow length unit is given by\n    the *scale_units* parameter.\n\nscale_units : {\'width\', \'height\', \'dots\', \'inches\', \'x\', \'y\', \'xy\'}, optional\n    If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.\n\n    e.g. *scale_units* is \'inches\', *scale* is 2.0, and ``(u, v) = (1, 0)``,\n    then the vector will be 0.5 inches long.\n\n    If *scale_units* is \'width\' or \'height\', then the vector will be half the\n    width/height of the axes.\n\n    If *scale_units* is \'x\' then the vector will be 0.5 x-axis\n    units. To plot vectors in the x-y plane, with u and v having\n    the same units as x and y, use\n    ``angles=\'xy\', scale_units=\'xy\', scale=1``.\n\nunits : {\'width\', \'height\', \'dots\', \'inches\', \'x\', \'y\', \'xy\'}, default: \'width\'\n    Affects the arrow size (except for the length). In particular, the shaft\n    *width* is measured in multiples of this unit.\n\n    Supported values are:\n\n    - \'width\', \'height\': The width or height of the Axes.\n    - \'dots\', \'inches\': Pixels or inches based on the figure dpi.\n    - \'x\', \'y\', \'xy\': *X*, *Y* or :math:`\\sqrt{X^2 + Y^2}` in data units.\n\n    The following table summarizes how these values affect the visible arrow\n    size under zooming and figure size changes:\n\n    =================  =================   ==================\n    units              zoom                figure size change\n    =================  =================   ==================\n    \'x\', \'y\', \'xy\'     arrow size scales   —\n    \'width\', \'height\'  —                   arrow size scales\n    \'dots\', \'inches\'   —                   —\n    =================  =================   ==================\n\nwidth : float, optional\n    Shaft width in arrow units. All head parameters are relative to *width*.\n\n    The default depends on choice of *units* above, and number of vectors;\n    a typical starting value is about 0.005 times the width of the plot.\n\nheadwidth : float, default: 3\n    Head width as multiple of shaft *width*. See the notes below.\n\nheadlength : float, default: 5\n    Head length as multiple of shaft *width*. See the notes below.\n\nheadaxislength : float, default: 4.5\n    Head length at shaft intersection as multiple of shaft *width*.\n    See the notes below.\n\nminshaft : float, default: 1\n    Length below which arrow scales, in units of head length. Do not\n    set this to less than 1, or small arrows will look terrible!\n\nminlength : float, default: 1\n    Minimum length as a multiple of shaft width; if an arrow length\n    is less than this, plot a dot (hexagon) of this diameter instead.\n\ncolor : :mpltype:`color` or list :mpltype:`color`, optional\n    Explicit color(s) for the arrows. If *C* has been set, *color* has no\n    effect.\n\n    This is a synonym for the `.PolyCollection` *facecolor* parameter.\n\nOther Parameters\n----------------\ndata : indexable object, optional\n    DATA_PARAMETER_PLACEHOLDER\n\n**kwargs : `~matplotlib.collections.PolyCollection` properties, optional\n    All other keyword arguments are passed on to `.PolyCollection`:\n\n    %(PolyCollection:kwdoc)s\n\nReturns\n-------\n`~matplotlib.quiver.Quiver`\n\nSee Also\n--------\n.Axes.quiverkey : Add a key to a quiver plot.\n\nNotes\n-----\n\n**Arrow shape**\n\nThe arrow is drawn as a polygon using the nodes as shown below. The values\n*headwidth*, *headlength*, and *headaxislength* are in units of *width*.\n\n.. image:: /_static/quiver_sizes.svg\n   :width: 500px\n\nThe defaults give a slightly swept-back arrow. Here are some guidelines how to\nget other head shapes:\n\n- To make the head a triangle, make *headaxislength* the same as *headlength*.\n- To make the arrow more pointed, reduce *headwidth* or increase *headlength*\n  and *headaxislength*.\n- To make the head smaller relative to the shaft, scale down all the head\n  parameters proportionally.\n- To remove the head completely, set all *head* parameters to 0.\n- To get a diamond-shaped head, make *headaxislength* larger than *headlength*.\n- Warning: For *headaxislength* < (*headlength* / *headwidth*), the "headaxis"\n  nodes (i.e. the ones connecting the head with the shaft) will protrude out\n  of the head in forward direction so that the arrow head looks broken.\n' % _docstring.interpd.params
_docstring.interpd.update(quiver_doc=_quiver_doc)

class QuiverKey(martist.Artist):
    halign = {'N': 'center', 'S': 'center', 'E': 'left', 'W': 'right'}
    valign = {'N': 'bottom', 'S': 'top', 'E': 'center', 'W': 'center'}
    pivot = {'N': 'middle', 'S': 'middle', 'E': 'tip', 'W': 'tail'}

    def __init__(self, Q, X, Y, U, label, *, angle=0, coordinates='axes', color=None, labelsep=0.1, labelpos='N', labelcolor=None, fontproperties=None, **kwargs):
        super().__init__()
        self.Q = Q
        self.X = X
        self.Y = Y
        self.U = U
        self.angle = angle
        self.coord = coordinates
        self.color = color
        self.label = label
        self._labelsep_inches = labelsep
        self.labelpos = labelpos
        self.labelcolor = labelcolor
        self.fontproperties = fontproperties or dict()
        self.kw = kwargs
        self.text = mtext.Text(text=label, horizontalalignment=self.halign[self.labelpos], verticalalignment=self.valign[self.labelpos], fontproperties=self.fontproperties)
        if self.labelcolor is not None:
            self.text.set_color(self.labelcolor)
        self._dpi_at_last_init = None
        self.zorder = Q.zorder + 0.1

    @property
    def labelsep(self):
        return self._labelsep_inches * self.Q.axes.get_figure(root=True).dpi

    def _init(self):
        if True:
            if self.Q._dpi_at_last_init != self.Q.axes.get_figure(root=True).dpi:
                self.Q._init()
            self._set_transform()
            with cbook._setattr_cm(self.Q, pivot=self.pivot[self.labelpos], Umask=ma.nomask):
                u = self.U * np.cos(np.radians(self.angle))
                v = self.U * np.sin(np.radians(self.angle))
                self.verts = self.Q._make_verts([[0.0, 0.0]], np.array([u]), np.array([v]), 'uv')
            kwargs = self.Q.polykw
            kwargs.update(self.kw)
            self.vector = mcollections.PolyCollection(self.verts, offsets=[(self.X, self.Y)], offset_transform=self.get_transform(), **kwargs)
            if self.color is not None:
                self.vector.set_color(self.color)
            self.vector.set_transform(self.Q.get_transform())
            self.vector.set_figure(self.get_figure())
            self._dpi_at_last_init = self.Q.axes.get_figure(root=True).dpi

    def _text_shift(self):
        return {'N': (0, +self.labelsep), 'S': (0, -self.labelsep), 'E': (+self.labelsep, 0), 'W': (-self.labelsep, 0)}[self.labelpos]

    @martist.allow_rasterization
    def draw(self, renderer):
        self._init()
        self.vector.draw(renderer)
        pos = self.get_transform().transform((self.X, self.Y))
        self.text.set_position(pos + self._text_shift())
        self.text.draw(renderer)
        self.stale = False

    def _set_transform(self):
        fig = self.Q.axes.get_figure(root=False)
        self.set_transform(_api.check_getitem({'data': self.Q.axes.transData, 'axes': self.Q.axes.transAxes, 'figure': fig.transFigure, 'inches': fig.dpi_scale_trans}, coordinates=self.coord))

    def set_figure(self, fig):
        super().set_figure(fig)
        self.text.set_figure(fig)

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        if self.text.contains(mouseevent)[0] or self.vector.contains(mouseevent)[0]:
            return (True, {})
        return (False, {})

def _parse_args(*args, caller_name='function'):
    X = Y = C = None
    nargs = len(args)
    if nargs == 2:
        (U, V) = np.atleast_1d(*args)
    elif nargs == 3:
        (U, V, C) = np.atleast_1d(*args)
    elif nargs == 4:
        (X, Y, U, V) = np.atleast_1d(*args)
    elif nargs == 5:
        (X, Y, U, V, C) = np.atleast_1d(*args)
    else:
        raise _api.nargs_error(caller_name, takes='from 2 to 5', given=nargs)
    (nr, nc) = (1, U.shape[0]) if U.ndim == 1 else U.shape
    if X is not None:
        X = X.ravel()
        Y = Y.ravel()
        if len(X) == nc and len(Y) == nr:
            (X, Y) = (a.ravel() for a in np.meshgrid(X, Y))
        elif len(X) != len(Y):
            raise ValueError(f'X and Y must be the same size, but X.size is {X.size} and Y.size is {Y.size}.')
    else:
        indexgrid = np.meshgrid(np.arange(nc), np.arange(nr))
        (X, Y) = (np.ravel(a) for a in indexgrid)
    return (X, Y, U, V, C)

def _check_consistent_shapes(*arrays):
    all_shapes = {a.shape for a in arrays}
    if len(all_shapes) != 1:
        raise ValueError('The shapes of the passed in arrays do not match')

class Quiver(mcollections.PolyCollection):
    _PIVOT_VALS = ('tail', 'middle', 'tip')

    @_docstring.Substitution(_quiver_doc)
    def __init__(self, ax, *args, scale=None, headwidth=3, headlength=5, headaxislength=4.5, minshaft=1, minlength=1, units='width', scale_units=None, angles='uv', width=None, color='k', pivot='tail', **kwargs):
        self._axes = ax
        (X, Y, U, V, C) = _parse_args(*args, caller_name='quiver')
        self.X = X
        self.Y = Y
        self.XY = np.column_stack((X, Y))
        self.N = len(X)
        self.scale = scale
        self.headwidth = headwidth
        self.headlength = float(headlength)
        self.headaxislength = headaxislength
        self.minshaft = minshaft
        self.minlength = minlength
        self.units = units
        self.scale_units = scale_units
        self.angles = angles
        self.width = width
        if pivot.lower() == 'mid':
            pivot = 'middle'
        self.pivot = pivot.lower()
        _api.check_in_list(self._PIVOT_VALS, pivot=self.pivot)
        self.transform = kwargs.pop('transform', ax.transData)
        kwargs.setdefault('facecolors', color)
        kwargs.setdefault('linewidths', (0,))
        super().__init__([], offsets=self.XY, offset_transform=self.transform, closed=False, **kwargs)
        self.polykw = kwargs
        self.set_UVC(U, V, C)
        self._dpi_at_last_init = None

    def _init(self):
        if True:
            trans = self._set_transform()
            self.span = trans.inverted().transform_bbox(self.axes.bbox).width
            if self.width is None:
                sn = np.clip(math.sqrt(self.N), 8, 25)
                self.width = 0.06 * self.span / sn
            if self._dpi_at_last_init != self.axes.get_figure(root=True).dpi and self.scale is None:
                self._make_verts(self.XY, self.U, self.V, self.angles)
            self._dpi_at_last_init = self.axes.get_figure(root=True).dpi

    def get_datalim(self, transData):
        trans = self.get_transform()
        offset_trf = self.get_offset_transform()
        full_transform = trans - transData + (offset_trf - transData)
        XY = full_transform.transform(self.XY)
        bbox = transforms.Bbox.null()
        bbox.update_from_data_xy(XY, ignore=True)
        return bbox

    @martist.allow_rasterization
    def draw(self, renderer):
        self._init()
        verts = self._make_verts(self.XY, self.U, self.V, self.angles)
        self.set_verts(verts, closed=False)
        super().draw(renderer)
        self.stale = False

    def set_UVC(self, U, V, C=None):
        U = ma.masked_invalid(U, copy=True).ravel()
        V = ma.masked_invalid(V, copy=True).ravel()
        if C is not None:
            C = ma.masked_invalid(C, copy=True).ravel()
        for (name, var) in zip(('U', 'V', 'C'), (U, V, C)):
            if not (var is None or var.size == self.N or var.size == 1):
                raise ValueError(f'Argument {name} has a size {var.size} which does not match {self.N}, the number of arrow positions')
        mask = ma.mask_or(U.mask, V.mask, copy=False, shrink=True)
        if C is not None:
            mask = ma.mask_or(mask, C.mask, copy=False, shrink=True)
            if mask is ma.nomask:
                C = C.filled()
            else:
                C = ma.array(C, mask=mask, copy=False)
        self.U = U.filled(1)
        self.V = V.filled(1)
        self.Umask = mask
        if C is not None:
            self.set_array(C)
        self.stale = True

    def _dots_per_unit(self, units):
        bb = self.axes.bbox
        vl = self.axes.viewLim
        return _api.check_getitem({'x': bb.width / vl.width, 'y': bb.height / vl.height, 'xy': np.hypot(*bb.size) / np.hypot(*vl.size), 'width': bb.width, 'height': bb.height, 'dots': 1.0, 'inches': self.axes.get_figure(root=True).dpi}, units=units)

    def _set_transform(self):
        dx = self._dots_per_unit(self.units)
        self._trans_scale = dx
        trans = transforms.Affine2D().scale(dx)
        self.set_transform(trans)
        return trans

    def _angles_lengths(self, XY, U, V, eps=1):
        xy = self.axes.transData.transform(XY)
        uv = np.column_stack((U, V))
        xyp = self.axes.transData.transform(XY + eps * uv)
        dxy = xyp - xy
        angles = np.arctan2(dxy[:, 1], dxy[:, 0])
        lengths = np.hypot(*dxy.T) / eps
        return (angles, lengths)

    def _make_verts(self, XY, U, V, angles):
        uv = U + V * 1j
        str_angles = angles if isinstance(angles, str) else ''
        if str_angles == 'xy' and self.scale_units == 'xy':
            (angles, lengths) = self._angles_lengths(XY, U, V, eps=1)
        elif str_angles == 'xy' or self.scale_units == 'xy':
            eps = np.abs(self.axes.dataLim.extents).max() * 0.001
            (angles, lengths) = self._angles_lengths(XY, U, V, eps=eps)
        if str_angles and self.scale_units == 'xy':
            a = lengths
        else:
            a = np.abs(uv)
        if self.scale is None:
            sn = max(10, math.sqrt(self.N))
            if self.Umask is not ma.nomask:
                amean = a[~self.Umask].mean()
            else:
                amean = a.mean()
            scale = 1.8 * amean * sn / self.span
        if self.scale_units is None:
            if self.scale is None:
                self.scale = scale
            widthu_per_lenu = 1.0
        else:
            if self.scale_units == 'xy':
                dx = 1
            else:
                dx = self._dots_per_unit(self.scale_units)
            widthu_per_lenu = dx / self._trans_scale
            if self.scale is None:
                self.scale = scale * widthu_per_lenu
        length = a * (widthu_per_lenu / (self.scale * self.width))
        (X, Y) = self._h_arrows(length)
        if str_angles == 'xy':
            theta = angles
        elif str_angles == 'uv':
            theta = np.angle(uv)
        else:
            theta = ma.masked_invalid(np.deg2rad(angles)).filled(0)
        theta = theta.reshape((-1, 1))
        xy = (X + Y * 1j) * np.exp(1j * theta) * self.width
        XY = np.stack((xy.real, xy.imag), axis=2)
        if self.Umask is not ma.nomask:
            XY = ma.array(XY)
            XY[self.Umask] = ma.masked
        return XY

    def _h_arrows(self, length):
        minsh = self.minshaft * self.headlength
        N = len(length)
        length = length.reshape(N, 1)
        np.clip(length, 0, 2 ** 16, out=length)
        x = np.array([0, -self.headaxislength, -self.headlength, 0], np.float64)
        x = x + np.array([0, 1, 1, 1]) * length
        y = 0.5 * np.array([1, 1, self.headwidth, 0], np.float64)
        y = np.repeat(y[np.newaxis, :], N, axis=0)
        x0 = np.array([0, minsh - self.headaxislength, minsh - self.headlength, minsh], np.float64)
        y0 = 0.5 * np.array([1, 1, self.headwidth, 0], np.float64)
        ii = [0, 1, 2, 3, 2, 1, 0, 0]
        X = x[:, ii]
        Y = y[:, ii]
        Y[:, 3:-1] *= -1
        X0 = x0[ii]
        Y0 = y0[ii]
        Y0[3:-1] *= -1
        shrink = length / minsh if minsh != 0.0 else 0.0
        X0 = shrink * X0[np.newaxis, :]
        Y0 = shrink * Y0[np.newaxis, :]
        short = np.repeat(length < minsh, 8, axis=1)
        np.copyto(X, X0, where=short)
        np.copyto(Y, Y0, where=short)
        if self.pivot == 'middle':
            X -= 0.5 * X[:, 3, np.newaxis]
        elif self.pivot == 'tip':
            X = X - X[:, 3, np.newaxis]
        elif self.pivot != 'tail':
            _api.check_in_list(['middle', 'tip', 'tail'], pivot=self.pivot)
        tooshort = length < self.minlength
        if tooshort.any():
            th = np.arange(0, 8, 1, np.float64) * (np.pi / 3.0)
            x1 = np.cos(th) * self.minlength * 0.5
            y1 = np.sin(th) * self.minlength * 0.5
            X1 = np.repeat(x1[np.newaxis, :], N, axis=0)
            Y1 = np.repeat(y1[np.newaxis, :], N, axis=0)
            tooshort = np.repeat(tooshort, 8, 1)
            np.copyto(X, X1, where=tooshort)
            np.copyto(Y, Y1, where=tooshort)
        return (X, Y)
_barbs_doc = '\nPlot a 2D field of wind barbs.\n\nCall signature::\n\n  barbs([X, Y], U, V, [C], /, **kwargs)\n\nWhere *X*, *Y* define the barb locations, *U*, *V* define the barb\ndirections, and *C* optionally sets the color.\n\nThe arguments *X*, *Y*, *U*, *V*, *C* are positional-only and may be\n1D or 2D. *U*, *V*, *C* may be masked arrays, but masked *X*, *Y*\nare not supported at present.\n\nBarbs are traditionally used in meteorology as a way to plot the speed\nand direction of wind observations, but can technically be used to\nplot any two dimensional vector quantity.  As opposed to arrows, which\ngive vector magnitude by the length of the arrow, the barbs give more\nquantitative information about the vector magnitude by putting slanted\nlines or a triangle for various increments in magnitude, as show\nschematically below::\n\n  :                   /\\    \\\n  :                  /  \\    \\\n  :                 /    \\    \\    \\\n  :                /      \\    \\    \\\n  :               ------------------------------\n\nThe largest increment is given by a triangle (or "flag"). After those\ncome full lines (barbs). The smallest increment is a half line.  There\nis only, of course, ever at most 1 half line.  If the magnitude is\nsmall and only needs a single half-line and no full lines or\ntriangles, the half-line is offset from the end of the barb so that it\ncan be easily distinguished from barbs with a single full line.  The\nmagnitude for the barb shown above would nominally be 65, using the\nstandard increments of 50, 10, and 5.\n\nSee also https://en.wikipedia.org/wiki/Wind_barb.\n\nParameters\n----------\nX, Y : 1D or 2D array-like, optional\n    The x and y coordinates of the barb locations. See *pivot* for how the\n    barbs are drawn to the x, y positions.\n\n    If not given, they will be generated as a uniform integer meshgrid based\n    on the dimensions of *U* and *V*.\n\n    If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n    using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n    must match the column and row dimensions of *U* and *V*.\n\nU, V : 1D or 2D array-like\n    The x and y components of the barb shaft.\n\nC : 1D or 2D array-like, optional\n    Numeric data that defines the barb colors by colormapping via *norm* and\n    *cmap*.\n\n    This does not support explicit colors. If you want to set colors directly,\n    use *barbcolor* instead.\n\nlength : float, default: 7\n    Length of the barb in points; the other parts of the barb\n    are scaled against this.\n\npivot : {\'tip\', \'middle\'} or float, default: \'tip\'\n    The part of the arrow that is anchored to the *X*, *Y* grid. The barb\n    rotates about this point. This can also be a number, which shifts the\n    start of the barb that many points away from grid point.\n\nbarbcolor : :mpltype:`color` or color sequence\n    The color of all parts of the barb except for the flags.  This parameter\n    is analogous to the *edgecolor* parameter for polygons, which can be used\n    instead. However this parameter will override facecolor.\n\nflagcolor : :mpltype:`color` or color sequence\n    The color of any flags on the barb.  This parameter is analogous to the\n    *facecolor* parameter for polygons, which can be used instead. However,\n    this parameter will override facecolor.  If this is not set (and *C* has\n    not either) then *flagcolor* will be set to match *barbcolor* so that the\n    barb has a uniform color. If *C* has been set, *flagcolor* has no effect.\n\nsizes : dict, optional\n    A dictionary of coefficients specifying the ratio of a given\n    feature to the length of the barb. Only those values one wishes to\n    override need to be included.  These features include:\n\n    - \'spacing\' - space between features (flags, full/half barbs)\n    - \'height\' - height (distance from shaft to top) of a flag or full barb\n    - \'width\' - width of a flag, twice the width of a full barb\n    - \'emptybarb\' - radius of the circle used for low magnitudes\n\nfill_empty : bool, default: False\n    Whether the empty barbs (circles) that are drawn should be filled with\n    the flag color.  If they are not filled, the center is transparent.\n\nrounding : bool, default: True\n    Whether the vector magnitude should be rounded when allocating barb\n    components.  If True, the magnitude is rounded to the nearest multiple\n    of the half-barb increment.  If False, the magnitude is simply truncated\n    to the next lowest multiple.\n\nbarb_increments : dict, optional\n    A dictionary of increments specifying values to associate with\n    different parts of the barb. Only those values one wishes to\n    override need to be included.\n\n    - \'half\' - half barbs (Default is 5)\n    - \'full\' - full barbs (Default is 10)\n    - \'flag\' - flags (default is 50)\n\nflip_barb : bool or array-like of bool, default: False\n    Whether the lines and flags should point opposite to normal.\n    Normal behavior is for the barbs and lines to point right (comes from wind\n    barbs having these features point towards low pressure in the Northern\n    Hemisphere).\n\n    A single value is applied to all barbs. Individual barbs can be flipped by\n    passing a bool array of the same size as *U* and *V*.\n\nReturns\n-------\nbarbs : `~matplotlib.quiver.Barbs`\n\nOther Parameters\n----------------\ndata : indexable object, optional\n    DATA_PARAMETER_PLACEHOLDER\n\n**kwargs\n    The barbs can further be customized using `.PolyCollection` keyword\n    arguments:\n\n    %(PolyCollection:kwdoc)s\n' % _docstring.interpd.params
_docstring.interpd.update(barbs_doc=_barbs_doc)

class Barbs(mcollections.PolyCollection):

    @_docstring.interpd
    def __init__(self, ax, *args, pivot='tip', length=7, barbcolor=None, flagcolor=None, sizes=None, fill_empty=False, barb_increments=None, rounding=True, flip_barb=False, **kwargs):
        self.sizes = sizes or dict()
        self.fill_empty = fill_empty
        self.barb_increments = barb_increments or dict()
        self.rounding = rounding
        self.flip = np.atleast_1d(flip_barb)
        transform = kwargs.pop('transform', ax.transData)
        self._pivot = pivot
        self._length = length
        if None in (barbcolor, flagcolor):
            kwargs['edgecolors'] = 'face'
            if flagcolor:
                kwargs['facecolors'] = flagcolor
            elif barbcolor:
                kwargs['facecolors'] = barbcolor
            else:
                kwargs.setdefault('facecolors', 'k')
        else:
            kwargs['edgecolors'] = barbcolor
            kwargs['facecolors'] = flagcolor
        if 'linewidth' not in kwargs and 'lw' not in kwargs:
            kwargs['linewidth'] = 1
        (x, y, u, v, c) = _parse_args(*args, caller_name='barbs')
        self.x = x
        self.y = y
        xy = np.column_stack((x, y))
        barb_size = self._length ** 2 / 4
        super().__init__([], (barb_size,), offsets=xy, offset_transform=transform, **kwargs)
        self.set_transform(transforms.IdentityTransform())
        self.set_UVC(u, v, c)

    def _find_tails(self, mag, rounding=True, half=5, full=10, flag=50):
        if rounding:
            mag = half * np.around(mag / half)
        (n_flags, mag) = divmod(mag, flag)
        (n_barb, mag) = divmod(mag, full)
        half_flag = mag >= half
        empty_flag = ~(half_flag | (n_flags > 0) | (n_barb > 0))
        return (n_flags.astype(int), n_barb.astype(int), half_flag, empty_flag)

    def _make_barbs(self, u, v, nflags, nbarbs, half_barb, empty_flag, length, pivot, sizes, fill_empty, flip):
        spacing = length * sizes.get('spacing', 0.125)
        full_height = length * sizes.get('height', 0.4)
        full_width = length * sizes.get('width', 0.25)
        empty_rad = length * sizes.get('emptybarb', 0.15)
        pivot_points = dict(tip=0.0, middle=-length / 2.0)
        endx = 0.0
        try:
            endy = float(pivot)
        except ValueError:
            endy = pivot_points[pivot.lower()]
        angles = -(ma.arctan2(v, u) + np.pi / 2)
        circ = CirclePolygon((0, 0), radius=empty_rad).get_verts()
        if fill_empty:
            empty_barb = circ
        else:
            empty_barb = np.concatenate((circ, circ[::-1]))
        barb_list = []
        for (index, angle) in np.ndenumerate(angles):
            if empty_flag[index]:
                barb_list.append(empty_barb)
                continue
            poly_verts = [(endx, endy)]
            offset = length
            barb_height = -full_height if flip[index] else full_height
            for i in range(nflags[index]):
                if offset != length:
                    offset += spacing / 2.0
                poly_verts.extend([[endx, endy + offset], [endx + barb_height, endy - full_width / 2 + offset], [endx, endy - full_width + offset]])
                offset -= full_width + spacing
            for i in range(nbarbs[index]):
                poly_verts.extend([(endx, endy + offset), (endx + barb_height, endy + offset + full_width / 2), (endx, endy + offset)])
                offset -= spacing
            if half_barb[index]:
                if offset == length:
                    poly_verts.append((endx, endy + offset))
                    offset -= 1.5 * spacing
                poly_verts.extend([(endx, endy + offset), (endx + barb_height / 2, endy + offset + full_width / 4), (endx, endy + offset)])
            poly_verts = transforms.Affine2D().rotate(-angle).transform(poly_verts)
            barb_list.append(poly_verts)
        return barb_list

    def set_UVC(self, U, V, C=None):
        self.u = ma.masked_invalid(U, copy=True).ravel()
        self.v = ma.masked_invalid(V, copy=True).ravel()
        if len(self.flip) == 1:
            flip = np.broadcast_to(self.flip, self.u.shape)
        else:
            flip = self.flip
        if C is not None:
            c = ma.masked_invalid(C, copy=True).ravel()
            (x, y, u, v, c, flip) = cbook.delete_masked_points(self.x.ravel(), self.y.ravel(), self.u, self.v, c, flip.ravel())
            _check_consistent_shapes(x, y, u, v, c, flip)
        else:
            (x, y, u, v, flip) = cbook.delete_masked_points(self.x.ravel(), self.y.ravel(), self.u, self.v, flip.ravel())
            _check_consistent_shapes(x, y, u, v, flip)
        magnitude = np.hypot(u, v)
        (flags, barbs, halves, empty) = self._find_tails(magnitude, self.rounding, **self.barb_increments)
        plot_barbs = self._make_barbs(u, v, flags, barbs, halves, empty, self._length, self._pivot, self.sizes, self.fill_empty, flip)
        self.set_verts(plot_barbs)
        if C is not None:
            self.set_array(c)
        xy = np.column_stack((x, y))
        self._offsets = xy
        self.stale = True

    def set_offsets(self, xy):
        self.x = xy[:, 0]
        self.y = xy[:, 1]
        (x, y, u, v) = cbook.delete_masked_points(self.x.ravel(), self.y.ravel(), self.u, self.v)
        _check_consistent_shapes(x, y, u, v)
        xy = np.column_stack((x, y))
        super().set_offsets(xy)
        self.stale = True

# File: matplotlib-main/lib/matplotlib/sankey.py
""""""
import logging
from types import SimpleNamespace
import numpy as np
import matplotlib as mpl
from matplotlib.path import Path
from matplotlib.patches import PathPatch
from matplotlib.transforms import Affine2D
from matplotlib import _docstring
_log = logging.getLogger(__name__)
__author__ = 'Kevin L. Davies'
__credits__ = ['Yannick Copin']
__license__ = 'BSD'
__version__ = '2011/09/16'
RIGHT = 0
UP = 1
DOWN = 3

class Sankey:

    def __init__(self, ax=None, scale=1.0, unit='', format='%G', gap=0.25, radius=0.1, shoulder=0.03, offset=0.15, head_angle=100, margin=0.4, tolerance=1e-06, **kwargs):
        if gap < 0:
            raise ValueError("'gap' is negative, which is not allowed because it would cause the paths to overlap")
        if radius > gap:
            raise ValueError("'radius' is greater than 'gap', which is not allowed because it would cause the paths to overlap")
        if head_angle < 0:
            raise ValueError("'head_angle' is negative, which is not allowed because it would cause inputs to look like outputs and vice versa")
        if tolerance < 0:
            raise ValueError("'tolerance' is negative, but it must be a magnitude")
        if ax is None:
            import matplotlib.pyplot as plt
            fig = plt.figure()
            ax = fig.add_subplot(1, 1, 1, xticks=[], yticks=[])
        self.diagrams = []
        self.ax = ax
        self.unit = unit
        self.format = format
        self.scale = scale
        self.gap = gap
        self.radius = radius
        self.shoulder = shoulder
        self.offset = offset
        self.margin = margin
        self.pitch = np.tan(np.pi * (1 - head_angle / 180.0) / 2.0)
        self.tolerance = tolerance
        self.extent = np.array((np.inf, -np.inf, np.inf, -np.inf))
        if len(kwargs):
            self.add(**kwargs)

    def _arc(self, quadrant=0, cw=True, radius=1, center=(0, 0)):
        ARC_CODES = [Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4]
        ARC_VERTICES = np.array([[1.0, 0.0], [1.0, 0.265114773], [0.894571235, 0.519642327], [0.707106781, 0.707106781], [0.519642327, 0.894571235], [0.265114773, 1.0], [0.0, 1.0]])
        if quadrant in (0, 2):
            if cw:
                vertices = ARC_VERTICES
            else:
                vertices = ARC_VERTICES[:, ::-1]
        elif cw:
            vertices = np.column_stack((-ARC_VERTICES[:, 1], ARC_VERTICES[:, 0]))
        else:
            vertices = np.column_stack((-ARC_VERTICES[:, 0], ARC_VERTICES[:, 1]))
        if quadrant > 1:
            radius = -radius
        return list(zip(ARC_CODES, radius * vertices + np.tile(center, (ARC_VERTICES.shape[0], 1))))

    def _add_input(self, path, angle, flow, length):
        if angle is None:
            return ([0, 0], [0, 0])
        else:
            (x, y) = path[-1][1]
            dipdepth = flow / 2 * self.pitch
            if angle == RIGHT:
                x -= length
                dip = [x + dipdepth, y + flow / 2.0]
                path.extend([(Path.LINETO, [x, y]), (Path.LINETO, dip), (Path.LINETO, [x, y + flow]), (Path.LINETO, [x + self.gap, y + flow])])
                label_location = [dip[0] - self.offset, dip[1]]
            else:
                x -= self.gap
                if angle == UP:
                    sign = 1
                else:
                    sign = -1
                dip = [x - flow / 2, y - sign * (length - dipdepth)]
                if angle == DOWN:
                    quadrant = 2
                else:
                    quadrant = 1
                if self.radius:
                    path.extend(self._arc(quadrant=quadrant, cw=angle == UP, radius=self.radius, center=(x + self.radius, y - sign * self.radius)))
                else:
                    path.append((Path.LINETO, [x, y]))
                path.extend([(Path.LINETO, [x, y - sign * length]), (Path.LINETO, dip), (Path.LINETO, [x - flow, y - sign * length])])
                path.extend(self._arc(quadrant=quadrant, cw=angle == DOWN, radius=flow + self.radius, center=(x + self.radius, y - sign * self.radius)))
                path.append((Path.LINETO, [x - flow, y + sign * flow]))
                label_location = [dip[0], dip[1] - sign * self.offset]
            return (dip, label_location)

    def _add_output(self, path, angle, flow, length):
        if angle is None:
            return ([0, 0], [0, 0])
        else:
            (x, y) = path[-1][1]
            tipheight = (self.shoulder - flow / 2) * self.pitch
            if angle == RIGHT:
                x += length
                tip = [x + tipheight, y + flow / 2.0]
                path.extend([(Path.LINETO, [x, y]), (Path.LINETO, [x, y + self.shoulder]), (Path.LINETO, tip), (Path.LINETO, [x, y - self.shoulder + flow]), (Path.LINETO, [x, y + flow]), (Path.LINETO, [x - self.gap, y + flow])])
                label_location = [tip[0] + self.offset, tip[1]]
            else:
                x += self.gap
                if angle == UP:
                    (sign, quadrant) = (1, 3)
                else:
                    (sign, quadrant) = (-1, 0)
                tip = [x - flow / 2.0, y + sign * (length + tipheight)]
                if self.radius:
                    path.extend(self._arc(quadrant=quadrant, cw=angle == UP, radius=self.radius, center=(x - self.radius, y + sign * self.radius)))
                else:
                    path.append((Path.LINETO, [x, y]))
                path.extend([(Path.LINETO, [x, y + sign * length]), (Path.LINETO, [x - self.shoulder, y + sign * length]), (Path.LINETO, tip), (Path.LINETO, [x + self.shoulder - flow, y + sign * length]), (Path.LINETO, [x - flow, y + sign * length])])
                path.extend(self._arc(quadrant=quadrant, cw=angle == DOWN, radius=self.radius - flow, center=(x - self.radius, y + sign * self.radius)))
                path.append((Path.LINETO, [x - flow, y + sign * flow]))
                label_location = [tip[0], tip[1] + sign * self.offset]
            return (tip, label_location)

    def _revert(self, path, first_action=Path.LINETO):
        reverse_path = []
        next_code = first_action
        for (code, position) in path[::-1]:
            reverse_path.append((next_code, position))
            next_code = code
        return reverse_path

    @_docstring.dedent_interpd
    def add(self, patchlabel='', flows=None, orientations=None, labels='', trunklength=1.0, pathlengths=0.25, prior=None, connect=(0, 0), rotation=0, **kwargs):
        flows = np.array([1.0, -1.0]) if flows is None else np.array(flows)
        n = flows.shape[0]
        if rotation is None:
            rotation = 0
        else:
            rotation /= 90.0
        if orientations is None:
            orientations = 0
        try:
            orientations = np.broadcast_to(orientations, n)
        except ValueError:
            raise ValueError(f"The shapes of 'flows' {np.shape(flows)} and 'orientations' {np.shape(orientations)} are incompatible") from None
        try:
            labels = np.broadcast_to(labels, n)
        except ValueError:
            raise ValueError(f"The shapes of 'flows' {np.shape(flows)} and 'labels' {np.shape(labels)} are incompatible") from None
        if trunklength < 0:
            raise ValueError("'trunklength' is negative, which is not allowed because it would cause poor layout")
        if abs(np.sum(flows)) > self.tolerance:
            _log.info('The sum of the flows is nonzero (%f; patchlabel=%r); is the system not at steady state?', np.sum(flows), patchlabel)
        scaled_flows = self.scale * flows
        gain = sum((max(flow, 0) for flow in scaled_flows))
        loss = sum((min(flow, 0) for flow in scaled_flows))
        if prior is not None:
            if prior < 0:
                raise ValueError('The index of the prior diagram is negative')
            if min(connect) < 0:
                raise ValueError('At least one of the connection indices is negative')
            if prior >= len(self.diagrams):
                raise ValueError(f'The index of the prior diagram is {prior}, but there are only {len(self.diagrams)} other diagrams')
            if connect[0] >= len(self.diagrams[prior].flows):
                raise ValueError('The connection index to the source diagram is {}, but that diagram has only {} flows'.format(connect[0], len(self.diagrams[prior].flows)))
            if connect[1] >= n:
                raise ValueError(f'The connection index to this diagram is {connect[1]}, but this diagram has only {n} flows')
            if self.diagrams[prior].angles[connect[0]] is None:
                raise ValueError(f'The connection cannot be made, which may occur if the magnitude of flow {connect[0]} of diagram {prior} is less than the specified tolerance')
            flow_error = self.diagrams[prior].flows[connect[0]] + flows[connect[1]]
            if abs(flow_error) >= self.tolerance:
                raise ValueError(f'The scaled sum of the connected flows is {flow_error}, which is not within the tolerance ({self.tolerance})')
        are_inputs = [None] * n
        for (i, flow) in enumerate(flows):
            if flow >= self.tolerance:
                are_inputs[i] = True
            elif flow <= -self.tolerance:
                are_inputs[i] = False
            else:
                _log.info('The magnitude of flow %d (%f) is below the tolerance (%f).\nIt will not be shown, and it cannot be used in a connection.', i, flow, self.tolerance)
        angles = [None] * n
        for (i, (orient, is_input)) in enumerate(zip(orientations, are_inputs)):
            if orient == 1:
                if is_input:
                    angles[i] = DOWN
                elif is_input is False:
                    angles[i] = UP
            elif orient == 0:
                if is_input is not None:
                    angles[i] = RIGHT
            else:
                if orient != -1:
                    raise ValueError(f'The value of orientations[{i}] is {orient}, but it must be -1, 0, or 1')
                if is_input:
                    angles[i] = UP
                elif is_input is False:
                    angles[i] = DOWN
        if np.iterable(pathlengths):
            if len(pathlengths) != n:
                raise ValueError(f"The lengths of 'flows' ({n}) and 'pathlengths' ({len(pathlengths)}) are incompatible")
        else:
            urlength = pathlengths
            ullength = pathlengths
            lrlength = pathlengths
            lllength = pathlengths
            d = dict(RIGHT=pathlengths)
            pathlengths = [d.get(angle, 0) for angle in angles]
            for (i, (angle, is_input, flow)) in enumerate(zip(angles, are_inputs, scaled_flows)):
                if angle == DOWN and is_input:
                    pathlengths[i] = ullength
                    ullength += flow
                elif angle == UP and is_input is False:
                    pathlengths[i] = urlength
                    urlength -= flow
            for (i, (angle, is_input, flow)) in enumerate(reversed(list(zip(angles, are_inputs, scaled_flows)))):
                if angle == UP and is_input:
                    pathlengths[n - i - 1] = lllength
                    lllength += flow
                elif angle == DOWN and is_input is False:
                    pathlengths[n - i - 1] = lrlength
                    lrlength -= flow
            has_left_input = False
            for (i, (angle, is_input, spec)) in enumerate(reversed(list(zip(angles, are_inputs, zip(scaled_flows, pathlengths))))):
                if angle == RIGHT:
                    if is_input:
                        if has_left_input:
                            pathlengths[n - i - 1] = 0
                        else:
                            has_left_input = True
            has_right_output = False
            for (i, (angle, is_input, spec)) in enumerate(zip(angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
                if angle == RIGHT:
                    if is_input is False:
                        if has_right_output:
                            pathlengths[i] = 0
                        else:
                            has_right_output = True
        urpath = [(Path.MOVETO, [self.gap - trunklength / 2.0, gain / 2.0]), (Path.LINETO, [(self.gap - trunklength / 2.0) / 2.0, gain / 2.0]), (Path.CURVE4, [(self.gap - trunklength / 2.0) / 8.0, gain / 2.0]), (Path.CURVE4, [(trunklength / 2.0 - self.gap) / 8.0, -loss / 2.0]), (Path.LINETO, [(trunklength / 2.0 - self.gap) / 2.0, -loss / 2.0]), (Path.LINETO, [trunklength / 2.0 - self.gap, -loss / 2.0])]
        llpath = [(Path.LINETO, [trunklength / 2.0 - self.gap, loss / 2.0]), (Path.LINETO, [(trunklength / 2.0 - self.gap) / 2.0, loss / 2.0]), (Path.CURVE4, [(trunklength / 2.0 - self.gap) / 8.0, loss / 2.0]), (Path.CURVE4, [(self.gap - trunklength / 2.0) / 8.0, -gain / 2.0]), (Path.LINETO, [(self.gap - trunklength / 2.0) / 2.0, -gain / 2.0]), (Path.LINETO, [self.gap - trunklength / 2.0, -gain / 2.0])]
        lrpath = [(Path.LINETO, [trunklength / 2.0 - self.gap, loss / 2.0])]
        ulpath = [(Path.LINETO, [self.gap - trunklength / 2.0, gain / 2.0])]
        tips = np.zeros((n, 2))
        label_locations = np.zeros((n, 2))
        for (i, (angle, is_input, spec)) in enumerate(zip(angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
            if angle == DOWN and is_input:
                (tips[i, :], label_locations[i, :]) = self._add_input(ulpath, angle, *spec)
            elif angle == UP and is_input is False:
                (tips[i, :], label_locations[i, :]) = self._add_output(urpath, angle, *spec)
        for (i, (angle, is_input, spec)) in enumerate(reversed(list(zip(angles, are_inputs, list(zip(scaled_flows, pathlengths)))))):
            if angle == UP and is_input:
                (tip, label_location) = self._add_input(llpath, angle, *spec)
                tips[n - i - 1, :] = tip
                label_locations[n - i - 1, :] = label_location
            elif angle == DOWN and is_input is False:
                (tip, label_location) = self._add_output(lrpath, angle, *spec)
                tips[n - i - 1, :] = tip
                label_locations[n - i - 1, :] = label_location
        has_left_input = False
        for (i, (angle, is_input, spec)) in enumerate(reversed(list(zip(angles, are_inputs, list(zip(scaled_flows, pathlengths)))))):
            if angle == RIGHT and is_input:
                if not has_left_input:
                    if llpath[-1][1][0] > ulpath[-1][1][0]:
                        llpath.append((Path.LINETO, [ulpath[-1][1][0], llpath[-1][1][1]]))
                    has_left_input = True
                (tip, label_location) = self._add_input(llpath, angle, *spec)
                tips[n - i - 1, :] = tip
                label_locations[n - i - 1, :] = label_location
        has_right_output = False
        for (i, (angle, is_input, spec)) in enumerate(zip(angles, are_inputs, list(zip(scaled_flows, pathlengths)))):
            if angle == RIGHT and is_input is False:
                if not has_right_output:
                    if urpath[-1][1][0] < lrpath[-1][1][0]:
                        urpath.append((Path.LINETO, [lrpath[-1][1][0], urpath[-1][1][1]]))
                    has_right_output = True
                (tips[i, :], label_locations[i, :]) = self._add_output(urpath, angle, *spec)
        if not has_left_input:
            ulpath.pop()
            llpath.pop()
        if not has_right_output:
            lrpath.pop()
            urpath.pop()
        path = urpath + self._revert(lrpath) + llpath + self._revert(ulpath) + [(Path.CLOSEPOLY, urpath[0][1])]
        (codes, vertices) = zip(*path)
        vertices = np.array(vertices)

        def _get_angle(a, r):
            if a is None:
                return None
            else:
                return a + r
        if prior is None:
            if rotation != 0:
                angles = [_get_angle(angle, rotation) for angle in angles]
                rotate = Affine2D().rotate_deg(rotation * 90).transform_affine
                tips = rotate(tips)
                label_locations = rotate(label_locations)
                vertices = rotate(vertices)
            text = self.ax.text(0, 0, s=patchlabel, ha='center', va='center')
        else:
            rotation = self.diagrams[prior].angles[connect[0]] - angles[connect[1]]
            angles = [_get_angle(angle, rotation) for angle in angles]
            rotate = Affine2D().rotate_deg(rotation * 90).transform_affine
            tips = rotate(tips)
            offset = self.diagrams[prior].tips[connect[0]] - tips[connect[1]]
            translate = Affine2D().translate(*offset).transform_affine
            tips = translate(tips)
            label_locations = translate(rotate(label_locations))
            vertices = translate(rotate(vertices))
            kwds = dict(s=patchlabel, ha='center', va='center')
            text = self.ax.text(*offset, **kwds)
        if mpl.rcParams['_internal.classic_mode']:
            fc = kwargs.pop('fc', kwargs.pop('facecolor', '#bfd1d4'))
            lw = kwargs.pop('lw', kwargs.pop('linewidth', 0.5))
        else:
            fc = kwargs.pop('fc', kwargs.pop('facecolor', None))
            lw = kwargs.pop('lw', kwargs.pop('linewidth', None))
        if fc is None:
            fc = self.ax._get_patches_for_fill.get_next_color()
        patch = PathPatch(Path(vertices, codes), fc=fc, lw=lw, **kwargs)
        self.ax.add_patch(patch)
        texts = []
        for (number, angle, label, location) in zip(flows, angles, labels, label_locations):
            if label is None or angle is None:
                label = ''
            elif self.unit is not None:
                if isinstance(self.format, str):
                    quantity = self.format % abs(number) + self.unit
                elif callable(self.format):
                    quantity = self.format(number)
                else:
                    raise TypeError('format must be callable or a format string')
                if label != '':
                    label += '\n'
                label += quantity
            texts.append(self.ax.text(x=location[0], y=location[1], s=label, ha='center', va='center'))
        self.extent = (min(np.min(vertices[:, 0]), np.min(label_locations[:, 0]), self.extent[0]), max(np.max(vertices[:, 0]), np.max(label_locations[:, 0]), self.extent[1]), min(np.min(vertices[:, 1]), np.min(label_locations[:, 1]), self.extent[2]), max(np.max(vertices[:, 1]), np.max(label_locations[:, 1]), self.extent[3]))
        self.diagrams.append(SimpleNamespace(patch=patch, flows=flows, angles=angles, tips=tips, text=text, texts=texts))
        return self

    def finish(self):
        self.ax.axis([self.extent[0] - self.margin, self.extent[1] + self.margin, self.extent[2] - self.margin, self.extent[3] + self.margin])
        self.ax.set_aspect('equal', adjustable='datalim')
        return self.diagrams

# File: matplotlib-main/lib/matplotlib/scale.py
""""""
import inspect
import textwrap
import numpy as np
import matplotlib as mpl
from matplotlib import _api, _docstring
from matplotlib.ticker import NullFormatter, ScalarFormatter, LogFormatterSciNotation, LogitFormatter, NullLocator, LogLocator, AutoLocator, AutoMinorLocator, SymmetricalLogLocator, AsinhLocator, LogitLocator
from matplotlib.transforms import Transform, IdentityTransform

class ScaleBase:

    def __init__(self, axis):

    def get_transform(self):
        raise NotImplementedError()

    def set_default_locators_and_formatters(self, axis):
        raise NotImplementedError()

    def limit_range_for_scale(self, vmin, vmax, minpos):
        return (vmin, vmax)

class LinearScale(ScaleBase):
    name = 'linear'

    def __init__(self, axis):

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(AutoLocator())
        axis.set_major_formatter(ScalarFormatter())
        axis.set_minor_formatter(NullFormatter())
        if axis.axis_name == 'x' and mpl.rcParams['xtick.minor.visible'] or (axis.axis_name == 'y' and mpl.rcParams['ytick.minor.visible']):
            axis.set_minor_locator(AutoMinorLocator())
        else:
            axis.set_minor_locator(NullLocator())

    def get_transform(self):
        return IdentityTransform()

class FuncTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, forward, inverse):
        super().__init__()
        if callable(forward) and callable(inverse):
            self._forward = forward
            self._inverse = inverse
        else:
            raise ValueError('arguments to FuncTransform must be functions')

    def transform_non_affine(self, values):
        return self._forward(values)

    def inverted(self):
        return FuncTransform(self._inverse, self._forward)

class FuncScale(ScaleBase):
    name = 'function'

    def __init__(self, axis, functions):
        (forward, inverse) = functions
        transform = FuncTransform(forward, inverse)
        self._transform = transform

    def get_transform(self):
        return self._transform

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(AutoLocator())
        axis.set_major_formatter(ScalarFormatter())
        axis.set_minor_formatter(NullFormatter())
        if axis.axis_name == 'x' and mpl.rcParams['xtick.minor.visible'] or (axis.axis_name == 'y' and mpl.rcParams['ytick.minor.visible']):
            axis.set_minor_locator(AutoMinorLocator())
        else:
            axis.set_minor_locator(NullLocator())

class LogTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, base, nonpositive='clip'):
        super().__init__()
        if base <= 0 or base == 1:
            raise ValueError('The log base cannot be <= 0 or == 1')
        self.base = base
        self._clip = _api.check_getitem({'clip': True, 'mask': False}, nonpositive=nonpositive)

    def __str__(self):
        return '{}(base={}, nonpositive={!r})'.format(type(self).__name__, self.base, 'clip' if self._clip else 'mask')

    def transform_non_affine(self, values):
        with np.errstate(divide='ignore', invalid='ignore'):
            log = {np.e: np.log, 2: np.log2, 10: np.log10}.get(self.base)
            if log:
                out = log(values)
            else:
                out = np.log(values)
                out /= np.log(self.base)
            if self._clip:
                out[values <= 0] = -1000
        return out

    def inverted(self):
        return InvertedLogTransform(self.base)

class InvertedLogTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, base):
        super().__init__()
        self.base = base

    def __str__(self):
        return f'{type(self).__name__}(base={self.base})'

    def transform_non_affine(self, values):
        return np.power(self.base, values)

    def inverted(self):
        return LogTransform(self.base)

class LogScale(ScaleBase):
    name = 'log'

    def __init__(self, axis, *, base=10, subs=None, nonpositive='clip'):
        self._transform = LogTransform(base, nonpositive)
        self.subs = subs
    base = property(lambda self: self._transform.base)

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(LogLocator(self.base))
        axis.set_major_formatter(LogFormatterSciNotation(self.base))
        axis.set_minor_locator(LogLocator(self.base, self.subs))
        axis.set_minor_formatter(LogFormatterSciNotation(self.base, labelOnlyBase=self.subs is not None))

    def get_transform(self):
        return self._transform

    def limit_range_for_scale(self, vmin, vmax, minpos):
        if not np.isfinite(minpos):
            minpos = 1e-300
        return (minpos if vmin <= 0 else vmin, minpos if vmax <= 0 else vmax)

class FuncScaleLog(LogScale):
    name = 'functionlog'

    def __init__(self, axis, functions, base=10):
        (forward, inverse) = functions
        self.subs = None
        self._transform = FuncTransform(forward, inverse) + LogTransform(base)

    @property
    def base(self):
        return self._transform._b.base

    def get_transform(self):
        return self._transform

class SymmetricalLogTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, base, linthresh, linscale):
        super().__init__()
        if base <= 1.0:
            raise ValueError("'base' must be larger than 1")
        if linthresh <= 0.0:
            raise ValueError("'linthresh' must be positive")
        if linscale <= 0.0:
            raise ValueError("'linscale' must be positive")
        self.base = base
        self.linthresh = linthresh
        self.linscale = linscale
        self._linscale_adj = linscale / (1.0 - self.base ** (-1))
        self._log_base = np.log(base)

    def transform_non_affine(self, values):
        abs_a = np.abs(values)
        with np.errstate(divide='ignore', invalid='ignore'):
            out = np.sign(values) * self.linthresh * (self._linscale_adj + np.log(abs_a / self.linthresh) / self._log_base)
            inside = abs_a <= self.linthresh
        out[inside] = values[inside] * self._linscale_adj
        return out

    def inverted(self):
        return InvertedSymmetricalLogTransform(self.base, self.linthresh, self.linscale)

class InvertedSymmetricalLogTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, base, linthresh, linscale):
        super().__init__()
        symlog = SymmetricalLogTransform(base, linthresh, linscale)
        self.base = base
        self.linthresh = linthresh
        self.invlinthresh = symlog.transform(linthresh)
        self.linscale = linscale
        self._linscale_adj = linscale / (1.0 - self.base ** (-1))

    def transform_non_affine(self, values):
        abs_a = np.abs(values)
        with np.errstate(divide='ignore', invalid='ignore'):
            out = np.sign(values) * self.linthresh * np.power(self.base, abs_a / self.linthresh - self._linscale_adj)
            inside = abs_a <= self.invlinthresh
        out[inside] = values[inside] / self._linscale_adj
        return out

    def inverted(self):
        return SymmetricalLogTransform(self.base, self.linthresh, self.linscale)

class SymmetricalLogScale(ScaleBase):
    name = 'symlog'

    def __init__(self, axis, *, base=10, linthresh=2, subs=None, linscale=1):
        self._transform = SymmetricalLogTransform(base, linthresh, linscale)
        self.subs = subs
    base = property(lambda self: self._transform.base)
    linthresh = property(lambda self: self._transform.linthresh)
    linscale = property(lambda self: self._transform.linscale)

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(SymmetricalLogLocator(self.get_transform()))
        axis.set_major_formatter(LogFormatterSciNotation(self.base))
        axis.set_minor_locator(SymmetricalLogLocator(self.get_transform(), self.subs))
        axis.set_minor_formatter(NullFormatter())

    def get_transform(self):
        return self._transform

class AsinhTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, linear_width):
        super().__init__()
        if linear_width <= 0.0:
            raise ValueError("Scale parameter 'linear_width' " + 'must be strictly positive')
        self.linear_width = linear_width

    def transform_non_affine(self, values):
        return self.linear_width * np.arcsinh(values / self.linear_width)

    def inverted(self):
        return InvertedAsinhTransform(self.linear_width)

class InvertedAsinhTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, linear_width):
        super().__init__()
        self.linear_width = linear_width

    def transform_non_affine(self, values):
        return self.linear_width * np.sinh(values / self.linear_width)

    def inverted(self):
        return AsinhTransform(self.linear_width)

class AsinhScale(ScaleBase):
    name = 'asinh'
    auto_tick_multipliers = {3: (2,), 4: (2,), 5: (2,), 8: (2, 4), 10: (2, 5), 16: (2, 4, 8), 64: (4, 16), 1024: (256, 512)}

    def __init__(self, axis, *, linear_width=1.0, base=10, subs='auto', **kwargs):
        super().__init__(axis)
        self._transform = AsinhTransform(linear_width)
        self._base = int(base)
        if subs == 'auto':
            self._subs = self.auto_tick_multipliers.get(self._base)
        else:
            self._subs = subs
    linear_width = property(lambda self: self._transform.linear_width)

    def get_transform(self):
        return self._transform

    def set_default_locators_and_formatters(self, axis):
        axis.set(major_locator=AsinhLocator(self.linear_width, base=self._base), minor_locator=AsinhLocator(self.linear_width, base=self._base, subs=self._subs), minor_formatter=NullFormatter())
        if self._base > 1:
            axis.set_major_formatter(LogFormatterSciNotation(self._base))
        else:
            axis.set_major_formatter('{x:.3g}')

class LogitTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, nonpositive='mask'):
        super().__init__()
        _api.check_in_list(['mask', 'clip'], nonpositive=nonpositive)
        self._nonpositive = nonpositive
        self._clip = {'clip': True, 'mask': False}[nonpositive]

    def transform_non_affine(self, values):
        with np.errstate(divide='ignore', invalid='ignore'):
            out = np.log10(values / (1 - values))
        if self._clip:
            out[values <= 0] = -1000
            out[1 <= values] = 1000
        return out

    def inverted(self):
        return LogisticTransform(self._nonpositive)

    def __str__(self):
        return f'{type(self).__name__}({self._nonpositive!r})'

class LogisticTransform(Transform):
    input_dims = output_dims = 1

    def __init__(self, nonpositive='mask'):
        super().__init__()
        self._nonpositive = nonpositive

    def transform_non_affine(self, values):
        return 1.0 / (1 + 10 ** (-values))

    def inverted(self):
        return LogitTransform(self._nonpositive)

    def __str__(self):
        return f'{type(self).__name__}({self._nonpositive!r})'

class LogitScale(ScaleBase):
    name = 'logit'

    def __init__(self, axis, nonpositive='mask', *, one_half='\\frac{1}{2}', use_overline=False):
        self._transform = LogitTransform(nonpositive)
        self._use_overline = use_overline
        self._one_half = one_half

    def get_transform(self):
        return self._transform

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(LogitLocator())
        axis.set_major_formatter(LogitFormatter(one_half=self._one_half, use_overline=self._use_overline))
        axis.set_minor_locator(LogitLocator(minor=True))
        axis.set_minor_formatter(LogitFormatter(minor=True, one_half=self._one_half, use_overline=self._use_overline))

    def limit_range_for_scale(self, vmin, vmax, minpos):
        if not np.isfinite(minpos):
            minpos = 1e-07
        return (minpos if vmin <= 0 else vmin, 1 - minpos if vmax >= 1 else vmax)
_scale_mapping = {'linear': LinearScale, 'log': LogScale, 'symlog': SymmetricalLogScale, 'asinh': AsinhScale, 'logit': LogitScale, 'function': FuncScale, 'functionlog': FuncScaleLog}

def get_scale_names():
    return sorted(_scale_mapping)

def scale_factory(scale, axis, **kwargs):
    scale_cls = _api.check_getitem(_scale_mapping, scale=scale)
    return scale_cls(axis, **kwargs)
if scale_factory.__doc__:
    scale_factory.__doc__ = scale_factory.__doc__ % {'names': ', '.join(map(repr, get_scale_names()))}

def register_scale(scale_class):
    _scale_mapping[scale_class.name] = scale_class

def _get_scale_docs():
    docs = []
    for (name, scale_class) in _scale_mapping.items():
        docstring = inspect.getdoc(scale_class.__init__) or ''
        docs.extend([f'    {name!r}', '', textwrap.indent(docstring, ' ' * 8), ''])
    return '\n'.join(docs)
_docstring.interpd.update(scale_type='{%s}' % ', '.join([repr(x) for x in get_scale_names()]), scale_docs=_get_scale_docs().rstrip())

# File: matplotlib-main/lib/matplotlib/sphinxext/figmpl_directive.py
""""""
from docutils import nodes
from docutils.parsers.rst import directives
from docutils.parsers.rst.directives.images import Figure, Image
import os
from os.path import relpath
from pathlib import PurePath, Path
import shutil
from sphinx.errors import ExtensionError
import matplotlib

class figmplnode(nodes.General, nodes.Element):
    pass

class FigureMpl(Figure):
    has_content = False
    required_arguments = 1
    optional_arguments = 2
    final_argument_whitespace = False
    option_spec = {'alt': directives.unchanged, 'height': directives.length_or_unitless, 'width': directives.length_or_percentage_or_unitless, 'scale': directives.nonnegative_int, 'align': Image.align, 'class': directives.class_option, 'caption': directives.unchanged, 'srcset': directives.unchanged}

    def run(self):
        image_node = figmplnode()
        imagenm = self.arguments[0]
        image_node['alt'] = self.options.get('alt', '')
        image_node['align'] = self.options.get('align', None)
        image_node['class'] = self.options.get('class', None)
        image_node['width'] = self.options.get('width', None)
        image_node['height'] = self.options.get('height', None)
        image_node['scale'] = self.options.get('scale', None)
        image_node['caption'] = self.options.get('caption', None)
        image_node['uri'] = imagenm
        image_node['srcset'] = self.options.get('srcset', None)
        return [image_node]

def _parse_srcsetNodes(st):
    entries = st.split(',')
    srcset = {}
    for entry in entries:
        spl = entry.strip().split(' ')
        if len(spl) == 1:
            srcset[0] = spl[0]
        elif len(spl) == 2:
            mult = spl[1][:-1]
            srcset[float(mult)] = spl[0]
        else:
            raise ExtensionError(f'srcset argument "{entry}" is invalid.')
    return srcset

def _copy_images_figmpl(self, node):
    if node['srcset']:
        srcset = _parse_srcsetNodes(node['srcset'])
    else:
        srcset = None
    docsource = PurePath(self.document['source']).parent
    srctop = self.builder.srcdir
    rel = relpath(docsource, srctop).replace('.', '').replace(os.sep, '-')
    if len(rel):
        rel += '-'
    imagedir = PurePath(self.builder.outdir, self.builder.imagedir)
    Path(imagedir).mkdir(parents=True, exist_ok=True)
    if srcset:
        for src in srcset.values():
            abspath = PurePath(docsource, src)
            name = rel + abspath.name
            shutil.copyfile(abspath, imagedir / name)
    else:
        abspath = PurePath(docsource, node['uri'])
        name = rel + abspath.name
        shutil.copyfile(abspath, imagedir / name)
    return (imagedir, srcset, rel)

def visit_figmpl_html(self, node):
    (imagedir, srcset, rel) = _copy_images_figmpl(self, node)
    docsource = PurePath(self.document['source'])
    srctop = PurePath(self.builder.srcdir, '')
    relsource = relpath(docsource, srctop)
    desttop = PurePath(self.builder.outdir, '')
    dest = desttop / relsource
    imagerel = PurePath(relpath(imagedir, dest.parent)).as_posix()
    if self.builder.name == 'dirhtml':
        imagerel = f'..{imagerel}'
    nm = PurePath(node['uri'][1:]).name
    uri = f'{imagerel}/{rel}{nm}'
    maxsrc = uri
    srcsetst = ''
    if srcset:
        maxmult = -1
        for (mult, src) in srcset.items():
            nm = PurePath(src[1:]).name
            path = f'{imagerel}/{rel}{nm}'
            srcsetst += path
            if mult == 0:
                srcsetst += ', '
            else:
                srcsetst += f' {mult:1.2f}x, '
            if mult > maxmult:
                maxmult = mult
                maxsrc = path
        srcsetst = srcsetst[:-2]
    alt = node['alt']
    if node['class'] is not None:
        classst = ' '.join(node['class'])
        classst = f'class="{classst}"'
    else:
        classst = ''
    stylers = ['width', 'height', 'scale']
    stylest = ''
    for style in stylers:
        if node[style]:
            stylest += f'{style}: {node[style]};'
    figalign = node['align'] if node['align'] else 'center'
    img_block = f'<img src="{uri}" style="{stylest}" srcset="{srcsetst}" alt="{alt}" {classst}/>'
    html_block = f'<figure class="align-{figalign}">\n'
    html_block += f'  <a class="reference internal image-reference" href="{maxsrc}">\n'
    html_block += f'    {img_block}\n  </a>\n'
    if node['caption']:
        html_block += '  <figcaption>\n'
        html_block += f"""   <p><span class="caption-text">{node['caption']}</span></p>\n"""
        html_block += '  </figcaption>\n'
    html_block += '</figure>\n'
    self.body.append(html_block)

def visit_figmpl_latex(self, node):
    if node['srcset'] is not None:
        (imagedir, srcset) = _copy_images_figmpl(self, node)
        maxmult = -1
        maxmult = max(srcset, default=-1)
        node['uri'] = PurePath(srcset[maxmult]).name
    self.visit_figure(node)

def depart_figmpl_html(self, node):
    pass

def depart_figmpl_latex(self, node):
    self.depart_figure(node)

def figurempl_addnode(app):
    app.add_node(figmplnode, html=(visit_figmpl_html, depart_figmpl_html), latex=(visit_figmpl_latex, depart_figmpl_latex))

def setup(app):
    app.add_directive('figure-mpl', FigureMpl)
    figurempl_addnode(app)
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True, 'version': matplotlib.__version__}
    return metadata

# File: matplotlib-main/lib/matplotlib/sphinxext/mathmpl.py
""""""
import hashlib
from pathlib import Path
from docutils import nodes
from docutils.parsers.rst import Directive, directives
import sphinx
from sphinx.errors import ConfigError, ExtensionError
import matplotlib as mpl
from matplotlib import _api, mathtext
from matplotlib.rcsetup import validate_float_or_None

class latex_math(nodes.General, nodes.Element):
    pass

def fontset_choice(arg):
    return directives.choice(arg, mathtext.MathTextParser._font_type_mapping)

def math_role(role, rawtext, text, lineno, inliner, options={}, content=[]):
    i = rawtext.find('`')
    latex = rawtext[i + 1:-1]
    node = latex_math(rawtext)
    node['latex'] = latex
    node['fontset'] = options.get('fontset', 'cm')
    node['fontsize'] = options.get('fontsize', setup.app.config.mathmpl_fontsize)
    return ([node], [])
math_role.options = {'fontset': fontset_choice, 'fontsize': validate_float_or_None}

class MathDirective(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 0
    final_argument_whitespace = False
    option_spec = {'fontset': fontset_choice, 'fontsize': validate_float_or_None}

    def run(self):
        latex = ''.join(self.content)
        node = latex_math(self.block_text)
        node['latex'] = latex
        node['fontset'] = self.options.get('fontset', 'cm')
        node['fontsize'] = self.options.get('fontsize', setup.app.config.mathmpl_fontsize)
        return [node]

def latex2png(latex, filename, fontset='cm', fontsize=10, dpi=100):
    with mpl.rc_context({'mathtext.fontset': fontset, 'font.size': fontsize}):
        try:
            depth = mathtext.math_to_image(f'${latex}$', filename, dpi=dpi, format='png')
        except Exception:
            _api.warn_external(f'Could not render math expression {latex}')
            depth = 0
    return depth

def latex2html(node, source):
    inline = isinstance(node.parent, nodes.TextElement)
    latex = node['latex']
    fontset = node['fontset']
    fontsize = node['fontsize']
    name = 'math-{}'.format(hashlib.md5(f'{latex}{fontset}{fontsize}'.encode()).hexdigest()[-10:])
    destdir = Path(setup.app.builder.outdir, '_images', 'mathmpl')
    destdir.mkdir(parents=True, exist_ok=True)
    dest = destdir / f'{name}.png'
    depth = latex2png(latex, dest, fontset, fontsize=fontsize)
    srcset = []
    for size in setup.app.config.mathmpl_srcset:
        filename = f"{name}-{size.replace('.', '_')}.png"
        latex2png(latex, destdir / filename, fontset, fontsize=fontsize, dpi=100 * float(size[:-1]))
        srcset.append(f'{setup.app.builder.imgpath}/mathmpl/{filename} {size}')
    if srcset:
        srcset = f'srcset="{setup.app.builder.imgpath}/mathmpl/{name}.png, ' + ', '.join(srcset) + '" '
    if inline:
        cls = ''
    else:
        cls = 'class="center" '
    if inline and depth != 0:
        style = 'style="position: relative; bottom: -%dpx"' % (depth + 1)
    else:
        style = ''
    return f'<img src="{setup.app.builder.imgpath}/mathmpl/{name}.png" {srcset}{cls}{style}/>'

def _config_inited(app, config):
    for (i, size) in enumerate(app.config.mathmpl_srcset):
        if size[-1] == 'x':
            try:
                float(size[:-1])
            except ValueError:
                raise ConfigError(f'Invalid value for mathmpl_srcset parameter: {size!r}. Must be a list of strings with the multiplicative factor followed by an "x".  e.g. ["2.0x", "1.5x"]')
        else:
            raise ConfigError(f'Invalid value for mathmpl_srcset parameter: {size!r}. Must be a list of strings with the multiplicative factor followed by an "x".  e.g. ["2.0x", "1.5x"]')

def setup(app):
    setup.app = app
    app.add_config_value('mathmpl_fontsize', 10.0, True)
    app.add_config_value('mathmpl_srcset', [], True)
    try:
        app.connect('config-inited', _config_inited)
    except ExtensionError:
        app.connect('env-updated', lambda app, env: _config_inited(app, None))

    def visit_latex_math_html(self, node):
        source = self.document.attributes['source']
        self.body.append(latex2html(node, source))

    def depart_latex_math_html(self, node):
        pass

    def visit_latex_math_latex(self, node):
        inline = isinstance(node.parent, nodes.TextElement)
        if inline:
            self.body.append('$%s$' % node['latex'])
        else:
            self.body.extend(['\\begin{equation}', node['latex'], '\\end{equation}'])

    def depart_latex_math_latex(self, node):
        pass
    app.add_node(latex_math, html=(visit_latex_math_html, depart_latex_math_html), latex=(visit_latex_math_latex, depart_latex_math_latex))
    app.add_role('mathmpl', math_role)
    app.add_directive('mathmpl', MathDirective)
    if sphinx.version_info < (1, 8):
        app.add_role('math', math_role)
        app.add_directive('math', MathDirective)
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
    return metadata

# File: matplotlib-main/lib/matplotlib/sphinxext/plot_directive.py
""""""
import contextlib
import doctest
from io import StringIO
import itertools
import os
from os.path import relpath
from pathlib import Path
import re
import shutil
import sys
import textwrap
import traceback
from docutils.parsers.rst import directives, Directive
from docutils.parsers.rst.directives.images import Image
import jinja2
from sphinx.errors import ExtensionError
import matplotlib
from matplotlib.backend_bases import FigureManagerBase
import matplotlib.pyplot as plt
from matplotlib import _pylab_helpers, cbook
matplotlib.use('agg')
__version__ = 2

def _option_boolean(arg):
    if not arg or not arg.strip():
        return True
    elif arg.strip().lower() in ('no', '0', 'false'):
        return False
    elif arg.strip().lower() in ('yes', '1', 'true'):
        return True
    else:
        raise ValueError(f'{arg!r} unknown boolean')

def _option_context(arg):
    if arg in [None, 'reset', 'close-figs']:
        return arg
    raise ValueError("Argument should be None or 'reset' or 'close-figs'")

def _option_format(arg):
    return directives.choice(arg, ('python', 'doctest'))

def mark_plot_labels(app, document):
    for (name, explicit) in document.nametypes.items():
        if not explicit:
            continue
        labelid = document.nameids[name]
        if labelid is None:
            continue
        node = document.ids[labelid]
        if node.tagname in ('html_only', 'latex_only'):
            for n in node:
                if n.tagname == 'figure':
                    sectname = name
                    for c in n:
                        if c.tagname == 'caption':
                            sectname = c.astext()
                            break
                    node['ids'].remove(labelid)
                    node['names'].remove(name)
                    n['ids'].append(labelid)
                    n['names'].append(name)
                    document.settings.env.labels[name] = (document.settings.env.docname, labelid, sectname)
                    break

class PlotDirective(Directive):
    has_content = True
    required_arguments = 0
    optional_arguments = 2
    final_argument_whitespace = False
    option_spec = {'alt': directives.unchanged, 'height': directives.length_or_unitless, 'width': directives.length_or_percentage_or_unitless, 'scale': directives.nonnegative_int, 'align': Image.align, 'class': directives.class_option, 'include-source': _option_boolean, 'show-source-link': _option_boolean, 'format': _option_format, 'context': _option_context, 'nofigs': directives.flag, 'caption': directives.unchanged}

    def run(self):
        try:
            return run(self.arguments, self.content, self.options, self.state_machine, self.state, self.lineno)
        except Exception as e:
            raise self.error(str(e))

def _copy_css_file(app, exc):
    if exc is None and app.builder.format == 'html':
        src = cbook._get_data_path('plot_directive/plot_directive.css')
        dst = app.outdir / Path('_static')
        dst.mkdir(exist_ok=True)
        shutil.copyfile(src, dst / Path('plot_directive.css'))

def setup(app):
    setup.app = app
    setup.config = app.config
    setup.confdir = app.confdir
    app.add_directive('plot', PlotDirective)
    app.add_config_value('plot_pre_code', None, True)
    app.add_config_value('plot_include_source', False, True)
    app.add_config_value('plot_html_show_source_link', True, True)
    app.add_config_value('plot_formats', ['png', 'hires.png', 'pdf'], True)
    app.add_config_value('plot_basedir', None, True)
    app.add_config_value('plot_html_show_formats', True, True)
    app.add_config_value('plot_rcparams', {}, True)
    app.add_config_value('plot_apply_rcparams', False, True)
    app.add_config_value('plot_working_directory', None, True)
    app.add_config_value('plot_template', None, True)
    app.add_config_value('plot_srcset', [], True)
    app.connect('doctree-read', mark_plot_labels)
    app.add_css_file('plot_directive.css')
    app.connect('build-finished', _copy_css_file)
    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True, 'version': matplotlib.__version__}
    return metadata

def contains_doctest(text):
    try:
        compile(text, '<string>', 'exec')
        return False
    except SyntaxError:
        pass
    r = re.compile('^\\s*>>>', re.M)
    m = r.search(text)
    return bool(m)

def _split_code_at_show(text, function_name):
    is_doctest = contains_doctest(text)
    if function_name is None:
        parts = []
        part = []
        for line in text.split('\n'):
            if not is_doctest and line.startswith('plt.show(') or (is_doctest and line.strip() == '>>> plt.show()'):
                part.append(line)
                parts.append('\n'.join(part))
                part = []
            else:
                part.append(line)
        if '\n'.join(part).strip():
            parts.append('\n'.join(part))
    else:
        parts = [text]
    return (is_doctest, parts)
_SOURCECODE = '\n{{ source_code }}\n\n.. only:: html\n\n   {% if src_name or (html_show_formats and not multi_image) %}\n   (\n   {%- if src_name -%}\n   :download:`Source code <{{ build_dir }}/{{ src_name }}>`\n   {%- endif -%}\n   {%- if html_show_formats and not multi_image -%}\n     {%- for img in images -%}\n       {%- for fmt in img.formats -%}\n         {%- if src_name or not loop.first -%}, {% endif -%}\n         :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`\n       {%- endfor -%}\n     {%- endfor -%}\n   {%- endif -%}\n   )\n   {% endif %}\n'
TEMPLATE_SRCSET = _SOURCECODE + '\n   {% for img in images %}\n   .. figure-mpl:: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}\n      {% for option in options -%}\n      {{ option }}\n      {% endfor %}\n      {%- if caption -%}\n      {{ caption }}  {# appropriate leading whitespace added beforehand #}\n      {% endif -%}\n      {%- if srcset -%}\n        :srcset: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}\n        {%- for sr in srcset -%}\n            , {{ build_dir }}/{{ img.basename }}.{{ sr }}.{{ default_fmt }} {{sr}}\n        {%- endfor -%}\n      {% endif %}\n\n   {% if html_show_formats and multi_image %}\n   (\n    {%- for fmt in img.formats -%}\n    {%- if not loop.first -%}, {% endif -%}\n    :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`\n    {%- endfor -%}\n   )\n   {% endif %}\n\n\n   {% endfor %}\n\n.. only:: not html\n\n   {% for img in images %}\n   .. figure-mpl:: {{ build_dir }}/{{ img.basename }}.*\n      {% for option in options -%}\n      {{ option }}\n      {% endfor -%}\n\n      {{ caption }}  {# appropriate leading whitespace added beforehand #}\n   {% endfor %}\n\n'
TEMPLATE = _SOURCECODE + '\n\n   {% for img in images %}\n   .. figure:: {{ build_dir }}/{{ img.basename }}.{{ default_fmt }}\n      {% for option in options -%}\n      {{ option }}\n      {% endfor %}\n\n      {% if html_show_formats and multi_image -%}\n        (\n        {%- for fmt in img.formats -%}\n        {%- if not loop.first -%}, {% endif -%}\n        :download:`{{ fmt }} <{{ build_dir }}/{{ img.basename }}.{{ fmt }}>`\n        {%- endfor -%}\n        )\n      {%- endif -%}\n\n      {{ caption }}  {# appropriate leading whitespace added beforehand #}\n   {% endfor %}\n\n.. only:: not html\n\n   {% for img in images %}\n   .. figure:: {{ build_dir }}/{{ img.basename }}.*\n      {% for option in options -%}\n      {{ option }}\n      {% endfor -%}\n\n      {{ caption }}  {# appropriate leading whitespace added beforehand #}\n   {% endfor %}\n\n'
exception_template = '\n.. only:: html\n\n   [`source code <%(linkdir)s/%(basename)s.py>`__]\n\nException occurred rendering plot.\n\n'
plot_context = dict()

class ImageFile:

    def __init__(self, basename, dirname):
        self.basename = basename
        self.dirname = dirname
        self.formats = []

    def filename(self, format):
        return os.path.join(self.dirname, f'{self.basename}.{format}')

    def filenames(self):
        return [self.filename(fmt) for fmt in self.formats]

def out_of_date(original, derived, includes=None):
    if not os.path.exists(derived):
        return True
    if includes is None:
        includes = []
    files_to_check = [original, *includes]

    def out_of_date_one(original, derived_mtime):
        return os.path.exists(original) and derived_mtime < os.stat(original).st_mtime
    derived_mtime = os.stat(derived).st_mtime
    return any((out_of_date_one(f, derived_mtime) for f in files_to_check))

class PlotError(RuntimeError):
    pass

def _run_code(code, code_path, ns=None, function_name=None):
    pwd = os.getcwd()
    if setup.config.plot_working_directory is not None:
        try:
            os.chdir(setup.config.plot_working_directory)
        except OSError as err:
            raise OSError(f'{err}\n`plot_working_directory` option in Sphinx configuration file must be a valid directory path') from err
        except TypeError as err:
            raise TypeError(f'{err}\n`plot_working_directory` option in Sphinx configuration file must be a string or None') from err
    elif code_path is not None:
        dirname = os.path.abspath(os.path.dirname(code_path))
        os.chdir(dirname)
    with cbook._setattr_cm(sys, argv=[code_path], path=[os.getcwd(), *sys.path]), contextlib.redirect_stdout(StringIO()):
        try:
            if ns is None:
                ns = {}
            if not ns:
                if setup.config.plot_pre_code is None:
                    exec('import numpy as np\nfrom matplotlib import pyplot as plt\n', ns)
                else:
                    exec(str(setup.config.plot_pre_code), ns)
            if '__main__' in code:
                ns['__name__'] = '__main__'
            with cbook._setattr_cm(FigureManagerBase, show=lambda self: None):
                exec(code, ns)
                if function_name is not None:
                    exec(function_name + '()', ns)
        except (Exception, SystemExit) as err:
            raise PlotError(traceback.format_exc()) from err
        finally:
            os.chdir(pwd)
    return ns

def clear_state(plot_rcparams, close=True):
    if close:
        plt.close('all')
    matplotlib.rc_file_defaults()
    matplotlib.rcParams.update(plot_rcparams)

def get_plot_formats(config):
    default_dpi = {'png': 80, 'hires.png': 200, 'pdf': 200}
    formats = []
    plot_formats = config.plot_formats
    for fmt in plot_formats:
        if isinstance(fmt, str):
            if ':' in fmt:
                (suffix, dpi) = fmt.split(':')
                formats.append((str(suffix), int(dpi)))
            else:
                formats.append((fmt, default_dpi.get(fmt, 80)))
        elif isinstance(fmt, (tuple, list)) and len(fmt) == 2:
            formats.append((str(fmt[0]), int(fmt[1])))
        else:
            raise PlotError('invalid image format "%r" in plot_formats' % fmt)
    return formats

def _parse_srcset(entries):
    srcset = {}
    for entry in entries:
        entry = entry.strip()
        if len(entry) >= 2:
            mult = entry[:-1]
            srcset[float(mult)] = entry
        else:
            raise ExtensionError(f'srcset argument {entry!r} is invalid.')
    return srcset

def render_figures(code, code_path, output_dir, output_base, context, function_name, config, context_reset=False, close_figs=False, code_includes=None):
    if function_name is not None:
        output_base = f'{output_base}_{function_name}'
    formats = get_plot_formats(config)
    (is_doctest, code_pieces) = _split_code_at_show(code, function_name)
    img = ImageFile(output_base, output_dir)
    for (format, dpi) in formats:
        if context or out_of_date(code_path, img.filename(format), includes=code_includes):
            all_exists = False
            break
        img.formats.append(format)
    else:
        all_exists = True
    if all_exists:
        return [(code, [img])]
    results = []
    for (i, code_piece) in enumerate(code_pieces):
        images = []
        for j in itertools.count():
            if len(code_pieces) > 1:
                img = ImageFile('%s_%02d_%02d' % (output_base, i, j), output_dir)
            else:
                img = ImageFile('%s_%02d' % (output_base, j), output_dir)
            for (fmt, dpi) in formats:
                if context or out_of_date(code_path, img.filename(fmt), includes=code_includes):
                    all_exists = False
                    break
                img.formats.append(fmt)
            if not all_exists:
                all_exists = j > 0
                break
            images.append(img)
        if not all_exists:
            break
        results.append((code_piece, images))
    else:
        all_exists = True
    if all_exists:
        return results
    results = []
    ns = plot_context if context else {}
    if context_reset:
        clear_state(config.plot_rcparams)
        plot_context.clear()
    close_figs = not context or close_figs
    for (i, code_piece) in enumerate(code_pieces):
        if not context or config.plot_apply_rcparams:
            clear_state(config.plot_rcparams, close_figs)
        elif close_figs:
            plt.close('all')
        _run_code(doctest.script_from_examples(code_piece) if is_doctest else code_piece, code_path, ns, function_name)
        images = []
        fig_managers = _pylab_helpers.Gcf.get_all_fig_managers()
        for (j, figman) in enumerate(fig_managers):
            if len(fig_managers) == 1 and len(code_pieces) == 1:
                img = ImageFile(output_base, output_dir)
            elif len(code_pieces) == 1:
                img = ImageFile('%s_%02d' % (output_base, j), output_dir)
            else:
                img = ImageFile('%s_%02d_%02d' % (output_base, i, j), output_dir)
            images.append(img)
            for (fmt, dpi) in formats:
                try:
                    figman.canvas.figure.savefig(img.filename(fmt), dpi=dpi)
                    if fmt == formats[0][0] and config.plot_srcset:
                        srcset = _parse_srcset(config.plot_srcset)
                        for (mult, suffix) in srcset.items():
                            fm = f'{suffix}.{fmt}'
                            img.formats.append(fm)
                            figman.canvas.figure.savefig(img.filename(fm), dpi=int(dpi * mult))
                except Exception as err:
                    raise PlotError(traceback.format_exc()) from err
                img.formats.append(fmt)
        results.append((code_piece, images))
    if not context or config.plot_apply_rcparams:
        clear_state(config.plot_rcparams, close=not context)
    return results

def run(arguments, content, options, state_machine, state, lineno):
    document = state_machine.document
    config = document.settings.env.config
    nofigs = 'nofigs' in options
    if config.plot_srcset and setup.app.builder.name == 'singlehtml':
        raise ExtensionError('plot_srcset option not compatible with single HTML writer')
    formats = get_plot_formats(config)
    default_fmt = formats[0][0]
    options.setdefault('include-source', config.plot_include_source)
    options.setdefault('show-source-link', config.plot_html_show_source_link)
    if 'class' in options:
        options['class'] = ['plot-directive'] + options['class']
    else:
        options.setdefault('class', ['plot-directive'])
    keep_context = 'context' in options
    context_opt = None if not keep_context else options['context']
    rst_file = document.attributes['source']
    rst_dir = os.path.dirname(rst_file)
    if len(arguments):
        if not config.plot_basedir:
            source_file_name = os.path.join(setup.app.builder.srcdir, directives.uri(arguments[0]))
        else:
            source_file_name = os.path.join(setup.confdir, config.plot_basedir, directives.uri(arguments[0]))
        caption = '\n'.join(content)
        if 'caption' in options:
            if caption:
                raise ValueError('Caption specified in both content and options. Please remove ambiguity.')
            caption = options['caption']
        if len(arguments) == 2:
            function_name = arguments[1]
        else:
            function_name = None
        code = Path(source_file_name).read_text(encoding='utf-8')
        output_base = os.path.basename(source_file_name)
    else:
        source_file_name = rst_file
        code = textwrap.dedent('\n'.join(map(str, content)))
        counter = document.attributes.get('_plot_counter', 0) + 1
        document.attributes['_plot_counter'] = counter
        (base, ext) = os.path.splitext(os.path.basename(source_file_name))
        output_base = '%s-%d.py' % (base, counter)
        function_name = None
        caption = options.get('caption', '')
    (base, source_ext) = os.path.splitext(output_base)
    if source_ext in ('.py', '.rst', '.txt'):
        output_base = base
    else:
        source_ext = ''
    output_base = output_base.replace('.', '-')
    is_doctest = contains_doctest(code)
    if 'format' in options:
        if options['format'] == 'python':
            is_doctest = False
        else:
            is_doctest = True
    source_rel_name = relpath(source_file_name, setup.confdir)
    source_rel_dir = os.path.dirname(source_rel_name).lstrip(os.path.sep)
    build_dir = os.path.join(os.path.dirname(setup.app.doctreedir), 'plot_directive', source_rel_dir)
    build_dir = os.path.normpath(build_dir)
    os.makedirs(build_dir, exist_ok=True)
    try:
        build_dir_link = relpath(build_dir, rst_dir).replace(os.path.sep, '/')
    except ValueError:
        build_dir_link = build_dir
    try:
        source_file_includes = [os.path.join(os.getcwd(), t[0]) for t in state.document.include_log]
    except AttributeError:
        possible_sources = {os.path.join(setup.confdir, t[0]) for t in state_machine.input_lines.items}
        source_file_includes = [f for f in possible_sources if os.path.isfile(f)]
    try:
        source_file_includes.remove(source_file_name)
    except ValueError:
        pass
    if options['show-source-link']:
        Path(build_dir, output_base + source_ext).write_text(doctest.script_from_examples(code) if source_file_name == rst_file and is_doctest else code, encoding='utf-8')
    try:
        results = render_figures(code=code, code_path=source_file_name, output_dir=build_dir, output_base=output_base, context=keep_context, function_name=function_name, config=config, context_reset=context_opt == 'reset', close_figs=context_opt == 'close-figs', code_includes=source_file_includes)
        errors = []
    except PlotError as err:
        reporter = state.memo.reporter
        sm = reporter.system_message(2, 'Exception occurred in plotting {}\n from {}:\n{}'.format(output_base, source_file_name, err), line=lineno)
        results = [(code, [])]
        errors = [sm]
    if caption and config.plot_srcset:
        caption = f':caption: {caption}'
    elif caption:
        caption = '\n' + '\n'.join(('      ' + line.strip() for line in caption.split('\n')))
    total_lines = []
    for (j, (code_piece, images)) in enumerate(results):
        if options['include-source']:
            if is_doctest:
                lines = ['', *code_piece.splitlines()]
            else:
                lines = ['.. code-block:: python', '', *textwrap.indent(code_piece, '    ').splitlines()]
            source_code = '\n'.join(lines)
        else:
            source_code = ''
        if nofigs:
            images = []
        opts = [f':{key}: {val}' for (key, val) in options.items() if key in ('alt', 'height', 'width', 'scale', 'align', 'class')]
        if j == 0 and options['show-source-link']:
            src_name = output_base + source_ext
        else:
            src_name = None
        if config.plot_srcset:
            srcset = [*_parse_srcset(config.plot_srcset).values()]
            template = TEMPLATE_SRCSET
        else:
            srcset = None
            template = TEMPLATE
        result = jinja2.Template(config.plot_template or template).render(default_fmt=default_fmt, build_dir=build_dir_link, src_name=src_name, multi_image=len(images) > 1, options=opts, srcset=srcset, images=images, source_code=source_code, html_show_formats=config.plot_html_show_formats and len(images), caption=caption)
        total_lines.extend(result.split('\n'))
        total_lines.extend('\n')
    if total_lines:
        state_machine.insert_input(total_lines, source=source_file_name)
    return errors

# File: matplotlib-main/lib/matplotlib/sphinxext/roles.py
""""""
from urllib.parse import urlsplit, urlunsplit
from docutils import nodes
import matplotlib
from matplotlib import rcParamsDefault

class _QueryReference(nodes.Inline, nodes.TextElement):

    def to_query_string(self):
        return '&'.join((f'{name}={value}' for (name, value) in self.attlist()))

def _visit_query_reference_node(self, node):
    query = node.to_query_string()
    for refnode in node.findall(nodes.reference):
        uri = urlsplit(refnode['refuri'])._replace(query=query)
        refnode['refuri'] = urlunsplit(uri)
    self.visit_literal(node)

def _depart_query_reference_node(self, node):
    self.depart_literal(node)

def _rcparam_role(name, rawtext, text, lineno, inliner, options=None, content=None):
    title = f'rcParams["{text}"]'
    target = 'matplotlibrc-sample'
    (ref_nodes, messages) = inliner.interpreted(title, f'{title} <{target}>', 'ref', lineno)
    qr = _QueryReference(rawtext, highlight=text)
    qr += ref_nodes
    node_list = [qr]
    if text in rcParamsDefault and text != 'backend':
        node_list.extend([nodes.Text(' (default: '), nodes.literal('', repr(rcParamsDefault[text])), nodes.Text(')')])
    return (node_list, messages)

def _mpltype_role(name, rawtext, text, lineno, inliner, options=None, content=None):
    mpltype = text
    type_to_link_target = {'color': 'colors_def'}
    if mpltype not in type_to_link_target:
        raise ValueError(f'Unknown mpltype: {mpltype!r}')
    (node_list, messages) = inliner.interpreted(mpltype, f'{mpltype} <{type_to_link_target[mpltype]}>', 'ref', lineno)
    return (node_list, messages)

def setup(app):
    app.add_role('rc', _rcparam_role)
    app.add_role('mpltype', _mpltype_role)
    app.add_node(_QueryReference, html=(_visit_query_reference_node, _depart_query_reference_node), latex=(_visit_query_reference_node, _depart_query_reference_node), text=(_visit_query_reference_node, _depart_query_reference_node))
    return {'version': matplotlib.__version__, 'parallel_read_safe': True, 'parallel_write_safe': True}

# File: matplotlib-main/lib/matplotlib/spines.py
from collections.abc import MutableMapping
import functools
import numpy as np
import matplotlib as mpl
from matplotlib import _api, _docstring
from matplotlib.artist import allow_rasterization
import matplotlib.transforms as mtransforms
import matplotlib.patches as mpatches
import matplotlib.path as mpath

class Spine(mpatches.Patch):

    def __str__(self):
        return 'Spine'

    @_docstring.dedent_interpd
    def __init__(self, axes, spine_type, path, **kwargs):
        super().__init__(**kwargs)
        self.axes = axes
        self.set_figure(self.axes.get_figure(root=False))
        self.spine_type = spine_type
        self.set_facecolor('none')
        self.set_edgecolor(mpl.rcParams['axes.edgecolor'])
        self.set_linewidth(mpl.rcParams['axes.linewidth'])
        self.set_capstyle('projecting')
        self.axis = None
        self.set_zorder(2.5)
        self.set_transform(self.axes.transData)
        self._bounds = None
        self._position = None
        _api.check_isinstance(mpath.Path, path=path)
        self._path = path
        self._patch_type = 'line'
        self._patch_transform = mtransforms.IdentityTransform()

    def set_patch_arc(self, center, radius, theta1, theta2):
        self._patch_type = 'arc'
        self._center = center
        self._width = radius * 2
        self._height = radius * 2
        self._theta1 = theta1
        self._theta2 = theta2
        self._path = mpath.Path.arc(theta1, theta2)
        self.set_transform(self.axes.transAxes)
        self.stale = True

    def set_patch_circle(self, center, radius):
        self._patch_type = 'circle'
        self._center = center
        self._width = radius * 2
        self._height = radius * 2
        self.set_transform(self.axes.transAxes)
        self.stale = True

    def set_patch_line(self):
        self._patch_type = 'line'
        self.stale = True

    def _recompute_transform(self):
        assert self._patch_type in ('arc', 'circle')
        center = (self.convert_xunits(self._center[0]), self.convert_yunits(self._center[1]))
        width = self.convert_xunits(self._width)
        height = self.convert_yunits(self._height)
        self._patch_transform = mtransforms.Affine2D().scale(width * 0.5, height * 0.5).translate(*center)

    def get_patch_transform(self):
        if self._patch_type in ('arc', 'circle'):
            self._recompute_transform()
            return self._patch_transform
        else:
            return super().get_patch_transform()

    def get_window_extent(self, renderer=None):
        self._adjust_location()
        bb = super().get_window_extent(renderer=renderer)
        if self.axis is None or not self.axis.get_visible():
            return bb
        bboxes = [bb]
        drawn_ticks = self.axis._update_ticks()
        major_tick = next(iter({*drawn_ticks} & {*self.axis.majorTicks}), None)
        minor_tick = next(iter({*drawn_ticks} & {*self.axis.minorTicks}), None)
        for tick in [major_tick, minor_tick]:
            if tick is None:
                continue
            bb0 = bb.frozen()
            tickl = tick._size
            tickdir = tick._tickdir
            if tickdir == 'out':
                padout = 1
                padin = 0
            elif tickdir == 'in':
                padout = 0
                padin = 1
            else:
                padout = 0.5
                padin = 0.5
            dpi = self.get_figure(root=True).dpi
            padout = padout * tickl / 72 * dpi
            padin = padin * tickl / 72 * dpi
            if tick.tick1line.get_visible():
                if self.spine_type == 'left':
                    bb0.x0 = bb0.x0 - padout
                    bb0.x1 = bb0.x1 + padin
                elif self.spine_type == 'bottom':
                    bb0.y0 = bb0.y0 - padout
                    bb0.y1 = bb0.y1 + padin
            if tick.tick2line.get_visible():
                if self.spine_type == 'right':
                    bb0.x1 = bb0.x1 + padout
                    bb0.x0 = bb0.x0 - padin
                elif self.spine_type == 'top':
                    bb0.y1 = bb0.y1 + padout
                    bb0.y0 = bb0.y0 - padout
            bboxes.append(bb0)
        return mtransforms.Bbox.union(bboxes)

    def get_path(self):
        return self._path

    def _ensure_position_is_set(self):
        if self._position is None:
            self._position = ('outward', 0.0)
            self.set_position(self._position)

    def register_axis(self, axis):
        self.axis = axis
        self.stale = True

    def clear(self):
        self._clear()
        if self.axis is not None:
            self.axis.clear()

    def _clear(self):
        self._position = None

    def _adjust_location(self):
        if self.spine_type == 'circle':
            return
        if self._bounds is not None:
            (low, high) = self._bounds
        elif self.spine_type in ('left', 'right'):
            (low, high) = self.axes.viewLim.intervaly
        elif self.spine_type in ('top', 'bottom'):
            (low, high) = self.axes.viewLim.intervalx
        else:
            raise ValueError(f'unknown spine spine_type: {self.spine_type}')
        if self._patch_type == 'arc':
            if self.spine_type in ('bottom', 'top'):
                try:
                    direction = self.axes.get_theta_direction()
                except AttributeError:
                    direction = 1
                try:
                    offset = self.axes.get_theta_offset()
                except AttributeError:
                    offset = 0
                low = low * direction + offset
                high = high * direction + offset
                if low > high:
                    (low, high) = (high, low)
                self._path = mpath.Path.arc(np.rad2deg(low), np.rad2deg(high))
                if self.spine_type == 'bottom':
                    (rmin, rmax) = self.axes.viewLim.intervaly
                    try:
                        rorigin = self.axes.get_rorigin()
                    except AttributeError:
                        rorigin = rmin
                    scaled_diameter = (rmin - rorigin) / (rmax - rorigin)
                    self._height = scaled_diameter
                    self._width = scaled_diameter
            else:
                raise ValueError('unable to set bounds for spine "%s"' % self.spine_type)
        else:
            v1 = self._path.vertices
            assert v1.shape == (2, 2), 'unexpected vertices shape'
            if self.spine_type in ['left', 'right']:
                v1[0, 1] = low
                v1[1, 1] = high
            elif self.spine_type in ['bottom', 'top']:
                v1[0, 0] = low
                v1[1, 0] = high
            else:
                raise ValueError('unable to set bounds for spine "%s"' % self.spine_type)

    @allow_rasterization
    def draw(self, renderer):
        self._adjust_location()
        ret = super().draw(renderer)
        self.stale = False
        return ret

    def set_position(self, position):
        if position in ('center', 'zero'):
            pass
        else:
            if len(position) != 2:
                raise ValueError("position should be 'center' or 2-tuple")
            if position[0] not in ['outward', 'axes', 'data']:
                raise ValueError("position[0] should be one of 'outward', 'axes', or 'data' ")
        self._position = position
        self.set_transform(self.get_spine_transform())
        if self.axis is not None:
            self.axis.reset_ticks()
        self.stale = True

    def get_position(self):
        self._ensure_position_is_set()
        return self._position

    def get_spine_transform(self):
        self._ensure_position_is_set()
        position = self._position
        if isinstance(position, str):
            if position == 'center':
                position = ('axes', 0.5)
            elif position == 'zero':
                position = ('data', 0)
        assert len(position) == 2, 'position should be 2-tuple'
        (position_type, amount) = position
        _api.check_in_list(['axes', 'outward', 'data'], position_type=position_type)
        if self.spine_type in ['left', 'right']:
            base_transform = self.axes.get_yaxis_transform(which='grid')
        elif self.spine_type in ['top', 'bottom']:
            base_transform = self.axes.get_xaxis_transform(which='grid')
        else:
            raise ValueError(f'unknown spine spine_type: {self.spine_type!r}')
        if position_type == 'outward':
            if amount == 0:
                return base_transform
            else:
                offset_vec = {'left': (-1, 0), 'right': (1, 0), 'bottom': (0, -1), 'top': (0, 1)}[self.spine_type]
                offset_dots = amount * np.array(offset_vec) / 72
                return base_transform + mtransforms.ScaledTranslation(*offset_dots, self.get_figure(root=False).dpi_scale_trans)
        elif position_type == 'axes':
            if self.spine_type in ['left', 'right']:
                return mtransforms.Affine2D.from_values(0, 0, 0, 1, amount, 0) + base_transform
            elif self.spine_type in ['bottom', 'top']:
                return mtransforms.Affine2D.from_values(1, 0, 0, 0, 0, amount) + base_transform
        elif position_type == 'data':
            if self.spine_type in ('right', 'top'):
                amount -= 1
            if self.spine_type in ('left', 'right'):
                return mtransforms.blended_transform_factory(mtransforms.Affine2D().translate(amount, 0) + self.axes.transData, self.axes.transData)
            elif self.spine_type in ('bottom', 'top'):
                return mtransforms.blended_transform_factory(self.axes.transData, mtransforms.Affine2D().translate(0, amount) + self.axes.transData)

    def set_bounds(self, low=None, high=None):
        if self.spine_type == 'circle':
            raise ValueError('set_bounds() method incompatible with circular spines')
        if high is None and np.iterable(low):
            (low, high) = low
        (old_low, old_high) = self.get_bounds() or (None, None)
        if low is None:
            low = old_low
        if high is None:
            high = old_high
        self._bounds = (low, high)
        self.stale = True

    def get_bounds(self):
        return self._bounds

    @classmethod
    def linear_spine(cls, axes, spine_type, **kwargs):
        if spine_type == 'left':
            path = mpath.Path([(0.0, 0.999), (0.0, 0.999)])
        elif spine_type == 'right':
            path = mpath.Path([(1.0, 0.999), (1.0, 0.999)])
        elif spine_type == 'bottom':
            path = mpath.Path([(0.999, 0.0), (0.999, 0.0)])
        elif spine_type == 'top':
            path = mpath.Path([(0.999, 1.0), (0.999, 1.0)])
        else:
            raise ValueError('unable to make path for spine "%s"' % spine_type)
        result = cls(axes, spine_type, path, **kwargs)
        result.set_visible(mpl.rcParams[f'axes.spines.{spine_type}'])
        return result

    @classmethod
    def arc_spine(cls, axes, spine_type, center, radius, theta1, theta2, **kwargs):
        path = mpath.Path.arc(theta1, theta2)
        result = cls(axes, spine_type, path, **kwargs)
        result.set_patch_arc(center, radius, theta1, theta2)
        return result

    @classmethod
    def circular_spine(cls, axes, center, radius, **kwargs):
        path = mpath.Path.unit_circle()
        spine_type = 'circle'
        result = cls(axes, spine_type, path, **kwargs)
        result.set_patch_circle(center, radius)
        return result

    def set_color(self, c):
        self.set_edgecolor(c)
        self.stale = True

class SpinesProxy:

    def __init__(self, spine_dict):
        self._spine_dict = spine_dict

    def __getattr__(self, name):
        broadcast_targets = [spine for spine in self._spine_dict.values() if hasattr(spine, name)]
        if name != 'set' and (not name.startswith('set_')) or not broadcast_targets:
            raise AttributeError(f"'SpinesProxy' object has no attribute '{name}'")

        def x(_targets, _funcname, *args, **kwargs):
            for spine in _targets:
                getattr(spine, _funcname)(*args, **kwargs)
        x = functools.partial(x, broadcast_targets, name)
        x.__doc__ = broadcast_targets[0].__doc__
        return x

    def __dir__(self):
        names = []
        for spine in self._spine_dict.values():
            names.extend((name for name in dir(spine) if name.startswith('set_')))
        return list(sorted(set(names)))

class Spines(MutableMapping):

    def __init__(self, **kwargs):
        self._dict = kwargs

    @classmethod
    def from_dict(cls, d):
        return cls(**d)

    def __getstate__(self):
        return self._dict

    def __setstate__(self, state):
        self.__init__(**state)

    def __getattr__(self, name):
        try:
            return self._dict[name]
        except KeyError:
            raise AttributeError(f"'Spines' object does not contain a '{name}' spine")

    def __getitem__(self, key):
        if isinstance(key, list):
            unknown_keys = [k for k in key if k not in self._dict]
            if unknown_keys:
                raise KeyError(', '.join(unknown_keys))
            return SpinesProxy({k: v for (k, v) in self._dict.items() if k in key})
        if isinstance(key, tuple):
            raise ValueError('Multiple spines must be passed as a single list')
        if isinstance(key, slice):
            if key.start is None and key.stop is None and (key.step is None):
                return SpinesProxy(self._dict)
            else:
                raise ValueError('Spines does not support slicing except for the fully open slice [:] to access all spines.')
        return self._dict[key]

    def __setitem__(self, key, value):
        self._dict[key] = value

    def __delitem__(self, key):
        del self._dict[key]

    def __iter__(self):
        return iter(self._dict)

    def __len__(self):
        return len(self._dict)

# File: matplotlib-main/lib/matplotlib/stackplot.py
""""""
import itertools
import numpy as np
from matplotlib import _api
__all__ = ['stackplot']

def stackplot(axes, x, *args, labels=(), colors=None, hatch=None, baseline='zero', **kwargs):
    y = np.vstack(args)
    labels = iter(labels)
    if colors is not None:
        colors = itertools.cycle(colors)
    else:
        colors = (axes._get_lines.get_next_color() for _ in y)
    if hatch is None or isinstance(hatch, str):
        hatch = itertools.cycle([hatch])
    else:
        hatch = itertools.cycle(hatch)
    stack = np.cumsum(y, axis=0, dtype=np.promote_types(y.dtype, np.float32))
    _api.check_in_list(['zero', 'sym', 'wiggle', 'weighted_wiggle'], baseline=baseline)
    if baseline == 'zero':
        first_line = 0.0
    elif baseline == 'sym':
        first_line = -np.sum(y, 0) * 0.5
        stack += first_line[None, :]
    elif baseline == 'wiggle':
        m = y.shape[0]
        first_line = (y * (m - 0.5 - np.arange(m)[:, None])).sum(0)
        first_line /= -m
        stack += first_line
    elif baseline == 'weighted_wiggle':
        total = np.sum(y, 0)
        inv_total = np.zeros_like(total)
        mask = total > 0
        inv_total[mask] = 1.0 / total[mask]
        increase = np.hstack((y[:, 0:1], np.diff(y)))
        below_size = total - stack
        below_size += 0.5 * y
        move_up = below_size * inv_total
        move_up[:, 0] = 0.5
        center = (move_up - 0.5) * increase
        center = np.cumsum(center.sum(0))
        first_line = center - 0.5 * total
        stack += first_line
    coll = axes.fill_between(x, first_line, stack[0, :], facecolor=next(colors), hatch=next(hatch), label=next(labels, None), **kwargs)
    coll.sticky_edges.y[:] = [0]
    r = [coll]
    for i in range(len(y) - 1):
        r.append(axes.fill_between(x, stack[i, :], stack[i + 1, :], facecolor=next(colors), hatch=next(hatch), label=next(labels, None), **kwargs))
    return r

# File: matplotlib-main/lib/matplotlib/streamplot.py
""""""
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cm, patches
import matplotlib.colors as mcolors
import matplotlib.collections as mcollections
import matplotlib.lines as mlines
__all__ = ['streamplot']

def streamplot(axes, x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', broken_streamlines=True):
    grid = Grid(x, y)
    mask = StreamMask(density)
    dmap = DomainMap(grid, mask)
    if zorder is None:
        zorder = mlines.Line2D.zorder
    if transform is None:
        transform = axes.transData
    if color is None:
        color = axes._get_lines.get_next_color()
    if linewidth is None:
        linewidth = mpl.rcParams['lines.linewidth']
    line_kw = {}
    arrow_kw = dict(arrowstyle=arrowstyle, mutation_scale=10 * arrowsize)
    _api.check_in_list(['both', 'forward', 'backward'], integration_direction=integration_direction)
    if integration_direction == 'both':
        maxlength /= 2.0
    use_multicolor_lines = isinstance(color, np.ndarray)
    if use_multicolor_lines:
        if color.shape != grid.shape:
            raise ValueError("If 'color' is given, it must match the shape of the (x, y) grid")
        line_colors = [[]]
        color = np.ma.masked_invalid(color)
    else:
        line_kw['color'] = color
        arrow_kw['color'] = color
    if isinstance(linewidth, np.ndarray):
        if linewidth.shape != grid.shape:
            raise ValueError("If 'linewidth' is given, it must match the shape of the (x, y) grid")
        line_kw['linewidth'] = []
    else:
        line_kw['linewidth'] = linewidth
        arrow_kw['linewidth'] = linewidth
    line_kw['zorder'] = zorder
    arrow_kw['zorder'] = zorder
    if u.shape != grid.shape or v.shape != grid.shape:
        raise ValueError("'u' and 'v' must match the shape of the (x, y) grid")
    u = np.ma.masked_invalid(u)
    v = np.ma.masked_invalid(v)
    integrate = _get_integrator(u, v, dmap, minlength, maxlength, integration_direction)
    trajectories = []
    if start_points is None:
        for (xm, ym) in _gen_starting_points(mask.shape):
            if mask[ym, xm] == 0:
                (xg, yg) = dmap.mask2grid(xm, ym)
                t = integrate(xg, yg, broken_streamlines)
                if t is not None:
                    trajectories.append(t)
    else:
        sp2 = np.asanyarray(start_points, dtype=float).copy()
        for (xs, ys) in sp2:
            if not (grid.x_origin <= xs <= grid.x_origin + grid.width and grid.y_origin <= ys <= grid.y_origin + grid.height):
                raise ValueError(f'Starting point ({xs}, {ys}) outside of data boundaries')
        sp2[:, 0] -= grid.x_origin
        sp2[:, 1] -= grid.y_origin
        for (xs, ys) in sp2:
            (xg, yg) = dmap.data2grid(xs, ys)
            xg = np.clip(xg, 0, grid.nx - 1)
            yg = np.clip(yg, 0, grid.ny - 1)
            t = integrate(xg, yg, broken_streamlines)
            if t is not None:
                trajectories.append(t)
    if use_multicolor_lines:
        if norm is None:
            norm = mcolors.Normalize(color.min(), color.max())
        cmap = cm._ensure_cmap(cmap)
    streamlines = []
    arrows = []
    for t in trajectories:
        (tgx, tgy) = t.T
        (tx, ty) = dmap.grid2data(tgx, tgy)
        tx += grid.x_origin
        ty += grid.y_origin
        if isinstance(linewidth, np.ndarray) or use_multicolor_lines:
            points = np.transpose([tx, ty]).reshape(-1, 1, 2)
            streamlines.extend(np.hstack([points[:-1], points[1:]]))
        else:
            points = np.transpose([tx, ty])
            streamlines.append(points)
        s = np.cumsum(np.hypot(np.diff(tx), np.diff(ty)))
        n = np.searchsorted(s, s[-1] / 2.0)
        arrow_tail = (tx[n], ty[n])
        arrow_head = (np.mean(tx[n:n + 2]), np.mean(ty[n:n + 2]))
        if isinstance(linewidth, np.ndarray):
            line_widths = interpgrid(linewidth, tgx, tgy)[:-1]
            line_kw['linewidth'].extend(line_widths)
            arrow_kw['linewidth'] = line_widths[n]
        if use_multicolor_lines:
            color_values = interpgrid(color, tgx, tgy)[:-1]
            line_colors.append(color_values)
            arrow_kw['color'] = cmap(norm(color_values[n]))
        p = patches.FancyArrowPatch(arrow_tail, arrow_head, transform=transform, **arrow_kw)
        arrows.append(p)
    lc = mcollections.LineCollection(streamlines, transform=transform, **line_kw)
    lc.sticky_edges.x[:] = [grid.x_origin, grid.x_origin + grid.width]
    lc.sticky_edges.y[:] = [grid.y_origin, grid.y_origin + grid.height]
    if use_multicolor_lines:
        lc.set_array(np.ma.hstack(line_colors))
        lc.set_cmap(cmap)
        lc.set_norm(norm)
    axes.add_collection(lc)
    ac = mcollections.PatchCollection(arrows)
    for p in arrows:
        axes.add_patch(p)
    axes.autoscale_view()
    stream_container = StreamplotSet(lc, ac)
    return stream_container

class StreamplotSet:

    def __init__(self, lines, arrows):
        self.lines = lines
        self.arrows = arrows

class DomainMap:

    def __init__(self, grid, mask):
        self.grid = grid
        self.mask = mask
        self.x_grid2mask = (mask.nx - 1) / (grid.nx - 1)
        self.y_grid2mask = (mask.ny - 1) / (grid.ny - 1)
        self.x_mask2grid = 1.0 / self.x_grid2mask
        self.y_mask2grid = 1.0 / self.y_grid2mask
        self.x_data2grid = 1.0 / grid.dx
        self.y_data2grid = 1.0 / grid.dy

    def grid2mask(self, xi, yi):
        return (round(xi * self.x_grid2mask), round(yi * self.y_grid2mask))

    def mask2grid(self, xm, ym):
        return (xm * self.x_mask2grid, ym * self.y_mask2grid)

    def data2grid(self, xd, yd):
        return (xd * self.x_data2grid, yd * self.y_data2grid)

    def grid2data(self, xg, yg):
        return (xg / self.x_data2grid, yg / self.y_data2grid)

    def start_trajectory(self, xg, yg, broken_streamlines=True):
        (xm, ym) = self.grid2mask(xg, yg)
        self.mask._start_trajectory(xm, ym, broken_streamlines)

    def reset_start_point(self, xg, yg):
        (xm, ym) = self.grid2mask(xg, yg)
        self.mask._current_xy = (xm, ym)

    def update_trajectory(self, xg, yg, broken_streamlines=True):
        if not self.grid.within_grid(xg, yg):
            raise InvalidIndexError
        (xm, ym) = self.grid2mask(xg, yg)
        self.mask._update_trajectory(xm, ym, broken_streamlines)

    def undo_trajectory(self):
        self.mask._undo_trajectory()

class Grid:

    def __init__(self, x, y):
        if np.ndim(x) == 1:
            pass
        elif np.ndim(x) == 2:
            x_row = x[0]
            if not np.allclose(x_row, x):
                raise ValueError("The rows of 'x' must be equal")
            x = x_row
        else:
            raise ValueError("'x' can have at maximum 2 dimensions")
        if np.ndim(y) == 1:
            pass
        elif np.ndim(y) == 2:
            yt = np.transpose(y)
            y_col = yt[0]
            if not np.allclose(y_col, yt):
                raise ValueError("The columns of 'y' must be equal")
            y = y_col
        else:
            raise ValueError("'y' can have at maximum 2 dimensions")
        if not (np.diff(x) > 0).all():
            raise ValueError("'x' must be strictly increasing")
        if not (np.diff(y) > 0).all():
            raise ValueError("'y' must be strictly increasing")
        self.nx = len(x)
        self.ny = len(y)
        self.dx = x[1] - x[0]
        self.dy = y[1] - y[0]
        self.x_origin = x[0]
        self.y_origin = y[0]
        self.width = x[-1] - x[0]
        self.height = y[-1] - y[0]
        if not np.allclose(np.diff(x), self.width / (self.nx - 1)):
            raise ValueError("'x' values must be equally spaced")
        if not np.allclose(np.diff(y), self.height / (self.ny - 1)):
            raise ValueError("'y' values must be equally spaced")

    @property
    def shape(self):
        return (self.ny, self.nx)

    def within_grid(self, xi, yi):
        return 0 <= xi <= self.nx - 1 and 0 <= yi <= self.ny - 1

class StreamMask:

    def __init__(self, density):
        try:
            (self.nx, self.ny) = (30 * np.broadcast_to(density, 2)).astype(int)
        except ValueError as err:
            raise ValueError("'density' must be a scalar or be of length 2") from err
        if self.nx < 0 or self.ny < 0:
            raise ValueError("'density' must be positive")
        self._mask = np.zeros((self.ny, self.nx))
        self.shape = self._mask.shape
        self._current_xy = None

    def __getitem__(self, args):
        return self._mask[args]

    def _start_trajectory(self, xm, ym, broken_streamlines=True):
        self._traj = []
        self._update_trajectory(xm, ym, broken_streamlines)

    def _undo_trajectory(self):
        for t in self._traj:
            self._mask[t] = 0

    def _update_trajectory(self, xm, ym, broken_streamlines=True):
        if self._current_xy != (xm, ym):
            if self[ym, xm] == 0:
                self._traj.append((ym, xm))
                self._mask[ym, xm] = 1
                self._current_xy = (xm, ym)
            elif broken_streamlines:
                raise InvalidIndexError
            else:
                pass

class InvalidIndexError(Exception):
    pass

class TerminateTrajectory(Exception):
    pass

def _get_integrator(u, v, dmap, minlength, maxlength, integration_direction):
    (u, v) = dmap.data2grid(u, v)
    u_ax = u / (dmap.grid.nx - 1)
    v_ax = v / (dmap.grid.ny - 1)
    speed = np.ma.sqrt(u_ax ** 2 + v_ax ** 2)

    def forward_time(xi, yi):
        if not dmap.grid.within_grid(xi, yi):
            raise OutOfBounds
        ds_dt = interpgrid(speed, xi, yi)
        if ds_dt == 0:
            raise TerminateTrajectory()
        dt_ds = 1.0 / ds_dt
        ui = interpgrid(u, xi, yi)
        vi = interpgrid(v, xi, yi)
        return (ui * dt_ds, vi * dt_ds)

    def backward_time(xi, yi):
        (dxi, dyi) = forward_time(xi, yi)
        return (-dxi, -dyi)

    def integrate(x0, y0, broken_streamlines=True):
        (stotal, xy_traj) = (0.0, [])
        try:
            dmap.start_trajectory(x0, y0, broken_streamlines)
        except InvalidIndexError:
            return None
        if integration_direction in ['both', 'backward']:
            (s, xyt) = _integrate_rk12(x0, y0, dmap, backward_time, maxlength, broken_streamlines)
            stotal += s
            xy_traj += xyt[::-1]
        if integration_direction in ['both', 'forward']:
            dmap.reset_start_point(x0, y0)
            (s, xyt) = _integrate_rk12(x0, y0, dmap, forward_time, maxlength, broken_streamlines)
            stotal += s
            xy_traj += xyt[1:]
        if stotal > minlength:
            return np.broadcast_arrays(xy_traj, np.empty((1, 2)))[0]
        else:
            dmap.undo_trajectory()
            return None
    return integrate

class OutOfBounds(IndexError):
    pass

def _integrate_rk12(x0, y0, dmap, f, maxlength, broken_streamlines=True):
    maxerror = 0.003
    maxds = min(1.0 / dmap.mask.nx, 1.0 / dmap.mask.ny, 0.1)
    ds = maxds
    stotal = 0
    xi = x0
    yi = y0
    xyf_traj = []
    while True:
        try:
            if dmap.grid.within_grid(xi, yi):
                xyf_traj.append((xi, yi))
            else:
                raise OutOfBounds
            (k1x, k1y) = f(xi, yi)
            (k2x, k2y) = f(xi + ds * k1x, yi + ds * k1y)
        except OutOfBounds:
            if xyf_traj:
                (ds, xyf_traj) = _euler_step(xyf_traj, dmap, f)
                stotal += ds
            break
        except TerminateTrajectory:
            break
        dx1 = ds * k1x
        dy1 = ds * k1y
        dx2 = ds * 0.5 * (k1x + k2x)
        dy2 = ds * 0.5 * (k1y + k2y)
        (ny, nx) = dmap.grid.shape
        error = np.hypot((dx2 - dx1) / (nx - 1), (dy2 - dy1) / (ny - 1))
        if error < maxerror:
            xi += dx2
            yi += dy2
            try:
                dmap.update_trajectory(xi, yi, broken_streamlines)
            except InvalidIndexError:
                break
            if stotal + ds > maxlength:
                break
            stotal += ds
        if error == 0:
            ds = maxds
        else:
            ds = min(maxds, 0.85 * ds * (maxerror / error) ** 0.5)
    return (stotal, xyf_traj)

def _euler_step(xyf_traj, dmap, f):
    (ny, nx) = dmap.grid.shape
    (xi, yi) = xyf_traj[-1]
    (cx, cy) = f(xi, yi)
    if cx == 0:
        dsx = np.inf
    elif cx < 0:
        dsx = xi / -cx
    else:
        dsx = (nx - 1 - xi) / cx
    if cy == 0:
        dsy = np.inf
    elif cy < 0:
        dsy = yi / -cy
    else:
        dsy = (ny - 1 - yi) / cy
    ds = min(dsx, dsy)
    xyf_traj.append((xi + cx * ds, yi + cy * ds))
    return (ds, xyf_traj)

def interpgrid(a, xi, yi):
    (Ny, Nx) = np.shape(a)
    if isinstance(xi, np.ndarray):
        x = xi.astype(int)
        y = yi.astype(int)
        xn = np.clip(x + 1, 0, Nx - 1)
        yn = np.clip(y + 1, 0, Ny - 1)
    else:
        x = int(xi)
        y = int(yi)
        if x == Nx - 1:
            xn = x
        else:
            xn = x + 1
        if y == Ny - 1:
            yn = y
        else:
            yn = y + 1
    a00 = a[y, x]
    a01 = a[y, xn]
    a10 = a[yn, x]
    a11 = a[yn, xn]
    xt = xi - x
    yt = yi - y
    a0 = a00 * (1 - xt) + a01 * xt
    a1 = a10 * (1 - xt) + a11 * xt
    ai = a0 * (1 - yt) + a1 * yt
    if not isinstance(xi, np.ndarray):
        if np.ma.is_masked(ai):
            raise TerminateTrajectory
    return ai

def _gen_starting_points(shape):
    (ny, nx) = shape
    xfirst = 0
    yfirst = 1
    xlast = nx - 1
    ylast = ny - 1
    (x, y) = (0, 0)
    direction = 'right'
    for i in range(nx * ny):
        yield (x, y)
        if direction == 'right':
            x += 1
            if x >= xlast:
                xlast -= 1
                direction = 'up'
        elif direction == 'up':
            y += 1
            if y >= ylast:
                ylast -= 1
                direction = 'left'
        elif direction == 'left':
            x -= 1
            if x <= xfirst:
                xfirst += 1
                direction = 'down'
        elif direction == 'down':
            y -= 1
            if y <= yfirst:
                yfirst += 1
                direction = 'right'

# File: matplotlib-main/lib/matplotlib/style/core.py
""""""
import contextlib
import importlib.resources
import logging
import os
from pathlib import Path
import warnings
import matplotlib as mpl
from matplotlib import _api, _docstring, _rc_params_in_file, rcParamsDefault
_log = logging.getLogger(__name__)
__all__ = ['use', 'context', 'available', 'library', 'reload_library']
BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
STYLE_EXTENSION = 'mplstyle'
STYLE_BLACKLIST = {'interactive', 'backend', 'webagg.port', 'webagg.address', 'webagg.port_retries', 'webagg.open_in_browser', 'backend_fallback', 'toolbar', 'timezone', 'figure.max_open_warning', 'figure.raise_window', 'savefig.directory', 'tk.window_focus', 'docstring.hardcopy', 'date.epoch'}

@_docstring.Substitution('\n'.join(map('- {}'.format, sorted(STYLE_BLACKLIST, key=str.lower))))
def use(style):
    if isinstance(style, (str, Path)) or hasattr(style, 'keys'):
        styles = [style]
    else:
        styles = style
    style_alias = {'mpl20': 'default', 'mpl15': 'classic'}
    for style in styles:
        if isinstance(style, str):
            style = style_alias.get(style, style)
            if style == 'default':
                with _api.suppress_matplotlib_deprecation_warning():
                    style = {k: rcParamsDefault[k] for k in rcParamsDefault if k not in STYLE_BLACKLIST}
            elif style in library:
                style = library[style]
            elif '.' in style:
                (pkg, _, name) = style.rpartition('.')
                try:
                    path = importlib.resources.files(pkg) / f'{name}.{STYLE_EXTENSION}'
                    style = _rc_params_in_file(path)
                except (ModuleNotFoundError, OSError, TypeError) as exc:
                    pass
        if isinstance(style, (str, Path)):
            try:
                style = _rc_params_in_file(style)
            except OSError as err:
                raise OSError(f'{style!r} is not a valid package style, path of style file, URL of style file, or library style name (library styles are listed in `style.available`)') from err
        filtered = {}
        for k in style:
            if k in STYLE_BLACKLIST:
                _api.warn_external(f'Style includes a parameter, {k!r}, that is not related to style.  Ignoring this parameter.')
            else:
                filtered[k] = style[k]
        mpl.rcParams.update(filtered)

@contextlib.contextmanager
def context(style, after_reset=False):
    with mpl.rc_context():
        if after_reset:
            mpl.rcdefaults()
        use(style)
        yield

def update_user_library(library):
    for stylelib_path in map(os.path.expanduser, USER_LIBRARY_PATHS):
        styles = read_style_directory(stylelib_path)
        update_nested_dict(library, styles)
    return library

def read_style_directory(style_dir):
    styles = dict()
    for path in Path(style_dir).glob(f'*.{STYLE_EXTENSION}'):
        with warnings.catch_warnings(record=True) as warns:
            styles[path.stem] = _rc_params_in_file(path)
        for w in warns:
            _log.warning('In %s: %s', path, w.message)
    return styles

def update_nested_dict(main_dict, new_dict):
    for (name, rc_dict) in new_dict.items():
        main_dict.setdefault(name, {}).update(rc_dict)
    return main_dict
_base_library = read_style_directory(BASE_LIBRARY_PATH)
library = {}
available = []

def reload_library():
    library.clear()
    library.update(update_user_library(_base_library))
    available[:] = sorted(library.keys())
reload_library()

# File: matplotlib-main/lib/matplotlib/table.py
""""""
import numpy as np
from . import _api, _docstring
from .artist import Artist, allow_rasterization
from .patches import Rectangle
from .text import Text
from .transforms import Bbox
from .path import Path

class Cell(Rectangle):
    PAD = 0.1
    ''
    _edges = 'BRTL'
    _edge_aliases = {'open': '', 'closed': _edges, 'horizontal': 'BT', 'vertical': 'RL'}

    def __init__(self, xy, width, height, *, edgecolor='k', facecolor='w', fill=True, text='', loc='right', fontproperties=None, visible_edges='closed'):
        super().__init__(xy, width=width, height=height, fill=fill, edgecolor=edgecolor, facecolor=facecolor)
        self.set_clip_on(False)
        self.visible_edges = visible_edges
        self._loc = loc
        self._text = Text(x=xy[0], y=xy[1], clip_on=False, text=text, fontproperties=fontproperties, horizontalalignment=loc, verticalalignment='center')

    def set_transform(self, t):
        super().set_transform(t)
        self.stale = True

    def set_figure(self, fig):
        super().set_figure(fig)
        self._text.set_figure(fig)

    def get_text(self):
        return self._text

    def set_fontsize(self, size):
        self._text.set_fontsize(size)
        self.stale = True

    def get_fontsize(self):
        return self._text.get_fontsize()

    def auto_set_font_size(self, renderer):
        fontsize = self.get_fontsize()
        required = self.get_required_width(renderer)
        while fontsize > 1 and required > self.get_width():
            fontsize -= 1
            self.set_fontsize(fontsize)
            required = self.get_required_width(renderer)
        return fontsize

    @allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        super().draw(renderer)
        self._set_text_position(renderer)
        self._text.draw(renderer)
        self.stale = False

    def _set_text_position(self, renderer):
        bbox = self.get_window_extent(renderer)
        y = bbox.y0 + bbox.height / 2
        loc = self._text.get_horizontalalignment()
        if loc == 'center':
            x = bbox.x0 + bbox.width / 2
        elif loc == 'left':
            x = bbox.x0 + bbox.width * self.PAD
        else:
            x = bbox.x0 + bbox.width * (1 - self.PAD)
        self._text.set_position((x, y))

    def get_text_bounds(self, renderer):
        return self._text.get_window_extent(renderer).transformed(self.get_data_transform().inverted()).bounds

    def get_required_width(self, renderer):
        (l, b, w, h) = self.get_text_bounds(renderer)
        return w * (1.0 + 2.0 * self.PAD)

    @_docstring.dedent_interpd
    def set_text_props(self, **kwargs):
        self._text._internal_update(kwargs)
        self.stale = True

    @property
    def visible_edges(self):
        return self._visible_edges

    @visible_edges.setter
    def visible_edges(self, value):
        if value is None:
            self._visible_edges = self._edges
        elif value in self._edge_aliases:
            self._visible_edges = self._edge_aliases[value]
        else:
            if any((edge not in self._edges for edge in value)):
                raise ValueError('Invalid edge param {}, must only be one of {} or string of {}'.format(value, ', '.join(self._edge_aliases), ', '.join(self._edges)))
            self._visible_edges = value
        self.stale = True

    def get_path(self):
        codes = [Path.MOVETO]
        codes.extend((Path.LINETO if edge in self._visible_edges else Path.MOVETO for edge in self._edges))
        if Path.MOVETO not in codes[1:]:
            codes[-1] = Path.CLOSEPOLY
        return Path([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]], codes, readonly=True)
CustomCell = Cell

class Table(Artist):
    codes = {'best': 0, 'upper right': 1, 'upper left': 2, 'lower left': 3, 'lower right': 4, 'center left': 5, 'center right': 6, 'lower center': 7, 'upper center': 8, 'center': 9, 'top right': 10, 'top left': 11, 'bottom left': 12, 'bottom right': 13, 'right': 14, 'left': 15, 'top': 16, 'bottom': 17}
    ''
    FONTSIZE = 10
    AXESPAD = 0.02
    ''

    def __init__(self, ax, loc=None, bbox=None, **kwargs):
        super().__init__()
        if isinstance(loc, str):
            if loc not in self.codes:
                raise ValueError('Unrecognized location {!r}. Valid locations are\n\t{}'.format(loc, '\n\t'.join(self.codes)))
            loc = self.codes[loc]
        self.set_figure(ax.get_figure(root=False))
        self._axes = ax
        self._loc = loc
        self._bbox = bbox
        ax._unstale_viewLim()
        self.set_transform(ax.transAxes)
        self._cells = {}
        self._edges = None
        self._autoColumns = []
        self._autoFontsize = True
        self._internal_update(kwargs)
        self.set_clip_on(False)

    def add_cell(self, row, col, *args, **kwargs):
        xy = (0, 0)
        cell = Cell(xy, *args, visible_edges=self.edges, **kwargs)
        self[row, col] = cell
        return cell

    def __setitem__(self, position, cell):
        _api.check_isinstance(Cell, cell=cell)
        try:
            (row, col) = (position[0], position[1])
        except Exception as err:
            raise KeyError('Only tuples length 2 are accepted as coordinates') from err
        cell.set_figure(self.get_figure(root=False))
        cell.set_transform(self.get_transform())
        cell.set_clip_on(False)
        self._cells[row, col] = cell
        self.stale = True

    def __getitem__(self, position):
        return self._cells[position]

    @property
    def edges(self):
        return self._edges

    @edges.setter
    def edges(self, value):
        self._edges = value
        self.stale = True

    def _approx_text_height(self):
        return self.FONTSIZE / 72.0 * self.get_figure(root=True).dpi / self._axes.bbox.height * 1.2

    @allow_rasterization
    def draw(self, renderer):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        if renderer is None:
            raise RuntimeError('No renderer defined')
        if not self.get_visible():
            return
        renderer.open_group('table', gid=self.get_gid())
        self._update_positions(renderer)
        for key in sorted(self._cells):
            self._cells[key].draw(renderer)
        renderer.close_group('table')
        self.stale = False

    def _get_grid_bbox(self, renderer):
        boxes = [cell.get_window_extent(renderer) for ((row, col), cell) in self._cells.items() if row >= 0 and col >= 0]
        bbox = Bbox.union(boxes)
        return bbox.transformed(self.get_transform().inverted())

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        renderer = self.get_figure(root=True)._get_renderer()
        if renderer is not None:
            boxes = [cell.get_window_extent(renderer) for ((row, col), cell) in self._cells.items() if row >= 0 and col >= 0]
            bbox = Bbox.union(boxes)
            return (bbox.contains(mouseevent.x, mouseevent.y), {})
        else:
            return (False, {})

    def get_children(self):
        return list(self._cells.values())

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        self._update_positions(renderer)
        boxes = [cell.get_window_extent(renderer) for cell in self._cells.values()]
        return Bbox.union(boxes)

    def _do_cell_alignment(self):
        widths = {}
        heights = {}
        for ((row, col), cell) in self._cells.items():
            height = heights.setdefault(row, 0.0)
            heights[row] = max(height, cell.get_height())
            width = widths.setdefault(col, 0.0)
            widths[col] = max(width, cell.get_width())
        xpos = 0
        lefts = {}
        for col in sorted(widths):
            lefts[col] = xpos
            xpos += widths[col]
        ypos = 0
        bottoms = {}
        for row in sorted(heights, reverse=True):
            bottoms[row] = ypos
            ypos += heights[row]
        for ((row, col), cell) in self._cells.items():
            cell.set_x(lefts[col])
            cell.set_y(bottoms[row])

    def auto_set_column_width(self, col):
        col1d = np.atleast_1d(col)
        if not np.issubdtype(col1d.dtype, np.integer):
            _api.warn_deprecated('3.8', name='col', message='%(name)r must be an int or sequence of ints. Passing other types is deprecated since %(since)s and will be removed %(removal)s.')
            return
        for cell in col1d:
            self._autoColumns.append(cell)
        self.stale = True

    def _auto_set_column_width(self, col, renderer):
        cells = [cell for (key, cell) in self._cells.items() if key[1] == col]
        max_width = max((cell.get_required_width(renderer) for cell in cells), default=0)
        for cell in cells:
            cell.set_width(max_width)

    def auto_set_font_size(self, value=True):
        self._autoFontsize = value
        self.stale = True

    def _auto_set_font_size(self, renderer):
        if len(self._cells) == 0:
            return
        fontsize = next(iter(self._cells.values())).get_fontsize()
        cells = []
        for (key, cell) in self._cells.items():
            if key[1] in self._autoColumns:
                continue
            size = cell.auto_set_font_size(renderer)
            fontsize = min(fontsize, size)
            cells.append(cell)
        for cell in self._cells.values():
            cell.set_fontsize(fontsize)

    def scale(self, xscale, yscale):
        for c in self._cells.values():
            c.set_width(c.get_width() * xscale)
            c.set_height(c.get_height() * yscale)

    def set_fontsize(self, size):
        for cell in self._cells.values():
            cell.set_fontsize(size)
        self.stale = True

    def _offset(self, ox, oy):
        for c in self._cells.values():
            (x, y) = (c.get_x(), c.get_y())
            c.set_x(x + ox)
            c.set_y(y + oy)

    def _update_positions(self, renderer):
        for col in self._autoColumns:
            self._auto_set_column_width(col, renderer)
        if self._autoFontsize:
            self._auto_set_font_size(renderer)
        self._do_cell_alignment()
        bbox = self._get_grid_bbox(renderer)
        (l, b, w, h) = bbox.bounds
        if self._bbox is not None:
            if isinstance(self._bbox, Bbox):
                (rl, rb, rw, rh) = self._bbox.bounds
            else:
                (rl, rb, rw, rh) = self._bbox
            self.scale(rw / w, rh / h)
            ox = rl - l
            oy = rb - b
            self._do_cell_alignment()
        else:
            (BEST, UR, UL, LL, LR, CL, CR, LC, UC, C, TR, TL, BL, BR, R, L, T, B) = range(len(self.codes))
            ox = 0.5 - w / 2 - l
            oy = 0.5 - h / 2 - b
            if self._loc in (UL, LL, CL):
                ox = self.AXESPAD - l
            if self._loc in (BEST, UR, LR, R, CR):
                ox = 1 - (l + w + self.AXESPAD)
            if self._loc in (BEST, UR, UL, UC):
                oy = 1 - (b + h + self.AXESPAD)
            if self._loc in (LL, LR, LC):
                oy = self.AXESPAD - b
            if self._loc in (LC, UC, C):
                ox = 0.5 - w / 2 - l
            if self._loc in (CL, CR, C):
                oy = 0.5 - h / 2 - b
            if self._loc in (TL, BL, L):
                ox = -(l + w)
            if self._loc in (TR, BR, R):
                ox = 1.0 - l
            if self._loc in (TR, TL, T):
                oy = 1.0 - b
            if self._loc in (BL, BR, B):
                oy = -(b + h)
        self._offset(ox, oy)

    def get_celld(self):
        return self._cells

@_docstring.dedent_interpd
def table(ax, cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs):
    if cellColours is None and cellText is None:
        raise ValueError('At least one argument from "cellColours" or "cellText" must be provided to create a table.')
    if cellText is None:
        rows = len(cellColours)
        cols = len(cellColours[0])
        cellText = [[''] * cols] * rows
    rows = len(cellText)
    cols = len(cellText[0])
    for row in cellText:
        if len(row) != cols:
            raise ValueError(f"Each row in 'cellText' must have {cols} columns")
    if cellColours is not None:
        if len(cellColours) != rows:
            raise ValueError(f"'cellColours' must have {rows} rows")
        for row in cellColours:
            if len(row) != cols:
                raise ValueError(f"Each row in 'cellColours' must have {cols} columns")
    else:
        cellColours = ['w' * cols] * rows
    if colWidths is None:
        colWidths = [1.0 / cols] * cols
    rowLabelWidth = 0
    if rowLabels is None:
        if rowColours is not None:
            rowLabels = [''] * rows
            rowLabelWidth = colWidths[0]
    elif rowColours is None:
        rowColours = 'w' * rows
    if rowLabels is not None:
        if len(rowLabels) != rows:
            raise ValueError(f"'rowLabels' must be of length {rows}")
    offset = 1
    if colLabels is None:
        if colColours is not None:
            colLabels = [''] * cols
        else:
            offset = 0
    elif colColours is None:
        colColours = 'w' * cols
    if cellColours is None:
        cellColours = ['w' * cols] * rows
    table = Table(ax, loc, bbox, **kwargs)
    table.edges = edges
    height = table._approx_text_height()
    for row in range(rows):
        for col in range(cols):
            table.add_cell(row + offset, col, width=colWidths[col], height=height, text=cellText[row][col], facecolor=cellColours[row][col], loc=cellLoc)
    if colLabels is not None:
        for col in range(cols):
            table.add_cell(0, col, width=colWidths[col], height=height, text=colLabels[col], facecolor=colColours[col], loc=colLoc)
    if rowLabels is not None:
        for row in range(rows):
            table.add_cell(row + offset, -1, width=rowLabelWidth or 1e-15, height=height, text=rowLabels[row], facecolor=rowColours[row], loc=rowLoc)
        if rowLabelWidth == 0:
            table.auto_set_column_width(-1)
    ax.add_table(table)
    return table

# File: matplotlib-main/lib/matplotlib/texmanager.py
""""""
import functools
import hashlib
import logging
import os
from pathlib import Path
import subprocess
from tempfile import TemporaryDirectory
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, dviread
_log = logging.getLogger(__name__)

def _usepackage_if_not_loaded(package, *, option=None):
    option = f'[{option}]' if option is not None else ''
    return '\\makeatletter\\@ifpackageloaded{%(package)s}{}{\\usepackage%(option)s{%(package)s}}\\makeatother' % {'package': package, 'option': option}

class TexManager:
    texcache = _api.deprecate_privatize_attribute('3.8')
    _texcache = os.path.join(mpl.get_cachedir(), 'tex.cache')
    _grey_arrayd = {}
    _font_families = ('serif', 'sans-serif', 'cursive', 'monospace')
    _font_preambles = {'new century schoolbook': '\\renewcommand{\\rmdefault}{pnc}', 'bookman': '\\renewcommand{\\rmdefault}{pbk}', 'times': '\\usepackage{mathptmx}', 'palatino': '\\usepackage{mathpazo}', 'zapf chancery': '\\usepackage{chancery}', 'cursive': '\\usepackage{chancery}', 'charter': '\\usepackage{charter}', 'serif': '', 'sans-serif': '', 'helvetica': '\\usepackage{helvet}', 'avant garde': '\\usepackage{avant}', 'courier': '\\usepackage{courier}', 'monospace': '\\usepackage{type1ec}', 'computer modern roman': '\\usepackage{type1ec}', 'computer modern sans serif': '\\usepackage{type1ec}', 'computer modern typewriter': '\\usepackage{type1ec}'}
    _font_types = {'new century schoolbook': 'serif', 'bookman': 'serif', 'times': 'serif', 'palatino': 'serif', 'zapf chancery': 'cursive', 'charter': 'serif', 'helvetica': 'sans-serif', 'avant garde': 'sans-serif', 'courier': 'monospace', 'computer modern roman': 'serif', 'computer modern sans serif': 'sans-serif', 'computer modern typewriter': 'monospace'}

    @functools.lru_cache
    def __new__(cls):
        Path(cls._texcache).mkdir(parents=True, exist_ok=True)
        return object.__new__(cls)

    @classmethod
    def _get_font_family_and_reduced(cls):
        ff = mpl.rcParams['font.family']
        ff_val = ff[0].lower() if len(ff) == 1 else None
        if len(ff) == 1 and ff_val in cls._font_families:
            return (ff_val, False)
        elif len(ff) == 1 and ff_val in cls._font_preambles:
            return (cls._font_types[ff_val], True)
        else:
            _log.info('font.family must be one of (%s) when text.usetex is True. serif will be used by default.', ', '.join(cls._font_families))
            return ('serif', False)

    @classmethod
    def _get_font_preamble_and_command(cls):
        (requested_family, is_reduced_font) = cls._get_font_family_and_reduced()
        preambles = {}
        for font_family in cls._font_families:
            if is_reduced_font and font_family == requested_family:
                preambles[font_family] = cls._font_preambles[mpl.rcParams['font.family'][0].lower()]
            else:
                rcfonts = mpl.rcParams[f'font.{font_family}']
                for (i, font) in enumerate(map(str.lower, rcfonts)):
                    if font in cls._font_preambles:
                        preambles[font_family] = cls._font_preambles[font]
                        _log.debug('family: %s, package: %s, font: %s, skipped: %s', font_family, cls._font_preambles[font], rcfonts[i], ', '.join(rcfonts[:i]))
                        break
                else:
                    _log.info('No LaTeX-compatible font found for the %s fontfamily in rcParams. Using default.', font_family)
                    preambles[font_family] = cls._font_preambles[font_family]
        cmd = {preambles[family] for family in ['serif', 'sans-serif', 'monospace']}
        if requested_family == 'cursive':
            cmd.add(preambles['cursive'])
        cmd.add('\\usepackage{type1cm}')
        preamble = '\n'.join(sorted(cmd))
        fontcmd = '\\sffamily' if requested_family == 'sans-serif' else '\\ttfamily' if requested_family == 'monospace' else '\\rmfamily'
        return (preamble, fontcmd)

    @classmethod
    def get_basefile(cls, tex, fontsize, dpi=None):
        src = cls._get_tex_source(tex, fontsize) + str(dpi)
        filehash = hashlib.md5(src.encode('utf-8')).hexdigest()
        filepath = Path(cls._texcache)
        (num_letters, num_levels) = (2, 2)
        for i in range(0, num_letters * num_levels, num_letters):
            filepath = filepath / Path(filehash[i:i + 2])
        filepath.mkdir(parents=True, exist_ok=True)
        return os.path.join(filepath, filehash)

    @classmethod
    def get_font_preamble(cls):
        (font_preamble, command) = cls._get_font_preamble_and_command()
        return font_preamble

    @classmethod
    def get_custom_preamble(cls):
        return mpl.rcParams['text.latex.preamble']

    @classmethod
    def _get_tex_source(cls, tex, fontsize):
        (font_preamble, fontcmd) = cls._get_font_preamble_and_command()
        baselineskip = 1.25 * fontsize
        return '\n'.join(['\\documentclass{article}', '% Pass-through \\mathdefault, which is used in non-usetex mode', '% to use the default text font but was historically suppressed', '% in usetex mode.', '\\newcommand{\\mathdefault}[1]{#1}', font_preamble, '\\usepackage[utf8]{inputenc}', '\\DeclareUnicodeCharacter{2212}{\\ensuremath{-}}', '% geometry is loaded before the custom preamble as ', '% convert_psfrags relies on a custom preamble to change the ', '% geometry.', '\\usepackage[papersize=72in, margin=1in]{geometry}', cls.get_custom_preamble(), '% Use `underscore` package to take care of underscores in text.', '% The [strings] option allows to use underscores in file names.', _usepackage_if_not_loaded('underscore', option='strings'), '% Custom packages (e.g. newtxtext) may already have loaded ', '% textcomp with different options.', _usepackage_if_not_loaded('textcomp'), '\\pagestyle{empty}', '\\begin{document}', '% The empty hbox ensures that a page is printed even for empty', '% inputs, except when using psfrag which gets confused by it.', '% matplotlibbaselinemarker is used by dviread to detect the', "% last line's baseline.", f'\\fontsize{{{fontsize}}}{{{baselineskip}}}%', '\\ifdefined\\psfrag\\else\\hbox{}\\fi%', f'{{{fontcmd} {tex}}}%', '\\end{document}'])

    @classmethod
    def make_tex(cls, tex, fontsize):
        texfile = cls.get_basefile(tex, fontsize) + '.tex'
        Path(texfile).write_text(cls._get_tex_source(tex, fontsize), encoding='utf-8')
        return texfile

    @classmethod
    def _run_checked_subprocess(cls, command, tex, *, cwd=None):
        _log.debug(cbook._pformat_subprocess(command))
        try:
            report = subprocess.check_output(command, cwd=cwd if cwd is not None else cls._texcache, stderr=subprocess.STDOUT)
        except FileNotFoundError as exc:
            raise RuntimeError(f'Failed to process string with tex because {command[0]} could not be found') from exc
        except subprocess.CalledProcessError as exc:
            raise RuntimeError('{prog} was not able to process the following string:\n{tex!r}\n\nHere is the full command invocation and its output:\n\n{format_command}\n\n{exc}\n\n'.format(prog=command[0], format_command=cbook._pformat_subprocess(command), tex=tex.encode('unicode_escape'), exc=exc.output.decode('utf-8', 'backslashreplace'))) from None
        _log.debug(report)
        return report

    @classmethod
    def make_dvi(cls, tex, fontsize):
        basefile = cls.get_basefile(tex, fontsize)
        dvifile = '%s.dvi' % basefile
        if not os.path.exists(dvifile):
            texfile = Path(cls.make_tex(tex, fontsize))
            cwd = Path(dvifile).parent
            with TemporaryDirectory(dir=cwd) as tmpdir:
                tmppath = Path(tmpdir)
                cls._run_checked_subprocess(['latex', '-interaction=nonstopmode', '--halt-on-error', f'--output-directory={tmppath.name}', f'{texfile.name}'], tex, cwd=cwd)
                (tmppath / Path(dvifile).name).replace(dvifile)
        return dvifile

    @classmethod
    def make_png(cls, tex, fontsize, dpi):
        basefile = cls.get_basefile(tex, fontsize, dpi)
        pngfile = '%s.png' % basefile
        if not os.path.exists(pngfile):
            dvifile = cls.make_dvi(tex, fontsize)
            cmd = ['dvipng', '-bg', 'Transparent', '-D', str(dpi), '-T', 'tight', '-o', pngfile, dvifile]
            if getattr(mpl, '_called_from_pytest', False) and mpl._get_executable_info('dvipng').raw_version != '1.16':
                cmd.insert(1, '--freetype0')
            cls._run_checked_subprocess(cmd, tex)
        return pngfile

    @classmethod
    def get_grey(cls, tex, fontsize=None, dpi=None):
        if not fontsize:
            fontsize = mpl.rcParams['font.size']
        if not dpi:
            dpi = mpl.rcParams['savefig.dpi']
        key = (cls._get_tex_source(tex, fontsize), dpi)
        alpha = cls._grey_arrayd.get(key)
        if alpha is None:
            pngfile = cls.make_png(tex, fontsize, dpi)
            rgba = mpl.image.imread(os.path.join(cls._texcache, pngfile))
            cls._grey_arrayd[key] = alpha = rgba[:, :, -1]
        return alpha

    @classmethod
    def get_rgba(cls, tex, fontsize=None, dpi=None, rgb=(0, 0, 0)):
        alpha = cls.get_grey(tex, fontsize, dpi)
        rgba = np.empty((*alpha.shape, 4))
        rgba[..., :3] = mpl.colors.to_rgb(rgb)
        rgba[..., -1] = alpha
        return rgba

    @classmethod
    def get_text_width_height_descent(cls, tex, fontsize, renderer=None):
        if tex.strip() == '':
            return (0, 0, 0)
        dvifile = cls.make_dvi(tex, fontsize)
        dpi_fraction = renderer.points_to_pixels(1.0) if renderer else 1
        with dviread.Dvi(dvifile, 72 * dpi_fraction) as dvi:
            (page,) = dvi
        return (page.width, page.height + page.descent, page.descent)

# File: matplotlib-main/lib/matplotlib/text.py
""""""
import functools
import logging
import math
from numbers import Real
import weakref
import numpy as np
import matplotlib as mpl
from . import _api, artist, cbook, _docstring
from .artist import Artist
from .font_manager import FontProperties
from .patches import FancyArrowPatch, FancyBboxPatch, Rectangle
from .textpath import TextPath, TextToPath
from .transforms import Affine2D, Bbox, BboxBase, BboxTransformTo, IdentityTransform, Transform
_log = logging.getLogger(__name__)

def _get_textbox(text, renderer):
    projected_xs = []
    projected_ys = []
    theta = np.deg2rad(text.get_rotation())
    tr = Affine2D().rotate(-theta)
    (_, parts, d) = text._get_layout(renderer)
    for (t, wh, x, y) in parts:
        (w, h) = wh
        (xt1, yt1) = tr.transform((x, y))
        yt1 -= d
        (xt2, yt2) = (xt1 + w, yt1 + h)
        projected_xs.extend([xt1, xt2])
        projected_ys.extend([yt1, yt2])
    (xt_box, yt_box) = (min(projected_xs), min(projected_ys))
    (w_box, h_box) = (max(projected_xs) - xt_box, max(projected_ys) - yt_box)
    (x_box, y_box) = Affine2D().rotate(theta).transform((xt_box, yt_box))
    return (x_box, y_box, w_box, h_box)

def _get_text_metrics_with_cache(renderer, text, fontprop, ismath, dpi):
    return _get_text_metrics_with_cache_impl(weakref.ref(renderer), text, fontprop.copy(), ismath, dpi)

@functools.lru_cache(4096)
def _get_text_metrics_with_cache_impl(renderer_ref, text, fontprop, ismath, dpi):
    return renderer_ref().get_text_width_height_descent(text, fontprop, ismath)

@_docstring.interpd
@_api.define_aliases({'color': ['c'], 'fontproperties': ['font', 'font_properties'], 'fontfamily': ['family'], 'fontname': ['name'], 'fontsize': ['size'], 'fontstretch': ['stretch'], 'fontstyle': ['style'], 'fontvariant': ['variant'], 'fontweight': ['weight'], 'horizontalalignment': ['ha'], 'verticalalignment': ['va'], 'multialignment': ['ma']})
class Text(Artist):
    zorder = 3
    _charsize_cache = dict()

    def __repr__(self):
        return f'Text({self._x}, {self._y}, {self._text!r})'

    def __init__(self, x=0, y=0, text='', *, color=None, verticalalignment='baseline', horizontalalignment='left', multialignment=None, fontproperties=None, rotation=None, linespacing=None, rotation_mode=None, usetex=None, wrap=False, transform_rotates_text=False, parse_math=None, antialiased=None, **kwargs):
        super().__init__()
        (self._x, self._y) = (x, y)
        self._text = ''
        self._reset_visual_defaults(text=text, color=color, fontproperties=fontproperties, usetex=usetex, parse_math=parse_math, wrap=wrap, verticalalignment=verticalalignment, horizontalalignment=horizontalalignment, multialignment=multialignment, rotation=rotation, transform_rotates_text=transform_rotates_text, linespacing=linespacing, rotation_mode=rotation_mode, antialiased=antialiased)
        self.update(kwargs)

    def _reset_visual_defaults(self, text='', color=None, fontproperties=None, usetex=None, parse_math=None, wrap=False, verticalalignment='baseline', horizontalalignment='left', multialignment=None, rotation=None, transform_rotates_text=False, linespacing=None, rotation_mode=None, antialiased=None):
        self.set_text(text)
        self.set_color(mpl._val_or_rc(color, 'text.color'))
        self.set_fontproperties(fontproperties)
        self.set_usetex(usetex)
        self.set_parse_math(mpl._val_or_rc(parse_math, 'text.parse_math'))
        self.set_wrap(wrap)
        self.set_verticalalignment(verticalalignment)
        self.set_horizontalalignment(horizontalalignment)
        self._multialignment = multialignment
        self.set_rotation(rotation)
        self._transform_rotates_text = transform_rotates_text
        self._bbox_patch = None
        self._renderer = None
        if linespacing is None:
            linespacing = 1.2
        self.set_linespacing(linespacing)
        self.set_rotation_mode(rotation_mode)
        self.set_antialiased(antialiased if antialiased is not None else mpl.rcParams['text.antialiased'])

    def update(self, kwargs):
        ret = []
        kwargs = cbook.normalize_kwargs(kwargs, Text)
        sentinel = object()
        fontproperties = kwargs.pop('fontproperties', sentinel)
        if fontproperties is not sentinel:
            ret.append(self.set_fontproperties(fontproperties))
        bbox = kwargs.pop('bbox', sentinel)
        ret.extend(super().update(kwargs))
        if bbox is not sentinel:
            ret.append(self.set_bbox(bbox))
        return ret

    def __getstate__(self):
        d = super().__getstate__()
        d['_renderer'] = None
        return d

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent) or not self.get_visible() or self._renderer is None:
            return (False, {})
        bbox = Text.get_window_extent(self)
        inside = bbox.x0 <= mouseevent.x <= bbox.x1 and bbox.y0 <= mouseevent.y <= bbox.y1
        cattr = {}
        if self._bbox_patch:
            (patch_inside, patch_cattr) = self._bbox_patch.contains(mouseevent)
            inside = inside or patch_inside
            cattr['bbox_patch'] = patch_cattr
        return (inside, cattr)

    def _get_xy_display(self):
        (x, y) = self.get_unitless_position()
        return self.get_transform().transform((x, y))

    def _get_multialignment(self):
        if self._multialignment is not None:
            return self._multialignment
        else:
            return self._horizontalalignment

    def _char_index_at(self, x):
        if not self._text:
            return 0
        text = self._text
        fontproperties = str(self._fontproperties)
        if fontproperties not in Text._charsize_cache:
            Text._charsize_cache[fontproperties] = dict()
        charsize_cache = Text._charsize_cache[fontproperties]
        for char in set(text):
            if char not in charsize_cache:
                self.set_text(char)
                bb = self.get_window_extent()
                charsize_cache[char] = bb.x1 - bb.x0
        self.set_text(text)
        bb = self.get_window_extent()
        size_accum = np.cumsum([0] + [charsize_cache[x] for x in text])
        std_x = x - bb.x0
        return np.abs(size_accum - std_x).argmin()

    def get_rotation(self):
        if self.get_transform_rotates_text():
            return self.get_transform().transform_angles([self._rotation], [self.get_unitless_position()]).item(0)
        else:
            return self._rotation

    def get_transform_rotates_text(self):
        return self._transform_rotates_text

    def set_rotation_mode(self, m):
        if m is None:
            m = 'default'
        else:
            _api.check_in_list(('anchor', 'default'), rotation_mode=m)
        self._rotation_mode = m
        self.stale = True

    def get_rotation_mode(self):
        return self._rotation_mode

    def set_antialiased(self, antialiased):
        self._antialiased = antialiased
        self.stale = True

    def get_antialiased(self):
        return self._antialiased

    def update_from(self, other):
        super().update_from(other)
        self._color = other._color
        self._multialignment = other._multialignment
        self._verticalalignment = other._verticalalignment
        self._horizontalalignment = other._horizontalalignment
        self._fontproperties = other._fontproperties.copy()
        self._usetex = other._usetex
        self._rotation = other._rotation
        self._transform_rotates_text = other._transform_rotates_text
        self._picker = other._picker
        self._linespacing = other._linespacing
        self._antialiased = other._antialiased
        self.stale = True

    def _get_layout(self, renderer):
        (thisx, thisy) = (0.0, 0.0)
        lines = self._get_wrapped_text().split('\n')
        ws = []
        hs = []
        xs = []
        ys = []
        (_, lp_h, lp_d) = _get_text_metrics_with_cache(renderer, 'lp', self._fontproperties, ismath='TeX' if self.get_usetex() else False, dpi=self.get_figure(root=True).dpi)
        min_dy = (lp_h - lp_d) * self._linespacing
        for (i, line) in enumerate(lines):
            (clean_line, ismath) = self._preprocess_math(line)
            if clean_line:
                (w, h, d) = _get_text_metrics_with_cache(renderer, clean_line, self._fontproperties, ismath=ismath, dpi=self.get_figure(root=True).dpi)
            else:
                w = h = d = 0
            h = max(h, lp_h)
            d = max(d, lp_d)
            ws.append(w)
            hs.append(h)
            baseline = h - d - thisy
            if i == 0:
                thisy = -(h - d)
            else:
                thisy -= max(min_dy, (h - d) * self._linespacing)
            xs.append(thisx)
            ys.append(thisy)
            thisy -= d
        descent = d
        width = max(ws)
        xmin = 0
        xmax = width
        ymax = 0
        ymin = ys[-1] - descent
        M = Affine2D().rotate_deg(self.get_rotation())
        malign = self._get_multialignment()
        if malign == 'left':
            offset_layout = [(x, y) for (x, y) in zip(xs, ys)]
        elif malign == 'center':
            offset_layout = [(x + width / 2 - w / 2, y) for (x, y, w) in zip(xs, ys, ws)]
        elif malign == 'right':
            offset_layout = [(x + width - w, y) for (x, y, w) in zip(xs, ys, ws)]
        corners_horiz = np.array([(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)])
        corners_rotated = M.transform(corners_horiz)
        xmin = corners_rotated[:, 0].min()
        xmax = corners_rotated[:, 0].max()
        ymin = corners_rotated[:, 1].min()
        ymax = corners_rotated[:, 1].max()
        width = xmax - xmin
        height = ymax - ymin
        halign = self._horizontalalignment
        valign = self._verticalalignment
        rotation_mode = self.get_rotation_mode()
        if rotation_mode != 'anchor':
            if halign == 'center':
                offsetx = (xmin + xmax) / 2
            elif halign == 'right':
                offsetx = xmax
            else:
                offsetx = xmin
            if valign == 'center':
                offsety = (ymin + ymax) / 2
            elif valign == 'top':
                offsety = ymax
            elif valign == 'baseline':
                offsety = ymin + descent
            elif valign == 'center_baseline':
                offsety = ymin + height - baseline / 2.0
            else:
                offsety = ymin
        else:
            (xmin1, ymin1) = corners_horiz[0]
            (xmax1, ymax1) = corners_horiz[2]
            if halign == 'center':
                offsetx = (xmin1 + xmax1) / 2.0
            elif halign == 'right':
                offsetx = xmax1
            else:
                offsetx = xmin1
            if valign == 'center':
                offsety = (ymin1 + ymax1) / 2.0
            elif valign == 'top':
                offsety = ymax1
            elif valign == 'baseline':
                offsety = ymax1 - baseline
            elif valign == 'center_baseline':
                offsety = ymax1 - baseline / 2.0
            else:
                offsety = ymin1
            (offsetx, offsety) = M.transform((offsetx, offsety))
        xmin -= offsetx
        ymin -= offsety
        bbox = Bbox.from_bounds(xmin, ymin, width, height)
        xys = M.transform(offset_layout) - (offsetx, offsety)
        return (bbox, list(zip(lines, zip(ws, hs), *xys.T)), descent)

    def set_bbox(self, rectprops):
        if rectprops is not None:
            props = rectprops.copy()
            boxstyle = props.pop('boxstyle', None)
            pad = props.pop('pad', None)
            if boxstyle is None:
                boxstyle = 'square'
                if pad is None:
                    pad = 4
                pad /= self.get_size()
            elif pad is None:
                pad = 0.3
            if isinstance(boxstyle, str) and 'pad' not in boxstyle:
                boxstyle += ',pad=%0.2f' % pad
            self._bbox_patch = FancyBboxPatch((0, 0), 1, 1, boxstyle=boxstyle, transform=IdentityTransform(), **props)
        else:
            self._bbox_patch = None
        self._update_clip_properties()

    def get_bbox_patch(self):
        return self._bbox_patch

    def update_bbox_position_size(self, renderer):
        if self._bbox_patch:
            posx = float(self.convert_xunits(self._x))
            posy = float(self.convert_yunits(self._y))
            (posx, posy) = self.get_transform().transform((posx, posy))
            (x_box, y_box, w_box, h_box) = _get_textbox(self, renderer)
            self._bbox_patch.set_bounds(0.0, 0.0, w_box, h_box)
            self._bbox_patch.set_transform(Affine2D().rotate_deg(self.get_rotation()).translate(posx + x_box, posy + y_box))
            fontsize_in_pixel = renderer.points_to_pixels(self.get_size())
            self._bbox_patch.set_mutation_scale(fontsize_in_pixel)

    def _update_clip_properties(self):
        if self._bbox_patch:
            clipprops = dict(clip_box=self.clipbox, clip_path=self._clippath, clip_on=self._clipon)
            self._bbox_patch.update(clipprops)

    def set_clip_box(self, clipbox):
        super().set_clip_box(clipbox)
        self._update_clip_properties()

    def set_clip_path(self, path, transform=None):
        super().set_clip_path(path, transform)
        self._update_clip_properties()

    def set_clip_on(self, b):
        super().set_clip_on(b)
        self._update_clip_properties()

    def get_wrap(self):
        return self._wrap

    def set_wrap(self, wrap):
        self._wrap = wrap

    def _get_wrap_line_width(self):
        (x0, y0) = self.get_transform().transform(self.get_position())
        figure_box = self.get_figure().get_window_extent()
        alignment = self.get_horizontalalignment()
        self.set_rotation_mode('anchor')
        rotation = self.get_rotation()
        left = self._get_dist_to_box(rotation, x0, y0, figure_box)
        right = self._get_dist_to_box((180 + rotation) % 360, x0, y0, figure_box)
        if alignment == 'left':
            line_width = left
        elif alignment == 'right':
            line_width = right
        else:
            line_width = 2 * min(left, right)
        return line_width

    def _get_dist_to_box(self, rotation, x0, y0, figure_box):
        if rotation > 270:
            quad = rotation - 270
            h1 = (y0 - figure_box.y0) / math.cos(math.radians(quad))
            h2 = (figure_box.x1 - x0) / math.cos(math.radians(90 - quad))
        elif rotation > 180:
            quad = rotation - 180
            h1 = (x0 - figure_box.x0) / math.cos(math.radians(quad))
            h2 = (y0 - figure_box.y0) / math.cos(math.radians(90 - quad))
        elif rotation > 90:
            quad = rotation - 90
            h1 = (figure_box.y1 - y0) / math.cos(math.radians(quad))
            h2 = (x0 - figure_box.x0) / math.cos(math.radians(90 - quad))
        else:
            h1 = (figure_box.x1 - x0) / math.cos(math.radians(rotation))
            h2 = (figure_box.y1 - y0) / math.cos(math.radians(90 - rotation))
        return min(h1, h2)

    def _get_rendered_text_width(self, text):
        (w, h, d) = self._renderer.get_text_width_height_descent(text, self.get_fontproperties(), cbook.is_math_text(text))
        return math.ceil(w)

    def _get_wrapped_text(self):
        if not self.get_wrap():
            return self.get_text()
        if self.get_usetex():
            return self.get_text()
        line_width = self._get_wrap_line_width()
        wrapped_lines = []
        unwrapped_lines = self.get_text().split('\n')
        for unwrapped_line in unwrapped_lines:
            sub_words = unwrapped_line.split(' ')
            while len(sub_words) > 0:
                if len(sub_words) == 1:
                    wrapped_lines.append(sub_words.pop(0))
                    continue
                for i in range(2, len(sub_words) + 1):
                    line = ' '.join(sub_words[:i])
                    current_width = self._get_rendered_text_width(line)
                    if current_width > line_width:
                        wrapped_lines.append(' '.join(sub_words[:i - 1]))
                        sub_words = sub_words[i - 1:]
                        break
                    elif i == len(sub_words):
                        wrapped_lines.append(' '.join(sub_words[:i]))
                        sub_words = []
                        break
        return '\n'.join(wrapped_lines)

    @artist.allow_rasterization
    def draw(self, renderer):
        if renderer is not None:
            self._renderer = renderer
        if not self.get_visible():
            return
        if self.get_text() == '':
            return
        renderer.open_group('text', self.get_gid())
        with self._cm_set(text=self._get_wrapped_text()):
            (bbox, info, descent) = self._get_layout(renderer)
            trans = self.get_transform()
            posx = float(self.convert_xunits(self._x))
            posy = float(self.convert_yunits(self._y))
            (posx, posy) = trans.transform((posx, posy))
            if not np.isfinite(posx) or not np.isfinite(posy):
                _log.warning('posx and posy should be finite values')
                return
            (canvasw, canvash) = renderer.get_canvas_width_height()
            if self._bbox_patch:
                self.update_bbox_position_size(renderer)
                self._bbox_patch.draw(renderer)
            gc = renderer.new_gc()
            gc.set_foreground(self.get_color())
            gc.set_alpha(self.get_alpha())
            gc.set_url(self._url)
            gc.set_antialiased(self._antialiased)
            self._set_gc_clip(gc)
            angle = self.get_rotation()
            for (line, wh, x, y) in info:
                mtext = self if len(info) == 1 else None
                x = x + posx
                y = y + posy
                if renderer.flipy():
                    y = canvash - y
                (clean_line, ismath) = self._preprocess_math(line)
                if self.get_path_effects():
                    from matplotlib.patheffects import PathEffectRenderer
                    textrenderer = PathEffectRenderer(self.get_path_effects(), renderer)
                else:
                    textrenderer = renderer
                if self.get_usetex():
                    textrenderer.draw_tex(gc, x, y, clean_line, self._fontproperties, angle, mtext=mtext)
                else:
                    textrenderer.draw_text(gc, x, y, clean_line, self._fontproperties, angle, ismath=ismath, mtext=mtext)
        gc.restore()
        renderer.close_group('text')
        self.stale = False

    def get_color(self):
        return self._color

    def get_fontproperties(self):
        return self._fontproperties

    def get_fontfamily(self):
        return self._fontproperties.get_family()

    def get_fontname(self):
        return self._fontproperties.get_name()

    def get_fontstyle(self):
        return self._fontproperties.get_style()

    def get_fontsize(self):
        return self._fontproperties.get_size_in_points()

    def get_fontvariant(self):
        return self._fontproperties.get_variant()

    def get_fontweight(self):
        return self._fontproperties.get_weight()

    def get_stretch(self):
        return self._fontproperties.get_stretch()

    def get_horizontalalignment(self):
        return self._horizontalalignment

    def get_unitless_position(self):
        x = float(self.convert_xunits(self._x))
        y = float(self.convert_yunits(self._y))
        return (x, y)

    def get_position(self):
        return (self._x, self._y)

    def get_text(self):
        return self._text

    def get_verticalalignment(self):
        return self._verticalalignment

    def get_window_extent(self, renderer=None, dpi=None):
        if not self.get_visible():
            return Bbox.unit()
        fig = self.get_figure(root=True)
        if dpi is None:
            dpi = fig.dpi
        if self.get_text() == '':
            with cbook._setattr_cm(fig, dpi=dpi):
                (tx, ty) = self._get_xy_display()
                return Bbox.from_bounds(tx, ty, 0, 0)
        if renderer is not None:
            self._renderer = renderer
        if self._renderer is None:
            self._renderer = fig._get_renderer()
        if self._renderer is None:
            raise RuntimeError("Cannot get window extent of text w/o renderer. You likely want to call 'figure.draw_without_rendering()' first.")
        with cbook._setattr_cm(fig, dpi=dpi):
            (bbox, info, descent) = self._get_layout(self._renderer)
            (x, y) = self.get_unitless_position()
            (x, y) = self.get_transform().transform((x, y))
            bbox = bbox.translated(x, y)
            return bbox

    def set_backgroundcolor(self, color):
        if self._bbox_patch is None:
            self.set_bbox(dict(facecolor=color, edgecolor=color))
        else:
            self._bbox_patch.update(dict(facecolor=color))
        self._update_clip_properties()
        self.stale = True

    def set_color(self, color):
        if not cbook._str_equal(color, 'auto'):
            mpl.colors._check_color_like(color=color)
        self._color = color
        self.stale = True

    def set_horizontalalignment(self, align):
        _api.check_in_list(['center', 'right', 'left'], align=align)
        self._horizontalalignment = align
        self.stale = True

    def set_multialignment(self, align):
        _api.check_in_list(['center', 'right', 'left'], align=align)
        self._multialignment = align
        self.stale = True

    def set_linespacing(self, spacing):
        _api.check_isinstance(Real, spacing=spacing)
        self._linespacing = spacing
        self.stale = True

    def set_fontfamily(self, fontname):
        self._fontproperties.set_family(fontname)
        self.stale = True

    def set_fontvariant(self, variant):
        self._fontproperties.set_variant(variant)
        self.stale = True

    def set_fontstyle(self, fontstyle):
        self._fontproperties.set_style(fontstyle)
        self.stale = True

    def set_fontsize(self, fontsize):
        self._fontproperties.set_size(fontsize)
        self.stale = True

    def get_math_fontfamily(self):
        return self._fontproperties.get_math_fontfamily()

    def set_math_fontfamily(self, fontfamily):
        self._fontproperties.set_math_fontfamily(fontfamily)

    def set_fontweight(self, weight):
        self._fontproperties.set_weight(weight)
        self.stale = True

    def set_fontstretch(self, stretch):
        self._fontproperties.set_stretch(stretch)
        self.stale = True

    def set_position(self, xy):
        self.set_x(xy[0])
        self.set_y(xy[1])

    def set_x(self, x):
        self._x = x
        self.stale = True

    def set_y(self, y):
        self._y = y
        self.stale = True

    def set_rotation(self, s):
        if isinstance(s, Real):
            self._rotation = float(s) % 360
        elif cbook._str_equal(s, 'horizontal') or s is None:
            self._rotation = 0.0
        elif cbook._str_equal(s, 'vertical'):
            self._rotation = 90.0
        else:
            raise ValueError(f"rotation must be 'vertical', 'horizontal' or a number, not {s}")
        self.stale = True

    def set_transform_rotates_text(self, t):
        self._transform_rotates_text = t
        self.stale = True

    def set_verticalalignment(self, align):
        _api.check_in_list(['top', 'bottom', 'center', 'baseline', 'center_baseline'], align=align)
        self._verticalalignment = align
        self.stale = True

    def set_text(self, s):
        s = '' if s is None else str(s)
        if s != self._text:
            self._text = s
            self.stale = True

    def _preprocess_math(self, s):
        if self.get_usetex():
            if s == ' ':
                s = '\\ '
            return (s, 'TeX')
        elif not self.get_parse_math():
            return (s, False)
        elif cbook.is_math_text(s):
            return (s, True)
        else:
            return (s.replace('\\$', '$'), False)

    def set_fontproperties(self, fp):
        self._fontproperties = FontProperties._from_any(fp).copy()
        self.stale = True

    @_docstring.kwarg_doc('bool, default: :rc:`text.usetex`')
    def set_usetex(self, usetex):
        if usetex is None:
            self._usetex = mpl.rcParams['text.usetex']
        else:
            self._usetex = bool(usetex)
        self.stale = True

    def get_usetex(self):
        return self._usetex

    def set_parse_math(self, parse_math):
        self._parse_math = bool(parse_math)

    def get_parse_math(self):
        return self._parse_math

    def set_fontname(self, fontname):
        self.set_fontfamily(fontname)

class OffsetFrom:

    def __init__(self, artist, ref_coord, unit='points'):
        self._artist = artist
        (x, y) = ref_coord
        self._ref_coord = (x, y)
        self.set_unit(unit)

    def set_unit(self, unit):
        _api.check_in_list(['points', 'pixels'], unit=unit)
        self._unit = unit

    def get_unit(self):
        return self._unit

    def __call__(self, renderer):
        if isinstance(self._artist, Artist):
            bbox = self._artist.get_window_extent(renderer)
            (xf, yf) = self._ref_coord
            x = bbox.x0 + bbox.width * xf
            y = bbox.y0 + bbox.height * yf
        elif isinstance(self._artist, BboxBase):
            bbox = self._artist
            (xf, yf) = self._ref_coord
            x = bbox.x0 + bbox.width * xf
            y = bbox.y0 + bbox.height * yf
        elif isinstance(self._artist, Transform):
            (x, y) = self._artist.transform(self._ref_coord)
        else:
            _api.check_isinstance((Artist, BboxBase, Transform), artist=self._artist)
        scale = 1 if self._unit == 'pixels' else renderer.points_to_pixels(1)
        return Affine2D().scale(scale).translate(x, y)

class _AnnotationBase:

    def __init__(self, xy, xycoords='data', annotation_clip=None):
        (x, y) = xy
        self.xy = (x, y)
        self.xycoords = xycoords
        self.set_annotation_clip(annotation_clip)
        self._draggable = None

    def _get_xy(self, renderer, xy, coords):
        (x, y) = xy
        (xcoord, ycoord) = coords if isinstance(coords, tuple) else (coords, coords)
        if xcoord == 'data':
            x = float(self.convert_xunits(x))
        if ycoord == 'data':
            y = float(self.convert_yunits(y))
        return self._get_xy_transform(renderer, coords).transform((x, y))

    def _get_xy_transform(self, renderer, coords):
        if isinstance(coords, tuple):
            (xcoord, ycoord) = coords
            from matplotlib.transforms import blended_transform_factory
            tr1 = self._get_xy_transform(renderer, xcoord)
            tr2 = self._get_xy_transform(renderer, ycoord)
            return blended_transform_factory(tr1, tr2)
        elif callable(coords):
            tr = coords(renderer)
            if isinstance(tr, BboxBase):
                return BboxTransformTo(tr)
            elif isinstance(tr, Transform):
                return tr
            else:
                raise TypeError(f'xycoords callable must return a BboxBase or Transform, not a {type(tr).__name__}')
        elif isinstance(coords, Artist):
            bbox = coords.get_window_extent(renderer)
            return BboxTransformTo(bbox)
        elif isinstance(coords, BboxBase):
            return BboxTransformTo(coords)
        elif isinstance(coords, Transform):
            return coords
        elif not isinstance(coords, str):
            raise TypeError(f"'xycoords' must be an instance of str, tuple[str, str], Artist, Transform, or Callable, not a {type(coords).__name__}")
        if coords == 'data':
            return self.axes.transData
        elif coords == 'polar':
            from matplotlib.projections import PolarAxes
            tr = PolarAxes.PolarTransform(apply_theta_transforms=False)
            trans = tr + self.axes.transData
            return trans
        try:
            (bbox_name, unit) = coords.split()
        except ValueError:
            raise ValueError(f'{coords!r} is not a valid coordinate') from None
        (bbox0, xy0) = (None, None)
        if bbox_name == 'figure':
            bbox0 = self.get_figure(root=False).figbbox
        elif bbox_name == 'subfigure':
            bbox0 = self.get_figure(root=False).bbox
        elif bbox_name == 'axes':
            bbox0 = self.axes.bbox
        if bbox0 is not None:
            xy0 = bbox0.p0
        elif bbox_name == 'offset':
            xy0 = self._get_position_xy(renderer)
        else:
            raise ValueError(f'{coords!r} is not a valid coordinate')
        if unit == 'points':
            tr = Affine2D().scale(self.get_figure(root=True).dpi / 72)
        elif unit == 'pixels':
            tr = Affine2D()
        elif unit == 'fontsize':
            tr = Affine2D().scale(self.get_size() * self.get_figure(root=True).dpi / 72)
        elif unit == 'fraction':
            tr = Affine2D().scale(*bbox0.size)
        else:
            raise ValueError(f'{unit!r} is not a recognized unit')
        return tr.translate(*xy0)

    def set_annotation_clip(self, b):
        self._annotation_clip = b

    def get_annotation_clip(self):
        return self._annotation_clip

    def _get_position_xy(self, renderer):
        return self._get_xy(renderer, self.xy, self.xycoords)

    def _check_xy(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        b = self.get_annotation_clip()
        if b or (b is None and self.xycoords == 'data'):
            xy_pixel = self._get_position_xy(renderer)
            return self.axes.contains_point(xy_pixel)
        return True

    def draggable(self, state=None, use_blit=False):
        from matplotlib.offsetbox import DraggableAnnotation
        is_draggable = self._draggable is not None
        if state is None:
            state = not is_draggable
        if state:
            if self._draggable is None:
                self._draggable = DraggableAnnotation(self, use_blit)
        else:
            if self._draggable is not None:
                self._draggable.disconnect()
            self._draggable = None
        return self._draggable

class Annotation(Text, _AnnotationBase):

    def __str__(self):
        return f'Annotation({self.xy[0]:g}, {self.xy[1]:g}, {self._text!r})'

    def __init__(self, text, xy, xytext=None, xycoords='data', textcoords=None, arrowprops=None, annotation_clip=None, **kwargs):
        _AnnotationBase.__init__(self, xy, xycoords=xycoords, annotation_clip=annotation_clip)
        if xytext is None and textcoords is not None and (textcoords != xycoords):
            _api.warn_external('You have used the `textcoords` kwarg, but not the `xytext` kwarg.  This can lead to surprising results.')
        if textcoords is None:
            textcoords = self.xycoords
        self._textcoords = textcoords
        if xytext is None:
            xytext = self.xy
        (x, y) = xytext
        self.arrowprops = arrowprops
        if arrowprops is not None:
            arrowprops = arrowprops.copy()
            if 'arrowstyle' in arrowprops:
                self._arrow_relpos = arrowprops.pop('relpos', (0.5, 0.5))
            else:
                for key in ['width', 'headwidth', 'headlength', 'shrink']:
                    arrowprops.pop(key, None)
                if 'frac' in arrowprops:
                    _api.warn_deprecated('3.8', name="the (unused) 'frac' key in 'arrowprops'")
                    arrowprops.pop('frac')
            self.arrow_patch = FancyArrowPatch((0, 0), (1, 1), **arrowprops)
        else:
            self.arrow_patch = None
        Text.__init__(self, x, y, text, **kwargs)

    def contains(self, mouseevent):
        if self._different_canvas(mouseevent):
            return (False, {})
        (contains, tinfo) = Text.contains(self, mouseevent)
        if self.arrow_patch is not None:
            (in_patch, _) = self.arrow_patch.contains(mouseevent)
            contains = contains or in_patch
        return (contains, tinfo)

    @property
    def xycoords(self):
        return self._xycoords

    @xycoords.setter
    def xycoords(self, xycoords):

        def is_offset(s):
            return isinstance(s, str) and s.startswith('offset')
        if isinstance(xycoords, tuple) and any(map(is_offset, xycoords)) or is_offset(xycoords):
            raise ValueError('xycoords cannot be an offset coordinate')
        self._xycoords = xycoords

    @property
    def xyann(self):
        return self.get_position()

    @xyann.setter
    def xyann(self, xytext):
        self.set_position(xytext)

    def get_anncoords(self):
        return self._textcoords

    def set_anncoords(self, coords):
        self._textcoords = coords
    anncoords = property(get_anncoords, set_anncoords, doc='\n        The coordinate system to use for `.Annotation.xyann`.')

    def set_figure(self, fig):
        if self.arrow_patch is not None:
            self.arrow_patch.set_figure(fig)
        Artist.set_figure(self, fig)

    def update_positions(self, renderer):
        self.set_transform(self._get_xy_transform(renderer, self.anncoords))
        arrowprops = self.arrowprops
        if arrowprops is None:
            return
        bbox = Text.get_window_extent(self, renderer)
        arrow_end = (x1, y1) = self._get_position_xy(renderer)
        ms = arrowprops.get('mutation_scale', self.get_size())
        self.arrow_patch.set_mutation_scale(ms)
        if 'arrowstyle' not in arrowprops:
            shrink = arrowprops.get('shrink', 0.0)
            width = arrowprops.get('width', 4)
            headwidth = arrowprops.get('headwidth', 12)
            headlength = arrowprops.get('headlength', 12)
            stylekw = dict(head_length=headlength / ms, head_width=headwidth / ms, tail_width=width / ms)
            self.arrow_patch.set_arrowstyle('simple', **stylekw)
            xpos = [(bbox.x0, 0), ((bbox.x0 + bbox.x1) / 2, 0.5), (bbox.x1, 1)]
            ypos = [(bbox.y0, 0), ((bbox.y0 + bbox.y1) / 2, 0.5), (bbox.y1, 1)]
            (x, relposx) = min(xpos, key=lambda v: abs(v[0] - x1))
            (y, relposy) = min(ypos, key=lambda v: abs(v[0] - y1))
            self._arrow_relpos = (relposx, relposy)
            r = np.hypot(y - y1, x - x1)
            shrink_pts = shrink * r / renderer.points_to_pixels(1)
            self.arrow_patch.shrinkA = self.arrow_patch.shrinkB = shrink_pts
        arrow_begin = bbox.p0 + bbox.size * self._arrow_relpos
        self.arrow_patch.set_positions(arrow_begin, arrow_end)
        if 'patchA' in arrowprops:
            patchA = arrowprops['patchA']
        elif self._bbox_patch:
            patchA = self._bbox_patch
        elif self.get_text() == '':
            patchA = None
        else:
            pad = renderer.points_to_pixels(4)
            patchA = Rectangle(xy=(bbox.x0 - pad / 2, bbox.y0 - pad / 2), width=bbox.width + pad, height=bbox.height + pad, transform=IdentityTransform(), clip_on=False)
        self.arrow_patch.set_patchA(patchA)

    @artist.allow_rasterization
    def draw(self, renderer):
        if renderer is not None:
            self._renderer = renderer
        if not self.get_visible() or not self._check_xy(renderer):
            return
        self.update_positions(renderer)
        self.update_bbox_position_size(renderer)
        if self.arrow_patch is not None:
            if self.arrow_patch.get_figure(root=False) is None and (fig := self.get_figure(root=False)) is not None:
                self.arrow_patch.set_figure(fig)
            self.arrow_patch.draw(renderer)
        Text.draw(self, renderer)

    def get_window_extent(self, renderer=None):
        if not self.get_visible() or not self._check_xy(renderer):
            return Bbox.unit()
        if renderer is not None:
            self._renderer = renderer
        if self._renderer is None:
            self._renderer = self.get_figure(root=True)._get_renderer()
        if self._renderer is None:
            raise RuntimeError('Cannot get window extent without renderer')
        self.update_positions(self._renderer)
        text_bbox = Text.get_window_extent(self)
        bboxes = [text_bbox]
        if self.arrow_patch is not None:
            bboxes.append(self.arrow_patch.get_window_extent())
        return Bbox.union(bboxes)

    def get_tightbbox(self, renderer=None):
        if not self._check_xy(renderer):
            return Bbox.null()
        return super().get_tightbbox(renderer)
_docstring.interpd.update(Annotation=Annotation.__init__.__doc__)

# File: matplotlib-main/lib/matplotlib/textpath.py
from collections import OrderedDict
import logging
import urllib.parse
import numpy as np
from matplotlib import _text_helpers, dviread
from matplotlib.font_manager import FontProperties, get_font, fontManager as _fontManager
from matplotlib.ft2font import LOAD_NO_HINTING, LOAD_TARGET_LIGHT
from matplotlib.mathtext import MathTextParser
from matplotlib.path import Path
from matplotlib.texmanager import TexManager
from matplotlib.transforms import Affine2D
_log = logging.getLogger(__name__)

class TextToPath:
    FONT_SCALE = 100.0
    DPI = 72

    def __init__(self):
        self.mathtext_parser = MathTextParser('path')
        self._texmanager = None

    def _get_font(self, prop):
        filenames = _fontManager._find_fonts_by_props(prop)
        font = get_font(filenames)
        font.set_size(self.FONT_SCALE, self.DPI)
        return font

    def _get_hinting_flag(self):
        return LOAD_NO_HINTING

    def _get_char_id(self, font, ccode):
        return urllib.parse.quote(f'{font.postscript_name}-{ccode:x}')

    def get_text_width_height_descent(self, s, prop, ismath):
        fontsize = prop.get_size_in_points()
        if ismath == 'TeX':
            return TexManager().get_text_width_height_descent(s, fontsize)
        scale = fontsize / self.FONT_SCALE
        if ismath:
            prop = prop.copy()
            prop.set_size(self.FONT_SCALE)
            (width, height, descent, *_) = self.mathtext_parser.parse(s, 72, prop)
            return (width * scale, height * scale, descent * scale)
        font = self._get_font(prop)
        font.set_text(s, 0.0, flags=LOAD_NO_HINTING)
        (w, h) = font.get_width_height()
        w /= 64.0
        h /= 64.0
        d = font.get_descent()
        d /= 64.0
        return (w * scale, h * scale, d * scale)

    def get_text_path(self, prop, s, ismath=False):
        if ismath == 'TeX':
            (glyph_info, glyph_map, rects) = self.get_glyphs_tex(prop, s)
        elif not ismath:
            font = self._get_font(prop)
            (glyph_info, glyph_map, rects) = self.get_glyphs_with_font(font, s)
        else:
            (glyph_info, glyph_map, rects) = self.get_glyphs_mathtext(prop, s)
        (verts, codes) = ([], [])
        for (glyph_id, xposition, yposition, scale) in glyph_info:
            (verts1, codes1) = glyph_map[glyph_id]
            verts.extend(verts1 * scale + [xposition, yposition])
            codes.extend(codes1)
        for (verts1, codes1) in rects:
            verts.extend(verts1)
            codes.extend(codes1)
        if not verts:
            verts = np.empty((0, 2))
        return (verts, codes)

    def get_glyphs_with_font(self, font, s, glyph_map=None, return_new_glyphs_only=False):
        if glyph_map is None:
            glyph_map = OrderedDict()
        if return_new_glyphs_only:
            glyph_map_new = OrderedDict()
        else:
            glyph_map_new = glyph_map
        xpositions = []
        glyph_ids = []
        for item in _text_helpers.layout(s, font):
            char_id = self._get_char_id(item.ft_object, ord(item.char))
            glyph_ids.append(char_id)
            xpositions.append(item.x)
            if char_id not in glyph_map:
                glyph_map_new[char_id] = item.ft_object.get_path()
        ypositions = [0] * len(xpositions)
        sizes = [1.0] * len(xpositions)
        rects = []
        return (list(zip(glyph_ids, xpositions, ypositions, sizes)), glyph_map_new, rects)

    def get_glyphs_mathtext(self, prop, s, glyph_map=None, return_new_glyphs_only=False):
        prop = prop.copy()
        prop.set_size(self.FONT_SCALE)
        (width, height, descent, glyphs, rects) = self.mathtext_parser.parse(s, self.DPI, prop)
        if not glyph_map:
            glyph_map = OrderedDict()
        if return_new_glyphs_only:
            glyph_map_new = OrderedDict()
        else:
            glyph_map_new = glyph_map
        xpositions = []
        ypositions = []
        glyph_ids = []
        sizes = []
        for (font, fontsize, ccode, ox, oy) in glyphs:
            char_id = self._get_char_id(font, ccode)
            if char_id not in glyph_map:
                font.clear()
                font.set_size(self.FONT_SCALE, self.DPI)
                font.load_char(ccode, flags=LOAD_NO_HINTING)
                glyph_map_new[char_id] = font.get_path()
            xpositions.append(ox)
            ypositions.append(oy)
            glyph_ids.append(char_id)
            size = fontsize / self.FONT_SCALE
            sizes.append(size)
        myrects = []
        for (ox, oy, w, h) in rects:
            vert1 = [(ox, oy), (ox, oy + h), (ox + w, oy + h), (ox + w, oy), (ox, oy), (0, 0)]
            code1 = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
            myrects.append((vert1, code1))
        return (list(zip(glyph_ids, xpositions, ypositions, sizes)), glyph_map_new, myrects)

    def get_glyphs_tex(self, prop, s, glyph_map=None, return_new_glyphs_only=False):
        dvifile = TexManager().make_dvi(s, self.FONT_SCALE)
        with dviread.Dvi(dvifile, self.DPI) as dvi:
            (page,) = dvi
        if glyph_map is None:
            glyph_map = OrderedDict()
        if return_new_glyphs_only:
            glyph_map_new = OrderedDict()
        else:
            glyph_map_new = glyph_map
        (glyph_ids, xpositions, ypositions, sizes) = ([], [], [], [])
        for text in page.text:
            font = get_font(text.font_path)
            char_id = self._get_char_id(font, text.glyph)
            if char_id not in glyph_map:
                font.clear()
                font.set_size(self.FONT_SCALE, self.DPI)
                glyph_name_or_index = text.glyph_name_or_index
                if isinstance(glyph_name_or_index, str):
                    index = font.get_name_index(glyph_name_or_index)
                    font.load_glyph(index, flags=LOAD_TARGET_LIGHT)
                elif isinstance(glyph_name_or_index, int):
                    self._select_native_charmap(font)
                    font.load_char(glyph_name_or_index, flags=LOAD_TARGET_LIGHT)
                else:
                    raise TypeError(f'Glyph spec of unexpected type: {glyph_name_or_index!r}')
                glyph_map_new[char_id] = font.get_path()
            glyph_ids.append(char_id)
            xpositions.append(text.x)
            ypositions.append(text.y)
            sizes.append(text.font_size / self.FONT_SCALE)
        myrects = []
        for (ox, oy, h, w) in page.boxes:
            vert1 = [(ox, oy), (ox + w, oy), (ox + w, oy + h), (ox, oy + h), (ox, oy), (0, 0)]
            code1 = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
            myrects.append((vert1, code1))
        return (list(zip(glyph_ids, xpositions, ypositions, sizes)), glyph_map_new, myrects)

    @staticmethod
    def _select_native_charmap(font):
        for charmap_code in [1094992451, 1094995778]:
            try:
                font.select_charmap(charmap_code)
            except (ValueError, RuntimeError):
                pass
            else:
                break
        else:
            _log.warning('No supported encoding in font (%s).', font.fname)
text_to_path = TextToPath()

class TextPath(Path):

    def __init__(self, xy, s, size=None, prop=None, _interpolation_steps=1, usetex=False):
        from matplotlib.text import Text
        prop = FontProperties._from_any(prop)
        if size is None:
            size = prop.get_size_in_points()
        self._xy = xy
        self.set_size(size)
        self._cached_vertices = None
        (s, ismath) = Text(usetex=usetex)._preprocess_math(s)
        super().__init__(*text_to_path.get_text_path(prop, s, ismath=ismath), _interpolation_steps=_interpolation_steps, readonly=True)
        self._should_simplify = False

    def set_size(self, size):
        self._size = size
        self._invalid = True

    def get_size(self):
        return self._size

    @property
    def vertices(self):
        self._revalidate_path()
        return self._cached_vertices

    @property
    def codes(self):
        return self._codes

    def _revalidate_path(self):
        if self._invalid or self._cached_vertices is None:
            tr = Affine2D().scale(self._size / text_to_path.FONT_SCALE).translate(*self._xy)
            self._cached_vertices = tr.transform(self._vertices)
            self._cached_vertices.flags.writeable = False
            self._invalid = False

# File: matplotlib-main/lib/matplotlib/ticker.py
""""""
import itertools
import logging
import locale
import math
from numbers import Integral
import string
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
from matplotlib import transforms as mtransforms
_log = logging.getLogger(__name__)
__all__ = ('TickHelper', 'Formatter', 'FixedFormatter', 'NullFormatter', 'FuncFormatter', 'FormatStrFormatter', 'StrMethodFormatter', 'ScalarFormatter', 'LogFormatter', 'LogFormatterExponent', 'LogFormatterMathtext', 'LogFormatterSciNotation', 'LogitFormatter', 'EngFormatter', 'PercentFormatter', 'Locator', 'IndexLocator', 'FixedLocator', 'NullLocator', 'LinearLocator', 'LogLocator', 'AutoLocator', 'MultipleLocator', 'MaxNLocator', 'AutoMinorLocator', 'SymmetricalLogLocator', 'AsinhLocator', 'LogitLocator')

class _DummyAxis:
    __name__ = 'dummy'

    def __init__(self, minpos=0):
        self._data_interval = (0, 1)
        self._view_interval = (0, 1)
        self._minpos = minpos

    def get_view_interval(self):
        return self._view_interval

    def set_view_interval(self, vmin, vmax):
        self._view_interval = (vmin, vmax)

    def get_minpos(self):
        return self._minpos

    def get_data_interval(self):
        return self._data_interval

    def set_data_interval(self, vmin, vmax):
        self._data_interval = (vmin, vmax)

    def get_tick_space(self):
        return 9

class TickHelper:
    axis = None

    def set_axis(self, axis):
        self.axis = axis

    def create_dummy_axis(self, **kwargs):
        if self.axis is None:
            self.axis = _DummyAxis(**kwargs)

class Formatter(TickHelper):
    locs = []

    def __call__(self, x, pos=None):
        raise NotImplementedError('Derived must override')

    def format_ticks(self, values):
        self.set_locs(values)
        return [self(value, i) for (i, value) in enumerate(values)]

    def format_data(self, value):
        return self.__call__(value)

    def format_data_short(self, value):
        return self.format_data(value)

    def get_offset(self):
        return ''

    def set_locs(self, locs):
        self.locs = locs

    @staticmethod
    def fix_minus(s):
        return s.replace('-', '−') if mpl.rcParams['axes.unicode_minus'] else s

    def _set_locator(self, locator):
        pass

class NullFormatter(Formatter):

    def __call__(self, x, pos=None):
        return ''

class FixedFormatter(Formatter):

    def __init__(self, seq):
        self.seq = seq
        self.offset_string = ''

    def __call__(self, x, pos=None):
        if pos is None or pos >= len(self.seq):
            return ''
        else:
            return self.seq[pos]

    def get_offset(self):
        return self.offset_string

    def set_offset_string(self, ofs):
        self.offset_string = ofs

class FuncFormatter(Formatter):

    def __init__(self, func):
        self.func = func
        self.offset_string = ''

    def __call__(self, x, pos=None):
        return self.func(x, pos)

    def get_offset(self):
        return self.offset_string

    def set_offset_string(self, ofs):
        self.offset_string = ofs

class FormatStrFormatter(Formatter):

    def __init__(self, fmt):
        self.fmt = fmt

    def __call__(self, x, pos=None):
        return self.fmt % x

class _UnicodeMinusFormat(string.Formatter):

    def format_field(self, value, format_spec):
        return Formatter.fix_minus(super().format_field(value, format_spec))

class StrMethodFormatter(Formatter):

    def __init__(self, fmt):
        self.fmt = fmt

    def __call__(self, x, pos=None):
        return _UnicodeMinusFormat().format(self.fmt, x=x, pos=pos)

class ScalarFormatter(Formatter):

    def __init__(self, useOffset=None, useMathText=None, useLocale=None):
        if useOffset is None:
            useOffset = mpl.rcParams['axes.formatter.useoffset']
        self._offset_threshold = mpl.rcParams['axes.formatter.offset_threshold']
        self.set_useOffset(useOffset)
        self._usetex = mpl.rcParams['text.usetex']
        self.set_useMathText(useMathText)
        self.orderOfMagnitude = 0
        self.format = ''
        self._scientific = True
        self._powerlimits = mpl.rcParams['axes.formatter.limits']
        self.set_useLocale(useLocale)

    def get_useOffset(self):
        return self._useOffset

    def set_useOffset(self, val):
        if val in [True, False]:
            self.offset = 0
            self._useOffset = val
        else:
            self._useOffset = False
            self.offset = val
    useOffset = property(fget=get_useOffset, fset=set_useOffset)

    def get_useLocale(self):
        return self._useLocale

    def set_useLocale(self, val):
        if val is None:
            self._useLocale = mpl.rcParams['axes.formatter.use_locale']
        else:
            self._useLocale = val
    useLocale = property(fget=get_useLocale, fset=set_useLocale)

    def _format_maybe_minus_and_locale(self, fmt, arg):
        return self.fix_minus((','.join((locale.format_string(part, (arg,), True).replace(',', '{,}') for part in fmt.split(','))) if self._useMathText else locale.format_string(fmt, (arg,), True)) if self._useLocale else fmt % arg)

    def get_useMathText(self):
        return self._useMathText

    def set_useMathText(self, val):
        if val is None:
            self._useMathText = mpl.rcParams['axes.formatter.use_mathtext']
            if self._useMathText is False:
                try:
                    from matplotlib import font_manager
                    ufont = font_manager.findfont(font_manager.FontProperties(mpl.rcParams['font.family']), fallback_to_default=False)
                except ValueError:
                    ufont = None
                if ufont == str(cbook._get_data_path('fonts/ttf/cmr10.ttf')):
                    _api.warn_external('cmr10 font should ideally be used with mathtext, set axes.formatter.use_mathtext to True')
        else:
            self._useMathText = val
    useMathText = property(fget=get_useMathText, fset=set_useMathText)

    def __call__(self, x, pos=None):
        if len(self.locs) == 0:
            return ''
        else:
            xp = (x - self.offset) / 10.0 ** self.orderOfMagnitude
            if abs(xp) < 1e-08:
                xp = 0
            return self._format_maybe_minus_and_locale(self.format, xp)

    def set_scientific(self, b):
        self._scientific = bool(b)

    def set_powerlimits(self, lims):
        if len(lims) != 2:
            raise ValueError("'lims' must be a sequence of length 2")
        self._powerlimits = lims

    def format_data_short(self, value):
        if value is np.ma.masked:
            return ''
        if isinstance(value, Integral):
            fmt = '%d'
        else:
            if getattr(self.axis, '__name__', '') in ['xaxis', 'yaxis']:
                if self.axis.__name__ == 'xaxis':
                    axis_trf = self.axis.axes.get_xaxis_transform()
                    axis_inv_trf = axis_trf.inverted()
                    screen_xy = axis_trf.transform((value, 0))
                    neighbor_values = axis_inv_trf.transform(screen_xy + [[-1, 0], [+1, 0]])[:, 0]
                else:
                    axis_trf = self.axis.axes.get_yaxis_transform()
                    axis_inv_trf = axis_trf.inverted()
                    screen_xy = axis_trf.transform((0, value))
                    neighbor_values = axis_inv_trf.transform(screen_xy + [[0, -1], [0, +1]])[:, 1]
                delta = abs(neighbor_values - value).max()
            else:
                (a, b) = self.axis.get_view_interval()
                delta = (b - a) / 10000.0
            fmt = f'%-#.{cbook._g_sig_digits(value, delta)}g'
        return self._format_maybe_minus_and_locale(fmt, value)

    def format_data(self, value):
        e = math.floor(math.log10(abs(value)))
        s = round(value / 10 ** e, 10)
        significand = self._format_maybe_minus_and_locale('%d' if s % 1 == 0 else '%1.10g', s)
        if e == 0:
            return significand
        exponent = self._format_maybe_minus_and_locale('%d', e)
        if self._useMathText or self._usetex:
            exponent = '10^{%s}' % exponent
            return exponent if s == 1 else f'{significand} \\times {exponent}'
        else:
            return f'{significand}e{exponent}'

    def get_offset(self):
        if len(self.locs) == 0:
            return ''
        if self.orderOfMagnitude or self.offset:
            offsetStr = ''
            sciNotStr = ''
            if self.offset:
                offsetStr = self.format_data(self.offset)
                if self.offset > 0:
                    offsetStr = '+' + offsetStr
            if self.orderOfMagnitude:
                if self._usetex or self._useMathText:
                    sciNotStr = self.format_data(10 ** self.orderOfMagnitude)
                else:
                    sciNotStr = '1e%d' % self.orderOfMagnitude
            if self._useMathText or self._usetex:
                if sciNotStr != '':
                    sciNotStr = '\\times\\mathdefault{%s}' % sciNotStr
                s = f'${sciNotStr}\\mathdefault{{{offsetStr}}}$'
            else:
                s = ''.join((sciNotStr, offsetStr))
            return self.fix_minus(s)
        return ''

    def set_locs(self, locs):
        self.locs = locs
        if len(self.locs) > 0:
            if self._useOffset:
                self._compute_offset()
            self._set_order_of_magnitude()
            self._set_format()

    def _compute_offset(self):
        locs = self.locs
        (vmin, vmax) = sorted(self.axis.get_view_interval())
        locs = np.asarray(locs)
        locs = locs[(vmin <= locs) & (locs <= vmax)]
        if not len(locs):
            self.offset = 0
            return
        (lmin, lmax) = (locs.min(), locs.max())
        if lmin == lmax or lmin <= 0 <= lmax:
            self.offset = 0
            return
        (abs_min, abs_max) = sorted([abs(float(lmin)), abs(float(lmax))])
        sign = math.copysign(1, lmin)
        oom_max = np.ceil(math.log10(abs_max))
        oom = 1 + next((oom for oom in itertools.count(oom_max, -1) if abs_min // 10 ** oom != abs_max // 10 ** oom))
        if (abs_max - abs_min) / 10 ** oom <= 0.01:
            oom = 1 + next((oom for oom in itertools.count(oom_max, -1) if abs_max // 10 ** oom - abs_min // 10 ** oom > 1))
        n = self._offset_threshold - 1
        self.offset = sign * (abs_max // 10 ** oom) * 10 ** oom if abs_max // 10 ** oom >= 10 ** n else 0

    def _set_order_of_magnitude(self):
        if not self._scientific:
            self.orderOfMagnitude = 0
            return
        if self._powerlimits[0] == self._powerlimits[1] != 0:
            self.orderOfMagnitude = self._powerlimits[0]
            return
        (vmin, vmax) = sorted(self.axis.get_view_interval())
        locs = np.asarray(self.locs)
        locs = locs[(vmin <= locs) & (locs <= vmax)]
        locs = np.abs(locs)
        if not len(locs):
            self.orderOfMagnitude = 0
            return
        if self.offset:
            oom = math.floor(math.log10(vmax - vmin))
        else:
            val = locs.max()
            if val == 0:
                oom = 0
            else:
                oom = math.floor(math.log10(val))
        if oom <= self._powerlimits[0]:
            self.orderOfMagnitude = oom
        elif oom >= self._powerlimits[1]:
            self.orderOfMagnitude = oom
        else:
            self.orderOfMagnitude = 0

    def _set_format(self):
        if len(self.locs) < 2:
            _locs = [*self.locs, *self.axis.get_view_interval()]
        else:
            _locs = self.locs
        locs = (np.asarray(_locs) - self.offset) / 10.0 ** self.orderOfMagnitude
        loc_range = np.ptp(locs)
        if loc_range == 0:
            loc_range = np.max(np.abs(locs))
        if loc_range == 0:
            loc_range = 1
        if len(self.locs) < 2:
            locs = locs[:-2]
        loc_range_oom = int(math.floor(math.log10(loc_range)))
        sigfigs = max(0, 3 - loc_range_oom)
        thresh = 0.001 * 10 ** loc_range_oom
        while sigfigs >= 0:
            if np.abs(locs - np.round(locs, decimals=sigfigs)).max() < thresh:
                sigfigs -= 1
            else:
                break
        sigfigs += 1
        self.format = f'%1.{sigfigs}f'
        if self._usetex or self._useMathText:
            self.format = '$\\mathdefault{%s}$' % self.format

class LogFormatter(Formatter):

    def __init__(self, base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None):
        self.set_base(base)
        self.set_label_minor(labelOnlyBase)
        if minor_thresholds is None:
            if mpl.rcParams['_internal.classic_mode']:
                minor_thresholds = (0, 0)
            else:
                minor_thresholds = (1, 0.4)
        self.minor_thresholds = minor_thresholds
        self._sublabels = None
        self._linthresh = linthresh

    def set_base(self, base):
        self._base = float(base)

    def set_label_minor(self, labelOnlyBase):
        self.labelOnlyBase = labelOnlyBase

    def set_locs(self, locs=None):
        if np.isinf(self.minor_thresholds[0]):
            self._sublabels = None
            return
        linthresh = self._linthresh
        if linthresh is None:
            try:
                linthresh = self.axis.get_transform().linthresh
            except AttributeError:
                pass
        (vmin, vmax) = self.axis.get_view_interval()
        if vmin > vmax:
            (vmin, vmax) = (vmax, vmin)
        if linthresh is None and vmin <= 0:
            self._sublabels = {1}
            return
        b = self._base
        if linthresh is not None:
            numdec = 0
            if vmin < -linthresh:
                rhs = min(vmax, -linthresh)
                numdec += math.log(vmin / rhs) / math.log(b)
            if vmax > linthresh:
                lhs = max(vmin, linthresh)
                numdec += math.log(vmax / lhs) / math.log(b)
        else:
            vmin = math.log(vmin) / math.log(b)
            vmax = math.log(vmax) / math.log(b)
            numdec = abs(vmax - vmin)
        if numdec > self.minor_thresholds[0]:
            self._sublabels = {1}
        elif numdec > self.minor_thresholds[1]:
            c = np.geomspace(1, b, int(b) // 2 + 1)
            self._sublabels = set(np.round(c))
        else:
            self._sublabels = set(np.arange(1, b + 1))

    def _num_to_string(self, x, vmin, vmax):
        if x > 10000:
            s = '%1.0e' % x
        elif x < 1:
            s = '%1.0e' % x
        else:
            s = self._pprint_val(x, vmax - vmin)
        return s

    def __call__(self, x, pos=None):
        if x == 0.0:
            return '0'
        x = abs(x)
        b = self._base
        fx = math.log(x) / math.log(b)
        is_x_decade = _is_close_to_int(fx)
        exponent = round(fx) if is_x_decade else np.floor(fx)
        coeff = round(b ** (fx - exponent))
        if self.labelOnlyBase and (not is_x_decade):
            return ''
        if self._sublabels is not None and coeff not in self._sublabels:
            return ''
        (vmin, vmax) = self.axis.get_view_interval()
        (vmin, vmax) = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        s = self._num_to_string(x, vmin, vmax)
        return self.fix_minus(s)

    def format_data(self, value):
        with cbook._setattr_cm(self, labelOnlyBase=False):
            return cbook.strip_math(self.__call__(value))

    def format_data_short(self, value):
        return ('%-12g' % value).rstrip()

    def _pprint_val(self, x, d):
        if abs(x) < 10000.0 and x == int(x):
            return '%d' % x
        fmt = '%1.3e' if d < 0.01 else '%1.3f' if d <= 1 else '%1.2f' if d <= 10 else '%1.1f' if d <= 100000.0 else '%1.1e'
        s = fmt % x
        tup = s.split('e')
        if len(tup) == 2:
            mantissa = tup[0].rstrip('0').rstrip('.')
            exponent = int(tup[1])
            if exponent:
                s = '%se%d' % (mantissa, exponent)
            else:
                s = mantissa
        else:
            s = s.rstrip('0').rstrip('.')
        return s

class LogFormatterExponent(LogFormatter):

    def _num_to_string(self, x, vmin, vmax):
        fx = math.log(x) / math.log(self._base)
        if abs(fx) > 10000:
            s = '%1.0g' % fx
        elif abs(fx) < 1:
            s = '%1.0g' % fx
        else:
            fd = math.log(vmax - vmin) / math.log(self._base)
            s = self._pprint_val(fx, fd)
        return s

class LogFormatterMathtext(LogFormatter):

    def _non_decade_format(self, sign_string, base, fx, usetex):
        return '$\\mathdefault{%s%s^{%.2f}}$' % (sign_string, base, fx)

    def __call__(self, x, pos=None):
        if x == 0:
            return '$\\mathdefault{0}$'
        sign_string = '-' if x < 0 else ''
        x = abs(x)
        b = self._base
        fx = math.log(x) / math.log(b)
        is_x_decade = _is_close_to_int(fx)
        exponent = round(fx) if is_x_decade else np.floor(fx)
        coeff = round(b ** (fx - exponent))
        if self.labelOnlyBase and (not is_x_decade):
            return ''
        if self._sublabels is not None and coeff not in self._sublabels:
            return ''
        if is_x_decade:
            fx = round(fx)
        if b % 1 == 0.0:
            base = '%d' % b
        else:
            base = '%s' % b
        if abs(fx) < mpl.rcParams['axes.formatter.min_exponent']:
            return '$\\mathdefault{%s%g}$' % (sign_string, x)
        elif not is_x_decade:
            usetex = mpl.rcParams['text.usetex']
            return self._non_decade_format(sign_string, base, fx, usetex)
        else:
            return '$\\mathdefault{%s%s^{%d}}$' % (sign_string, base, fx)

class LogFormatterSciNotation(LogFormatterMathtext):

    def _non_decade_format(self, sign_string, base, fx, usetex):
        b = float(base)
        exponent = math.floor(fx)
        coeff = b ** (fx - exponent)
        if _is_close_to_int(coeff):
            coeff = round(coeff)
        return '$\\mathdefault{%s%g\\times%s^{%d}}$' % (sign_string, coeff, base, exponent)

class LogitFormatter(Formatter):

    def __init__(self, *, use_overline=False, one_half='\\frac{1}{2}', minor=False, minor_threshold=25, minor_number=6):
        self._use_overline = use_overline
        self._one_half = one_half
        self._minor = minor
        self._labelled = set()
        self._minor_threshold = minor_threshold
        self._minor_number = minor_number

    def use_overline(self, use_overline):
        self._use_overline = use_overline

    def set_one_half(self, one_half):
        self._one_half = one_half

    def set_minor_threshold(self, minor_threshold):
        self._minor_threshold = minor_threshold

    def set_minor_number(self, minor_number):
        self._minor_number = minor_number

    def set_locs(self, locs):
        self.locs = np.array(locs)
        self._labelled.clear()
        if not self._minor:
            return None
        if all((_is_decade(x, rtol=1e-07) or _is_decade(1 - x, rtol=1e-07) or (_is_close_to_int(2 * x) and int(np.round(2 * x)) == 1) for x in locs)):
            return None
        if len(locs) < self._minor_threshold:
            if len(locs) < self._minor_number:
                self._labelled.update(locs)
            else:
                diff = np.diff(-np.log(1 / self.locs - 1))
                space_pessimistic = np.minimum(np.concatenate(((np.inf,), diff)), np.concatenate((diff, (np.inf,))))
                space_sum = np.concatenate(((0,), diff)) + np.concatenate((diff, (0,)))
                good_minor = sorted(range(len(self.locs)), key=lambda i: (space_pessimistic[i], space_sum[i]))[-self._minor_number:]
                self._labelled.update((locs[i] for i in good_minor))

    def _format_value(self, x, locs, sci_notation=True):
        if sci_notation:
            exponent = math.floor(np.log10(x))
            min_precision = 0
        else:
            exponent = 0
            min_precision = 1
        value = x * 10 ** (-exponent)
        if len(locs) < 2:
            precision = min_precision
        else:
            diff = np.sort(np.abs(locs - x))[1]
            precision = -np.log10(diff) + exponent
            precision = int(np.round(precision)) if _is_close_to_int(precision) else math.ceil(precision)
            if precision < min_precision:
                precision = min_precision
        mantissa = '%.*f' % (precision, value)
        if not sci_notation:
            return mantissa
        s = '%s\\cdot10^{%d}' % (mantissa, exponent)
        return s

    def _one_minus(self, s):
        if self._use_overline:
            return '\\overline{%s}' % s
        else:
            return f'1-{s}'

    def __call__(self, x, pos=None):
        if self._minor and x not in self._labelled:
            return ''
        if x <= 0 or x >= 1:
            return ''
        if _is_close_to_int(2 * x) and round(2 * x) == 1:
            s = self._one_half
        elif x < 0.5 and _is_decade(x, rtol=1e-07):
            exponent = round(math.log10(x))
            s = '10^{%d}' % exponent
        elif x > 0.5 and _is_decade(1 - x, rtol=1e-07):
            exponent = round(math.log10(1 - x))
            s = self._one_minus('10^{%d}' % exponent)
        elif x < 0.1:
            s = self._format_value(x, self.locs)
        elif x > 0.9:
            s = self._one_minus(self._format_value(1 - x, 1 - self.locs))
        else:
            s = self._format_value(x, self.locs, sci_notation=False)
        return '$\\mathdefault{%s}$' % s

    def format_data_short(self, value):
        if value < 0.1:
            return f'{value:e}'
        if value < 0.9:
            return f'{value:f}'
        return f'1-{1 - value:e}'

class EngFormatter(Formatter):
    ENG_PREFIXES = {-30: 'q', -27: 'r', -24: 'y', -21: 'z', -18: 'a', -15: 'f', -12: 'p', -9: 'n', -6: 'µ', -3: 'm', 0: '', 3: 'k', 6: 'M', 9: 'G', 12: 'T', 15: 'P', 18: 'E', 21: 'Z', 24: 'Y', 27: 'R', 30: 'Q'}

    def __init__(self, unit='', places=None, sep=' ', *, usetex=None, useMathText=None):
        self.unit = unit
        self.places = places
        self.sep = sep
        self.set_usetex(usetex)
        self.set_useMathText(useMathText)

    def get_usetex(self):
        return self._usetex

    def set_usetex(self, val):
        if val is None:
            self._usetex = mpl.rcParams['text.usetex']
        else:
            self._usetex = val
    usetex = property(fget=get_usetex, fset=set_usetex)

    def get_useMathText(self):
        return self._useMathText

    def set_useMathText(self, val):
        if val is None:
            self._useMathText = mpl.rcParams['axes.formatter.use_mathtext']
        else:
            self._useMathText = val
    useMathText = property(fget=get_useMathText, fset=set_useMathText)

    def __call__(self, x, pos=None):
        s = f'{self.format_eng(x)}{self.unit}'
        if self.sep and s.endswith(self.sep):
            s = s[:-len(self.sep)]
        return self.fix_minus(s)

    def format_eng(self, num):
        sign = 1
        fmt = 'g' if self.places is None else f'.{self.places:d}f'
        if num < 0:
            sign = -1
            num = -num
        if num != 0:
            pow10 = int(math.floor(math.log10(num) / 3) * 3)
        else:
            pow10 = 0
            num = 0.0
        pow10 = np.clip(pow10, min(self.ENG_PREFIXES), max(self.ENG_PREFIXES))
        mant = sign * num / 10.0 ** pow10
        if abs(float(format(mant, fmt))) >= 1000 and pow10 < max(self.ENG_PREFIXES):
            mant /= 1000
            pow10 += 3
        prefix = self.ENG_PREFIXES[int(pow10)]
        if self._usetex or self._useMathText:
            formatted = f'${mant:{fmt}}${self.sep}{prefix}'
        else:
            formatted = f'{mant:{fmt}}{self.sep}{prefix}'
        return formatted

class PercentFormatter(Formatter):

    def __init__(self, xmax=100, decimals=None, symbol='%', is_latex=False):
        self.xmax = xmax + 0.0
        self.decimals = decimals
        self._symbol = symbol
        self._is_latex = is_latex

    def __call__(self, x, pos=None):
        (ax_min, ax_max) = self.axis.get_view_interval()
        display_range = abs(ax_max - ax_min)
        return self.fix_minus(self.format_pct(x, display_range))

    def format_pct(self, x, display_range):
        x = self.convert_to_pct(x)
        if self.decimals is None:
            scaled_range = self.convert_to_pct(display_range)
            if scaled_range <= 0:
                decimals = 0
            else:
                decimals = math.ceil(2.0 - math.log10(2.0 * scaled_range))
                if decimals > 5:
                    decimals = 5
                elif decimals < 0:
                    decimals = 0
        else:
            decimals = self.decimals
        s = f'{x:0.{int(decimals)}f}'
        return s + self.symbol

    def convert_to_pct(self, x):
        return 100.0 * (x / self.xmax)

    @property
    def symbol(self):
        symbol = self._symbol
        if not symbol:
            symbol = ''
        elif not self._is_latex and mpl.rcParams['text.usetex']:
            for spec in '\\#$%&~_^{}':
                symbol = symbol.replace(spec, '\\' + spec)
        return symbol

    @symbol.setter
    def symbol(self, symbol):
        self._symbol = symbol

class Locator(TickHelper):
    MAXTICKS = 1000

    def tick_values(self, vmin, vmax):
        raise NotImplementedError('Derived must override')

    def set_params(self, **kwargs):
        _api.warn_external("'set_params()' not defined for locator of type " + str(type(self)))

    def __call__(self):
        raise NotImplementedError('Derived must override')

    def raise_if_exceeds(self, locs):
        if len(locs) >= self.MAXTICKS:
            _log.warning('Locator attempting to generate %s ticks ([%s, ..., %s]), which exceeds Locator.MAXTICKS (%s).', len(locs), locs[0], locs[-1], self.MAXTICKS)
        return locs

    def nonsingular(self, v0, v1):
        return mtransforms.nonsingular(v0, v1, expander=0.05)

    def view_limits(self, vmin, vmax):
        return mtransforms.nonsingular(vmin, vmax)

class IndexLocator(Locator):

    def __init__(self, base, offset):
        self._base = base
        self.offset = offset

    def set_params(self, base=None, offset=None):
        if base is not None:
            self._base = base
        if offset is not None:
            self.offset = offset

    def __call__(self):
        (dmin, dmax) = self.axis.get_data_interval()
        return self.tick_values(dmin, dmax)

    def tick_values(self, vmin, vmax):
        return self.raise_if_exceeds(np.arange(vmin + self.offset, vmax + 1, self._base))

class FixedLocator(Locator):

    def __init__(self, locs, nbins=None):
        self.locs = np.asarray(locs)
        _api.check_shape((None,), locs=self.locs)
        self.nbins = max(nbins, 2) if nbins is not None else None

    def set_params(self, nbins=None):
        if nbins is not None:
            self.nbins = nbins

    def __call__(self):
        return self.tick_values(None, None)

    def tick_values(self, vmin, vmax):
        if self.nbins is None:
            return self.locs
        step = max(int(np.ceil(len(self.locs) / self.nbins)), 1)
        ticks = self.locs[::step]
        for i in range(1, step):
            ticks1 = self.locs[i::step]
            if np.abs(ticks1).min() < np.abs(ticks).min():
                ticks = ticks1
        return self.raise_if_exceeds(ticks)

class NullLocator(Locator):

    def __call__(self):
        return self.tick_values(None, None)

    def tick_values(self, vmin, vmax):
        return []

class LinearLocator(Locator):

    def __init__(self, numticks=None, presets=None):
        self.numticks = numticks
        if presets is None:
            self.presets = {}
        else:
            self.presets = presets

    @property
    def numticks(self):
        return self._numticks if self._numticks is not None else 11

    @numticks.setter
    def numticks(self, numticks):
        self._numticks = numticks

    def set_params(self, numticks=None, presets=None):
        if presets is not None:
            self.presets = presets
        if numticks is not None:
            self.numticks = numticks

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        (vmin, vmax) = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        if (vmin, vmax) in self.presets:
            return self.presets[vmin, vmax]
        if self.numticks == 0:
            return []
        ticklocs = np.linspace(vmin, vmax, self.numticks)
        return self.raise_if_exceeds(ticklocs)

    def view_limits(self, vmin, vmax):
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        if vmin == vmax:
            vmin -= 1
            vmax += 1
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            (exponent, remainder) = divmod(math.log10(vmax - vmin), math.log10(max(self.numticks - 1, 1)))
            exponent -= remainder < 0.5
            scale = max(self.numticks - 1, 1) ** (-exponent)
            vmin = math.floor(scale * vmin) / scale
            vmax = math.ceil(scale * vmax) / scale
        return mtransforms.nonsingular(vmin, vmax)

class MultipleLocator(Locator):

    def __init__(self, base=1.0, offset=0.0):
        self._edge = _Edge_integer(base, 0)
        self._offset = offset

    def set_params(self, base=None, offset=None):
        if base is not None:
            self._edge = _Edge_integer(base, 0)
        if offset is not None:
            self._offset = offset

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        step = self._edge.step
        vmin -= self._offset
        vmax -= self._offset
        vmin = self._edge.ge(vmin) * step
        n = (vmax - vmin + 0.001 * step) // step
        locs = vmin - step + np.arange(n + 3) * step + self._offset
        return self.raise_if_exceeds(locs)

    def view_limits(self, dmin, dmax):
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            vmin = self._edge.le(dmin - self._offset) * self._edge.step + self._offset
            vmax = self._edge.ge(dmax - self._offset) * self._edge.step + self._offset
            if vmin == vmax:
                vmin -= 1
                vmax += 1
        else:
            vmin = dmin
            vmax = dmax
        return mtransforms.nonsingular(vmin, vmax)

def scale_range(vmin, vmax, n=1, threshold=100):
    dv = abs(vmax - vmin)
    meanv = (vmax + vmin) / 2
    if abs(meanv) / dv < threshold:
        offset = 0
    else:
        offset = math.copysign(10 ** (math.log10(abs(meanv)) // 1), meanv)
    scale = 10 ** (math.log10(dv / n) // 1)
    return (scale, offset)

class _Edge_integer:

    def __init__(self, step, offset):
        if step <= 0:
            raise ValueError("'step' must be positive")
        self.step = step
        self._offset = abs(offset)

    def closeto(self, ms, edge):
        if self._offset > 0:
            digits = np.log10(self._offset / self.step)
            tol = max(1e-10, 10 ** (digits - 12))
            tol = min(0.4999, tol)
        else:
            tol = 1e-10
        return abs(ms - edge) < tol

    def le(self, x):
        (d, m) = divmod(x, self.step)
        if self.closeto(m / self.step, 1):
            return d + 1
        return d

    def ge(self, x):
        (d, m) = divmod(x, self.step)
        if self.closeto(m / self.step, 0):
            return d
        return d + 1

class MaxNLocator(Locator):
    default_params = dict(nbins=10, steps=None, integer=False, symmetric=False, prune=None, min_n_ticks=2)

    def __init__(self, nbins=None, **kwargs):
        if nbins is not None:
            kwargs['nbins'] = nbins
        self.set_params(**{**self.default_params, **kwargs})

    @staticmethod
    def _validate_steps(steps):
        if not np.iterable(steps):
            raise ValueError('steps argument must be an increasing sequence of numbers between 1 and 10 inclusive')
        steps = np.asarray(steps)
        if np.any(np.diff(steps) <= 0) or steps[-1] > 10 or steps[0] < 1:
            raise ValueError('steps argument must be an increasing sequence of numbers between 1 and 10 inclusive')
        if steps[0] != 1:
            steps = np.concatenate([[1], steps])
        if steps[-1] != 10:
            steps = np.concatenate([steps, [10]])
        return steps

    @staticmethod
    def _staircase(steps):
        return np.concatenate([0.1 * steps[:-1], steps, [10 * steps[1]]])

    def set_params(self, **kwargs):
        if 'nbins' in kwargs:
            self._nbins = kwargs.pop('nbins')
            if self._nbins != 'auto':
                self._nbins = int(self._nbins)
        if 'symmetric' in kwargs:
            self._symmetric = kwargs.pop('symmetric')
        if 'prune' in kwargs:
            prune = kwargs.pop('prune')
            _api.check_in_list(['upper', 'lower', 'both', None], prune=prune)
            self._prune = prune
        if 'min_n_ticks' in kwargs:
            self._min_n_ticks = max(1, kwargs.pop('min_n_ticks'))
        if 'steps' in kwargs:
            steps = kwargs.pop('steps')
            if steps is None:
                self._steps = np.array([1, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10])
            else:
                self._steps = self._validate_steps(steps)
            self._extended_steps = self._staircase(self._steps)
        if 'integer' in kwargs:
            self._integer = kwargs.pop('integer')
        if kwargs:
            raise _api.kwarg_error('set_params', kwargs)

    def _raw_ticks(self, vmin, vmax):
        if self._nbins == 'auto':
            if self.axis is not None:
                nbins = np.clip(self.axis.get_tick_space(), max(1, self._min_n_ticks - 1), 9)
            else:
                nbins = 9
        else:
            nbins = self._nbins
        (scale, offset) = scale_range(vmin, vmax, nbins)
        _vmin = vmin - offset
        _vmax = vmax - offset
        steps = self._extended_steps * scale
        if self._integer:
            igood = (steps < 1) | (np.abs(steps - np.round(steps)) < 0.001)
            steps = steps[igood]
        raw_step = (_vmax - _vmin) / nbins
        if hasattr(self.axis, 'axes') and self.axis.axes.name == '3d':
            raw_step = raw_step * 23 / 24
        large_steps = steps >= raw_step
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            floored_vmins = _vmin // steps * steps
            floored_vmaxs = floored_vmins + steps * nbins
            large_steps = large_steps & (floored_vmaxs >= _vmax)
        if any(large_steps):
            istep = np.nonzero(large_steps)[0][0]
        else:
            istep = len(steps) - 1
        for step in steps[:istep + 1][::-1]:
            if self._integer and np.floor(_vmax) - np.ceil(_vmin) >= self._min_n_ticks - 1:
                step = max(1, step)
            best_vmin = _vmin // step * step
            edge = _Edge_integer(step, offset)
            low = edge.le(_vmin - best_vmin)
            high = edge.ge(_vmax - best_vmin)
            ticks = np.arange(low, high + 1) * step + best_vmin
            nticks = ((ticks <= _vmax) & (ticks >= _vmin)).sum()
            if nticks >= self._min_n_ticks:
                break
        return ticks + offset

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        if self._symmetric:
            vmax = max(abs(vmin), abs(vmax))
            vmin = -vmax
        (vmin, vmax) = mtransforms.nonsingular(vmin, vmax, expander=1e-13, tiny=1e-14)
        locs = self._raw_ticks(vmin, vmax)
        prune = self._prune
        if prune == 'lower':
            locs = locs[1:]
        elif prune == 'upper':
            locs = locs[:-1]
        elif prune == 'both':
            locs = locs[1:-1]
        return self.raise_if_exceeds(locs)

    def view_limits(self, dmin, dmax):
        if self._symmetric:
            dmax = max(abs(dmin), abs(dmax))
            dmin = -dmax
        (dmin, dmax) = mtransforms.nonsingular(dmin, dmax, expander=1e-12, tiny=1e-13)
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            return self._raw_ticks(dmin, dmax)[[0, -1]]
        else:
            return (dmin, dmax)

def _is_decade(x, *, base=10, rtol=None):
    if not np.isfinite(x):
        return False
    if x == 0.0:
        return True
    lx = np.log(abs(x)) / np.log(base)
    if rtol is None:
        return np.isclose(lx, np.round(lx))
    else:
        return np.isclose(lx, np.round(lx), rtol=rtol)

def _decade_less_equal(x, base):
    return x if x == 0 else -_decade_greater_equal(-x, base) if x < 0 else base ** np.floor(np.log(x) / np.log(base))

def _decade_greater_equal(x, base):
    return x if x == 0 else -_decade_less_equal(-x, base) if x < 0 else base ** np.ceil(np.log(x) / np.log(base))

def _decade_less(x, base):
    if x < 0:
        return -_decade_greater(-x, base)
    less = _decade_less_equal(x, base)
    if less == x:
        less /= base
    return less

def _decade_greater(x, base):
    if x < 0:
        return -_decade_less(-x, base)
    greater = _decade_greater_equal(x, base)
    if greater == x:
        greater *= base
    return greater

def _is_close_to_int(x):
    return math.isclose(x, round(x))

class LogLocator(Locator):

    def __init__(self, base=10.0, subs=(1.0,), *, numticks=None):
        if numticks is None:
            if mpl.rcParams['_internal.classic_mode']:
                numticks = 15
            else:
                numticks = 'auto'
        self._base = float(base)
        self._set_subs(subs)
        self.numticks = numticks

    def set_params(self, base=None, subs=None, *, numticks=None):
        if base is not None:
            self._base = float(base)
        if subs is not None:
            self._set_subs(subs)
        if numticks is not None:
            self.numticks = numticks

    def _set_subs(self, subs):
        if subs is None:
            self._subs = 'auto'
        elif isinstance(subs, str):
            _api.check_in_list(('all', 'auto'), subs=subs)
            self._subs = subs
        else:
            try:
                self._subs = np.asarray(subs, dtype=float)
            except ValueError as e:
                raise ValueError(f"subs must be None, 'all', 'auto' or a sequence of floats, not {subs}.") from e
            if self._subs.ndim != 1:
                raise ValueError(f'A sequence passed to subs must be 1-dimensional, not {self._subs.ndim}-dimensional.')

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        if self.numticks == 'auto':
            if self.axis is not None:
                numticks = np.clip(self.axis.get_tick_space(), 2, 9)
            else:
                numticks = 9
        else:
            numticks = self.numticks
        b = self._base
        if vmin <= 0.0:
            if self.axis is not None:
                vmin = self.axis.get_minpos()
            if vmin <= 0.0 or not np.isfinite(vmin):
                raise ValueError('Data has no positive values, and therefore cannot be log-scaled.')
        _log.debug('vmin %s vmax %s', vmin, vmax)
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        log_vmin = math.log(vmin) / math.log(b)
        log_vmax = math.log(vmax) / math.log(b)
        numdec = math.floor(log_vmax) - math.ceil(log_vmin)
        if isinstance(self._subs, str):
            if numdec > 10 or b < 3:
                if self._subs == 'auto':
                    return np.array([])
                else:
                    subs = np.array([1.0])
            else:
                _first = 2.0 if self._subs == 'auto' else 1.0
                subs = np.arange(_first, b)
        else:
            subs = self._subs
        stride = max(math.ceil(numdec / (numticks - 1)), 1) if mpl.rcParams['_internal.classic_mode'] else numdec // numticks + 1
        if stride >= numdec:
            stride = max(1, numdec - 1)
        have_subs = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
        decades = np.arange(math.floor(log_vmin) - stride, math.ceil(log_vmax) + 2 * stride, stride)
        if have_subs:
            if stride == 1:
                ticklocs = np.concatenate([subs * decade_start for decade_start in b ** decades])
            else:
                ticklocs = np.array([])
        else:
            ticklocs = b ** decades
        _log.debug('ticklocs %r', ticklocs)
        if len(subs) > 1 and stride == 1 and (((vmin <= ticklocs) & (ticklocs <= vmax)).sum() <= 1):
            return AutoLocator().tick_values(vmin, vmax)
        else:
            return self.raise_if_exceeds(ticklocs)

    def view_limits(self, vmin, vmax):
        b = self._base
        (vmin, vmax) = self.nonsingular(vmin, vmax)
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            vmin = _decade_less_equal(vmin, b)
            vmax = _decade_greater_equal(vmax, b)
        return (vmin, vmax)

    def nonsingular(self, vmin, vmax):
        if vmin > vmax:
            (vmin, vmax) = (vmax, vmin)
        if not np.isfinite(vmin) or not np.isfinite(vmax):
            (vmin, vmax) = (1, 10)
        elif vmax <= 0:
            _api.warn_external('Data has no positive values, and therefore cannot be log-scaled.')
            (vmin, vmax) = (1, 10)
        else:
            minpos = min((axis.get_minpos() for axis in self.axis._get_shared_axis()))
            if not np.isfinite(minpos):
                minpos = 1e-300
            if vmin <= 0:
                vmin = minpos
            if vmin == vmax:
                vmin = _decade_less(vmin, self._base)
                vmax = _decade_greater(vmax, self._base)
        return (vmin, vmax)

class SymmetricalLogLocator(Locator):

    def __init__(self, transform=None, subs=None, linthresh=None, base=None):
        if transform is not None:
            self._base = transform.base
            self._linthresh = transform.linthresh
        elif linthresh is not None and base is not None:
            self._base = base
            self._linthresh = linthresh
        else:
            raise ValueError('Either transform, or both linthresh and base, must be provided.')
        if subs is None:
            self._subs = [1.0]
        else:
            self._subs = subs
        self.numticks = 15

    def set_params(self, subs=None, numticks=None):
        if numticks is not None:
            self.numticks = numticks
        if subs is not None:
            self._subs = subs

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        linthresh = self._linthresh
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        if -linthresh <= vmin < vmax <= linthresh:
            return sorted({vmin, 0, vmax})
        has_a = vmin < -linthresh
        has_c = vmax > linthresh
        has_b = has_a and vmax > -linthresh or (has_c and vmin < linthresh)
        base = self._base

        def get_log_range(lo, hi):
            lo = np.floor(np.log(lo) / np.log(base))
            hi = np.ceil(np.log(hi) / np.log(base))
            return (lo, hi)
        (a_lo, a_hi) = (0, 0)
        if has_a:
            a_upper_lim = min(-linthresh, vmax)
            (a_lo, a_hi) = get_log_range(abs(a_upper_lim), abs(vmin) + 1)
        (c_lo, c_hi) = (0, 0)
        if has_c:
            c_lower_lim = max(linthresh, vmin)
            (c_lo, c_hi) = get_log_range(c_lower_lim, vmax + 1)
        total_ticks = a_hi - a_lo + (c_hi - c_lo)
        if has_b:
            total_ticks += 1
        stride = max(total_ticks // (self.numticks - 1), 1)
        decades = []
        if has_a:
            decades.extend(-1 * base ** np.arange(a_lo, a_hi, stride)[::-1])
        if has_b:
            decades.append(0.0)
        if has_c:
            decades.extend(base ** np.arange(c_lo, c_hi, stride))
        subs = np.asarray(self._subs)
        if len(subs) > 1 or subs[0] != 1.0:
            ticklocs = []
            for decade in decades:
                if decade == 0:
                    ticklocs.append(decade)
                else:
                    ticklocs.extend(subs * decade)
        else:
            ticklocs = decades
        return self.raise_if_exceeds(np.array(ticklocs))

    def view_limits(self, vmin, vmax):
        b = self._base
        if vmax < vmin:
            (vmin, vmax) = (vmax, vmin)
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            vmin = _decade_less_equal(vmin, b)
            vmax = _decade_greater_equal(vmax, b)
            if vmin == vmax:
                vmin = _decade_less(vmin, b)
                vmax = _decade_greater(vmax, b)
        return mtransforms.nonsingular(vmin, vmax)

class AsinhLocator(Locator):

    def __init__(self, linear_width, numticks=11, symthresh=0.2, base=10, subs=None):
        super().__init__()
        self.linear_width = linear_width
        self.numticks = numticks
        self.symthresh = symthresh
        self.base = base
        self.subs = subs

    def set_params(self, numticks=None, symthresh=None, base=None, subs=None):
        if numticks is not None:
            self.numticks = numticks
        if symthresh is not None:
            self.symthresh = symthresh
        if base is not None:
            self.base = base
        if subs is not None:
            self.subs = subs if len(subs) > 0 else None

    def __call__(self):
        (vmin, vmax) = self.axis.get_view_interval()
        if vmin * vmax < 0 and abs(1 + vmax / vmin) < self.symthresh:
            bound = max(abs(vmin), abs(vmax))
            return self.tick_values(-bound, bound)
        else:
            return self.tick_values(vmin, vmax)

    def tick_values(self, vmin, vmax):
        (ymin, ymax) = self.linear_width * np.arcsinh(np.array([vmin, vmax]) / self.linear_width)
        ys = np.linspace(ymin, ymax, self.numticks)
        zero_dev = abs(ys / (ymax - ymin))
        if ymin * ymax < 0:
            ys = np.hstack([ys[zero_dev > 0.5 / self.numticks], 0.0])
        xs = self.linear_width * np.sinh(ys / self.linear_width)
        zero_xs = ys == 0
        with np.errstate(divide='ignore'):
            if self.base > 1:
                pows = np.sign(xs) * self.base ** np.floor(np.log(abs(xs)) / math.log(self.base))
                qs = np.outer(pows, self.subs).flatten() if self.subs else pows
            else:
                pows = np.where(zero_xs, 1, 10 ** np.floor(np.log10(abs(xs))))
                qs = pows * np.round(xs / pows)
        ticks = np.array(sorted(set(qs)))
        return ticks if len(ticks) >= 2 else np.linspace(vmin, vmax, self.numticks)

class LogitLocator(MaxNLocator):

    def __init__(self, minor=False, *, nbins='auto'):
        self._minor = minor
        super().__init__(nbins=nbins, steps=[1, 2, 5, 10])

    def set_params(self, minor=None, **kwargs):
        if minor is not None:
            self._minor = minor
        super().set_params(**kwargs)

    @property
    def minor(self):
        return self._minor

    @minor.setter
    def minor(self, value):
        self.set_params(minor=value)

    def tick_values(self, vmin, vmax):
        if hasattr(self.axis, 'axes') and self.axis.axes.name == 'polar':
            raise NotImplementedError('Polar axis cannot be logit scaled yet')
        if self._nbins == 'auto':
            if self.axis is not None:
                nbins = self.axis.get_tick_space()
                if nbins < 2:
                    nbins = 2
            else:
                nbins = 9
        else:
            nbins = self._nbins

        def ideal_ticks(x):
            return 10 ** x if x < 0 else 1 - 10 ** (-x) if x > 0 else 0.5
        (vmin, vmax) = self.nonsingular(vmin, vmax)
        binf = int(np.floor(np.log10(vmin)) if vmin < 0.5 else 0 if vmin < 0.9 else -np.ceil(np.log10(1 - vmin)))
        bsup = int(np.ceil(np.log10(vmax)) if vmax <= 0.5 else 1 if vmax <= 0.9 else -np.floor(np.log10(1 - vmax)))
        numideal = bsup - binf - 1
        if numideal >= 2:
            if numideal > nbins:
                subsampling_factor = math.ceil(numideal / nbins)
                if self._minor:
                    ticklocs = [ideal_ticks(b) for b in range(binf, bsup + 1) if b % subsampling_factor != 0]
                else:
                    ticklocs = [ideal_ticks(b) for b in range(binf, bsup + 1) if b % subsampling_factor == 0]
                return self.raise_if_exceeds(np.array(ticklocs))
            if self._minor:
                ticklocs = []
                for b in range(binf, bsup):
                    if b < -1:
                        ticklocs.extend(np.arange(2, 10) * 10 ** b)
                    elif b == -1:
                        ticklocs.extend(np.arange(2, 5) / 10)
                    elif b == 0:
                        ticklocs.extend(np.arange(6, 9) / 10)
                    else:
                        ticklocs.extend(1 - np.arange(2, 10)[::-1] * 10 ** (-b - 1))
                return self.raise_if_exceeds(np.array(ticklocs))
            ticklocs = [ideal_ticks(b) for b in range(binf, bsup + 1)]
            return self.raise_if_exceeds(np.array(ticklocs))
        if self._minor:
            return []
        return super().tick_values(vmin, vmax)

    def nonsingular(self, vmin, vmax):
        standard_minpos = 1e-07
        initial_range = (standard_minpos, 1 - standard_minpos)
        if vmin > vmax:
            (vmin, vmax) = (vmax, vmin)
        if not np.isfinite(vmin) or not np.isfinite(vmax):
            (vmin, vmax) = initial_range
        elif vmax <= 0 or vmin >= 1:
            _api.warn_external('Data has no values between 0 and 1, and therefore cannot be logit-scaled.')
            (vmin, vmax) = initial_range
        else:
            minpos = self.axis.get_minpos() if self.axis is not None else standard_minpos
            if not np.isfinite(minpos):
                minpos = standard_minpos
            if vmin <= 0:
                vmin = minpos
            if vmax >= 1:
                vmax = 1 - minpos
            if vmin == vmax:
                (vmin, vmax) = (0.1 * vmin, 1 - 0.1 * vmin)
        return (vmin, vmax)

class AutoLocator(MaxNLocator):

    def __init__(self):
        if mpl.rcParams['_internal.classic_mode']:
            nbins = 9
            steps = [1, 2, 5, 10]
        else:
            nbins = 'auto'
            steps = [1, 2, 2.5, 5, 10]
        super().__init__(nbins=nbins, steps=steps)

class AutoMinorLocator(Locator):

    def __init__(self, n=None):
        self.ndivs = n

    def __call__(self):
        if self.axis.get_scale() == 'log':
            _api.warn_external('AutoMinorLocator does not work on logarithmic scales')
            return []
        majorlocs = np.unique(self.axis.get_majorticklocs())
        if len(majorlocs) < 2:
            return []
        majorstep = majorlocs[1] - majorlocs[0]
        if self.ndivs is None:
            self.ndivs = mpl.rcParams['ytick.minor.ndivs' if self.axis.axis_name == 'y' else 'xtick.minor.ndivs']
        if self.ndivs == 'auto':
            majorstep_mantissa = 10 ** (np.log10(majorstep) % 1)
            ndivs = 5 if np.isclose(majorstep_mantissa, [1, 2.5, 5, 10]).any() else 4
        else:
            ndivs = self.ndivs
        minorstep = majorstep / ndivs
        (vmin, vmax) = sorted(self.axis.get_view_interval())
        t0 = majorlocs[0]
        tmin = round((vmin - t0) / minorstep)
        tmax = round((vmax - t0) / minorstep) + 1
        locs = np.arange(tmin, tmax) * minorstep + t0
        return self.raise_if_exceeds(locs)

    def tick_values(self, vmin, vmax):
        raise NotImplementedError(f'Cannot get tick locations for a {type(self).__name__}')

# File: matplotlib-main/lib/matplotlib/transforms.py
""""""
import copy
import functools
import itertools
import textwrap
import weakref
import math
import numpy as np
from numpy.linalg import inv
from matplotlib import _api
from matplotlib._path import affine_transform, count_bboxes_overlapping_bbox, update_path_extents
from .path import Path
DEBUG = False

def _make_str_method(*args, **kwargs):
    indent = functools.partial(textwrap.indent, prefix=' ' * 4)

    def strrepr(x):
        return repr(x) if isinstance(x, str) else str(x)
    return lambda self: type(self).__name__ + '(' + ','.join([*(indent('\n' + strrepr(getattr(self, arg))) for arg in args), *(indent('\n' + k + '=' + strrepr(getattr(self, arg))) for (k, arg) in kwargs.items())]) + ')'

class TransformNode:
    INVALID_NON_AFFINE = _api.deprecated('3.8')(_api.classproperty(lambda cls: 1))
    INVALID_AFFINE = _api.deprecated('3.8')(_api.classproperty(lambda cls: 2))
    INVALID = _api.deprecated('3.8')(_api.classproperty(lambda cls: 3))
    (_VALID, _INVALID_AFFINE_ONLY, _INVALID_FULL) = range(3)
    is_affine = False
    is_bbox = _api.deprecated('3.9')(_api.classproperty(lambda cls: False))
    pass_through = False
    ''

    def __init__(self, shorthand_name=None):
        self._parents = {}
        self._invalid = self._INVALID_FULL
        self._shorthand_name = shorthand_name or ''
    if DEBUG:

        def __str__(self):
            return self._shorthand_name or repr(self)

    def __getstate__(self):
        return {**self.__dict__, '_parents': {k: v() for (k, v) in self._parents.items()}}

    def __setstate__(self, data_dict):
        self.__dict__ = data_dict
        self._parents = {k: weakref.ref(v, lambda _, pop=self._parents.pop, k=k: pop(k)) for (k, v) in self._parents.items() if v is not None}

    def __copy__(self):
        other = copy.copy(super())
        other._parents = {}
        for (key, val) in vars(self).items():
            if isinstance(val, TransformNode) and id(self) in val._parents:
                other.set_children(val)
        return other

    def invalidate(self):
        return self._invalidate_internal(level=self._INVALID_AFFINE_ONLY if self.is_affine else self._INVALID_FULL, invalidating_node=self)

    def _invalidate_internal(self, level, invalidating_node):
        if level <= self._invalid and (not self.pass_through):
            return
        self._invalid = level
        for parent in list(self._parents.values()):
            parent = parent()
            if parent is not None:
                parent._invalidate_internal(level=level, invalidating_node=self)

    def set_children(self, *children):
        id_self = id(self)
        for child in children:
            ref = weakref.ref(self, lambda _, pop=child._parents.pop, k=id_self: pop(k))
            child._parents[id_self] = ref

    def frozen(self):
        return self

class BboxBase(TransformNode):
    is_bbox = _api.deprecated('3.9')(_api.classproperty(lambda cls: True))
    is_affine = True
    if DEBUG:

        @staticmethod
        def _check(points):
            if isinstance(points, np.ma.MaskedArray):
                _api.warn_external('Bbox bounds are a masked array.')
            points = np.asarray(points)
            if any(points[1, :] - points[0, :] == 0):
                _api.warn_external('Singular Bbox.')

    def frozen(self):
        return Bbox(self.get_points().copy())
    frozen.__doc__ = TransformNode.__doc__

    def __array__(self, *args, **kwargs):
        return self.get_points()

    @property
    def x0(self):
        return self.get_points()[0, 0]

    @property
    def y0(self):
        return self.get_points()[0, 1]

    @property
    def x1(self):
        return self.get_points()[1, 0]

    @property
    def y1(self):
        return self.get_points()[1, 1]

    @property
    def p0(self):
        return self.get_points()[0]

    @property
    def p1(self):
        return self.get_points()[1]

    @property
    def xmin(self):
        return np.min(self.get_points()[:, 0])

    @property
    def ymin(self):
        return np.min(self.get_points()[:, 1])

    @property
    def xmax(self):
        return np.max(self.get_points()[:, 0])

    @property
    def ymax(self):
        return np.max(self.get_points()[:, 1])

    @property
    def min(self):
        return np.min(self.get_points(), axis=0)

    @property
    def max(self):
        return np.max(self.get_points(), axis=0)

    @property
    def intervalx(self):
        return self.get_points()[:, 0]

    @property
    def intervaly(self):
        return self.get_points()[:, 1]

    @property
    def width(self):
        points = self.get_points()
        return points[1, 0] - points[0, 0]

    @property
    def height(self):
        points = self.get_points()
        return points[1, 1] - points[0, 1]

    @property
    def size(self):
        points = self.get_points()
        return points[1] - points[0]

    @property
    def bounds(self):
        ((x0, y0), (x1, y1)) = self.get_points()
        return (x0, y0, x1 - x0, y1 - y0)

    @property
    def extents(self):
        return self.get_points().flatten()

    def get_points(self):
        raise NotImplementedError

    def containsx(self, x):
        (x0, x1) = self.intervalx
        return x0 <= x <= x1 or x0 >= x >= x1

    def containsy(self, y):
        (y0, y1) = self.intervaly
        return y0 <= y <= y1 or y0 >= y >= y1

    def contains(self, x, y):
        return self.containsx(x) and self.containsy(y)

    def overlaps(self, other):
        (ax1, ay1, ax2, ay2) = self.extents
        (bx1, by1, bx2, by2) = other.extents
        if ax2 < ax1:
            (ax2, ax1) = (ax1, ax2)
        if ay2 < ay1:
            (ay2, ay1) = (ay1, ay2)
        if bx2 < bx1:
            (bx2, bx1) = (bx1, bx2)
        if by2 < by1:
            (by2, by1) = (by1, by2)
        return ax1 <= bx2 and bx1 <= ax2 and (ay1 <= by2) and (by1 <= ay2)

    def fully_containsx(self, x):
        (x0, x1) = self.intervalx
        return x0 < x < x1 or x0 > x > x1

    def fully_containsy(self, y):
        (y0, y1) = self.intervaly
        return y0 < y < y1 or y0 > y > y1

    def fully_contains(self, x, y):
        return self.fully_containsx(x) and self.fully_containsy(y)

    def fully_overlaps(self, other):
        (ax1, ay1, ax2, ay2) = self.extents
        (bx1, by1, bx2, by2) = other.extents
        if ax2 < ax1:
            (ax2, ax1) = (ax1, ax2)
        if ay2 < ay1:
            (ay2, ay1) = (ay1, ay2)
        if bx2 < bx1:
            (bx2, bx1) = (bx1, bx2)
        if by2 < by1:
            (by2, by1) = (by1, by2)
        return ax1 < bx2 and bx1 < ax2 and (ay1 < by2) and (by1 < ay2)

    def transformed(self, transform):
        pts = self.get_points()
        (ll, ul, lr) = transform.transform(np.array([pts[0], [pts[0, 0], pts[1, 1]], [pts[1, 0], pts[0, 1]]]))
        return Bbox([ll, [lr[0], ul[1]]])
    coefs = {'C': (0.5, 0.5), 'SW': (0, 0), 'S': (0.5, 0), 'SE': (1.0, 0), 'E': (1.0, 0.5), 'NE': (1.0, 1.0), 'N': (0.5, 1.0), 'NW': (0, 1.0), 'W': (0, 0.5)}

    def anchored(self, c, container=None):
        if container is None:
            _api.warn_deprecated('3.8', message='Calling anchored() with no container bbox returns a frozen copy of the original bbox and is deprecated since %(since)s.')
            container = self
        (l, b, w, h) = container.bounds
        (L, B, W, H) = self.bounds
        (cx, cy) = self.coefs[c] if isinstance(c, str) else c
        return Bbox(self._points + [l + cx * (w - W) - L, b + cy * (h - H) - B])

    def shrunk(self, mx, my):
        (w, h) = self.size
        return Bbox([self._points[0], self._points[0] + [mx * w, my * h]])

    def shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0):
        if box_aspect <= 0 or fig_aspect <= 0:
            raise ValueError("'box_aspect' and 'fig_aspect' must be positive")
        if container is None:
            container = self
        (w, h) = container.size
        H = w * box_aspect / fig_aspect
        if H <= h:
            W = w
        else:
            W = h * fig_aspect / box_aspect
            H = h
        return Bbox([self._points[0], self._points[0] + (W, H)])

    def splitx(self, *args):
        xf = [0, *args, 1]
        (x0, y0, x1, y1) = self.extents
        w = x1 - x0
        return [Bbox([[x0 + xf0 * w, y0], [x0 + xf1 * w, y1]]) for (xf0, xf1) in itertools.pairwise(xf)]

    def splity(self, *args):
        yf = [0, *args, 1]
        (x0, y0, x1, y1) = self.extents
        h = y1 - y0
        return [Bbox([[x0, y0 + yf0 * h], [x1, y0 + yf1 * h]]) for (yf0, yf1) in itertools.pairwise(yf)]

    def count_contains(self, vertices):
        if len(vertices) == 0:
            return 0
        vertices = np.asarray(vertices)
        with np.errstate(invalid='ignore'):
            return ((self.min < vertices) & (vertices < self.max)).all(axis=1).sum()

    def count_overlaps(self, bboxes):
        return count_bboxes_overlapping_bbox(self, np.atleast_3d([np.array(x) for x in bboxes]))

    def expanded(self, sw, sh):
        width = self.width
        height = self.height
        deltaw = (sw * width - width) / 2.0
        deltah = (sh * height - height) / 2.0
        a = np.array([[-deltaw, -deltah], [deltaw, deltah]])
        return Bbox(self._points + a)

    def padded(self, w_pad, h_pad=None):
        points = self.get_points()
        if h_pad is None:
            h_pad = w_pad
        return Bbox(points + [[-w_pad, -h_pad], [w_pad, h_pad]])

    def translated(self, tx, ty):
        return Bbox(self._points + (tx, ty))

    def corners(self):
        ((x0, y0), (x1, y1)) = self.get_points()
        return np.array([[x0, y0], [x0, y1], [x1, y0], [x1, y1]])

    def rotated(self, radians):
        corners = self.corners()
        corners_rotated = Affine2D().rotate(radians).transform(corners)
        bbox = Bbox.unit()
        bbox.update_from_data_xy(corners_rotated, ignore=True)
        return bbox

    @staticmethod
    def union(bboxes):
        if not len(bboxes):
            raise ValueError("'bboxes' cannot be empty")
        x0 = np.min([bbox.xmin for bbox in bboxes])
        x1 = np.max([bbox.xmax for bbox in bboxes])
        y0 = np.min([bbox.ymin for bbox in bboxes])
        y1 = np.max([bbox.ymax for bbox in bboxes])
        return Bbox([[x0, y0], [x1, y1]])

    @staticmethod
    def intersection(bbox1, bbox2):
        x0 = np.maximum(bbox1.xmin, bbox2.xmin)
        x1 = np.minimum(bbox1.xmax, bbox2.xmax)
        y0 = np.maximum(bbox1.ymin, bbox2.ymin)
        y1 = np.minimum(bbox1.ymax, bbox2.ymax)
        return Bbox([[x0, y0], [x1, y1]]) if x0 <= x1 and y0 <= y1 else None
_default_minpos = np.array([np.inf, np.inf])

class Bbox(BboxBase):

    def __init__(self, points, **kwargs):
        super().__init__(**kwargs)
        points = np.asarray(points, float)
        if points.shape != (2, 2):
            raise ValueError('Bbox points must be of the form "[[x0, y0], [x1, y1]]".')
        self._points = points
        self._minpos = _default_minpos.copy()
        self._ignore = True
        self._points_orig = self._points.copy()
    if DEBUG:
        ___init__ = __init__

        def __init__(self, points, **kwargs):
            self._check(points)
            self.___init__(points, **kwargs)

        def invalidate(self):
            self._check(self._points)
            super().invalidate()

    def frozen(self):
        frozen_bbox = super().frozen()
        frozen_bbox._minpos = self.minpos.copy()
        return frozen_bbox

    @staticmethod
    def unit():
        return Bbox([[0, 0], [1, 1]])

    @staticmethod
    def null():
        return Bbox([[np.inf, np.inf], [-np.inf, -np.inf]])

    @staticmethod
    def from_bounds(x0, y0, width, height):
        return Bbox.from_extents(x0, y0, x0 + width, y0 + height)

    @staticmethod
    def from_extents(*args, minpos=None):
        bbox = Bbox(np.reshape(args, (2, 2)))
        if minpos is not None:
            bbox._minpos[:] = minpos
        return bbox

    def __format__(self, fmt):
        return 'Bbox(x0={0.x0:{1}}, y0={0.y0:{1}}, x1={0.x1:{1}}, y1={0.y1:{1}})'.format(self, fmt)

    def __str__(self):
        return format(self, '')

    def __repr__(self):
        return 'Bbox([[{0.x0}, {0.y0}], [{0.x1}, {0.y1}]])'.format(self)

    def ignore(self, value):
        self._ignore = value

    def update_from_path(self, path, ignore=None, updatex=True, updatey=True):
        if ignore is None:
            ignore = self._ignore
        if path.vertices.size == 0:
            return
        (points, minpos, changed) = update_path_extents(path, None, self._points, self._minpos, ignore)
        if changed:
            self.invalidate()
            if updatex:
                self._points[:, 0] = points[:, 0]
                self._minpos[0] = minpos[0]
            if updatey:
                self._points[:, 1] = points[:, 1]
                self._minpos[1] = minpos[1]

    def update_from_data_x(self, x, ignore=None):
        x = np.ravel(x)
        self.update_from_data_xy(np.column_stack([x, np.ones(x.size)]), ignore=ignore, updatey=False)

    def update_from_data_y(self, y, ignore=None):
        y = np.ravel(y)
        self.update_from_data_xy(np.column_stack([np.ones(y.size), y]), ignore=ignore, updatex=False)

    def update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True):
        if len(xy) == 0:
            return
        path = Path(xy)
        self.update_from_path(path, ignore=ignore, updatex=updatex, updatey=updatey)

    @BboxBase.x0.setter
    def x0(self, val):
        self._points[0, 0] = val
        self.invalidate()

    @BboxBase.y0.setter
    def y0(self, val):
        self._points[0, 1] = val
        self.invalidate()

    @BboxBase.x1.setter
    def x1(self, val):
        self._points[1, 0] = val
        self.invalidate()

    @BboxBase.y1.setter
    def y1(self, val):
        self._points[1, 1] = val
        self.invalidate()

    @BboxBase.p0.setter
    def p0(self, val):
        self._points[0] = val
        self.invalidate()

    @BboxBase.p1.setter
    def p1(self, val):
        self._points[1] = val
        self.invalidate()

    @BboxBase.intervalx.setter
    def intervalx(self, interval):
        self._points[:, 0] = interval
        self.invalidate()

    @BboxBase.intervaly.setter
    def intervaly(self, interval):
        self._points[:, 1] = interval
        self.invalidate()

    @BboxBase.bounds.setter
    def bounds(self, bounds):
        (l, b, w, h) = bounds
        points = np.array([[l, b], [l + w, b + h]], float)
        if np.any(self._points != points):
            self._points = points
            self.invalidate()

    @property
    def minpos(self):
        return self._minpos

    @minpos.setter
    def minpos(self, val):
        self._minpos[:] = val

    @property
    def minposx(self):
        return self._minpos[0]

    @minposx.setter
    def minposx(self, val):
        self._minpos[0] = val

    @property
    def minposy(self):
        return self._minpos[1]

    @minposy.setter
    def minposy(self, val):
        self._minpos[1] = val

    def get_points(self):
        self._invalid = 0
        return self._points

    def set_points(self, points):
        if np.any(self._points != points):
            self._points = points
            self.invalidate()

    def set(self, other):
        if np.any(self._points != other.get_points()):
            self._points = other.get_points()
            self.invalidate()

    def mutated(self):
        return self.mutatedx() or self.mutatedy()

    def mutatedx(self):
        return self._points[0, 0] != self._points_orig[0, 0] or self._points[1, 0] != self._points_orig[1, 0]

    def mutatedy(self):
        return self._points[0, 1] != self._points_orig[0, 1] or self._points[1, 1] != self._points_orig[1, 1]

class TransformedBbox(BboxBase):

    def __init__(self, bbox, transform, **kwargs):
        _api.check_isinstance(BboxBase, bbox=bbox)
        _api.check_isinstance(Transform, transform=transform)
        if transform.input_dims != 2 or transform.output_dims != 2:
            raise ValueError("The input and output dimensions of 'transform' must be 2")
        super().__init__(**kwargs)
        self._bbox = bbox
        self._transform = transform
        self.set_children(bbox, transform)
        self._points = None
    __str__ = _make_str_method('_bbox', '_transform')

    def get_points(self):
        if self._invalid:
            p = self._bbox.get_points()
            points = self._transform.transform([[p[0, 0], p[0, 1]], [p[1, 0], p[0, 1]], [p[0, 0], p[1, 1]], [p[1, 0], p[1, 1]]])
            points = np.ma.filled(points, 0.0)
            xs = (min(points[:, 0]), max(points[:, 0]))
            if p[0, 0] > p[1, 0]:
                xs = xs[::-1]
            ys = (min(points[:, 1]), max(points[:, 1]))
            if p[0, 1] > p[1, 1]:
                ys = ys[::-1]
            self._points = np.array([[xs[0], ys[0]], [xs[1], ys[1]]])
            self._invalid = 0
        return self._points
    if DEBUG:
        _get_points = get_points

        def get_points(self):
            points = self._get_points()
            self._check(points)
            return points

    def contains(self, x, y):
        return self._bbox.contains(*self._transform.inverted().transform((x, y)))

    def fully_contains(self, x, y):
        return self._bbox.fully_contains(*self._transform.inverted().transform((x, y)))

class LockableBbox(BboxBase):

    def __init__(self, bbox, x0=None, y0=None, x1=None, y1=None, **kwargs):
        _api.check_isinstance(BboxBase, bbox=bbox)
        super().__init__(**kwargs)
        self._bbox = bbox
        self.set_children(bbox)
        self._points = None
        fp = [x0, y0, x1, y1]
        mask = [val is None for val in fp]
        self._locked_points = np.ma.array(fp, float, mask=mask).reshape((2, 2))
    __str__ = _make_str_method('_bbox', '_locked_points')

    def get_points(self):
        if self._invalid:
            points = self._bbox.get_points()
            self._points = np.where(self._locked_points.mask, points, self._locked_points)
            self._invalid = 0
        return self._points
    if DEBUG:
        _get_points = get_points

        def get_points(self):
            points = self._get_points()
            self._check(points)
            return points

    @property
    def locked_x0(self):
        if self._locked_points.mask[0, 0]:
            return None
        else:
            return self._locked_points[0, 0]

    @locked_x0.setter
    def locked_x0(self, x0):
        self._locked_points.mask[0, 0] = x0 is None
        self._locked_points.data[0, 0] = x0
        self.invalidate()

    @property
    def locked_y0(self):
        if self._locked_points.mask[0, 1]:
            return None
        else:
            return self._locked_points[0, 1]

    @locked_y0.setter
    def locked_y0(self, y0):
        self._locked_points.mask[0, 1] = y0 is None
        self._locked_points.data[0, 1] = y0
        self.invalidate()

    @property
    def locked_x1(self):
        if self._locked_points.mask[1, 0]:
            return None
        else:
            return self._locked_points[1, 0]

    @locked_x1.setter
    def locked_x1(self, x1):
        self._locked_points.mask[1, 0] = x1 is None
        self._locked_points.data[1, 0] = x1
        self.invalidate()

    @property
    def locked_y1(self):
        if self._locked_points.mask[1, 1]:
            return None
        else:
            return self._locked_points[1, 1]

    @locked_y1.setter
    def locked_y1(self, y1):
        self._locked_points.mask[1, 1] = y1 is None
        self._locked_points.data[1, 1] = y1
        self.invalidate()

class Transform(TransformNode):
    input_dims = None
    ''
    output_dims = None
    ''
    is_separable = False
    ''
    has_inverse = False
    ''

    def __init_subclass__(cls):
        if sum(('is_separable' in vars(parent) for parent in cls.__mro__)) == 1 and cls.input_dims == cls.output_dims == 1:
            cls.is_separable = True
        if sum(('has_inverse' in vars(parent) for parent in cls.__mro__)) == 1 and hasattr(cls, 'inverted') and (cls.inverted is not Transform.inverted):
            cls.has_inverse = True

    def __add__(self, other):
        return composite_transform_factory(self, other) if isinstance(other, Transform) else NotImplemented

    def _iter_break_from_left_to_right(self):
        yield (IdentityTransform(), self)

    @property
    def depth(self):
        return 1

    def contains_branch(self, other):
        if self.depth < other.depth:
            return False
        for (_, sub_tree) in self._iter_break_from_left_to_right():
            if sub_tree == other:
                return True
        return False

    def contains_branch_seperately(self, other_transform):
        if self.output_dims != 2:
            raise ValueError('contains_branch_seperately only supports transforms with 2 output dimensions')
        return (self.contains_branch(other_transform),) * 2

    def __sub__(self, other):
        if not isinstance(other, Transform):
            return NotImplemented
        for (remainder, sub_tree) in self._iter_break_from_left_to_right():
            if sub_tree == other:
                return remainder
        for (remainder, sub_tree) in other._iter_break_from_left_to_right():
            if sub_tree == self:
                if not remainder.has_inverse:
                    raise ValueError("The shortcut cannot be computed since 'other' includes a non-invertible component")
                return remainder.inverted()
        if other.has_inverse:
            return self + other.inverted()
        else:
            raise ValueError('It is not possible to compute transA - transB since transB cannot be inverted and there is no shortcut possible.')

    def __array__(self, *args, **kwargs):
        return self.get_affine().get_matrix()

    def transform(self, values):
        values = np.asanyarray(values)
        ndim = values.ndim
        values = values.reshape((-1, self.input_dims))
        res = self.transform_affine(self.transform_non_affine(values))
        if ndim == 0:
            assert not np.ma.is_masked(res)
            return res[0, 0]
        if ndim == 1:
            return res.reshape(-1)
        elif ndim == 2:
            return res
        raise ValueError('Input values must have shape (N, {dims}) or ({dims},)'.format(dims=self.input_dims))

    def transform_affine(self, values):
        return self.get_affine().transform(values)

    def transform_non_affine(self, values):
        return values

    def transform_bbox(self, bbox):
        return Bbox(self.transform(bbox.get_points()))

    def get_affine(self):
        return IdentityTransform()

    def get_matrix(self):
        return self.get_affine().get_matrix()

    def transform_point(self, point):
        if len(point) != self.input_dims:
            raise ValueError("The length of 'point' must be 'self.input_dims'")
        return self.transform(point)

    def transform_path(self, path):
        return self.transform_path_affine(self.transform_path_non_affine(path))

    def transform_path_affine(self, path):
        return self.get_affine().transform_path_affine(path)

    def transform_path_non_affine(self, path):
        x = self.transform_non_affine(path.vertices)
        return Path._fast_from_codes_and_verts(x, path.codes, path)

    def transform_angles(self, angles, pts, radians=False, pushoff=1e-05):
        if self.input_dims != 2 or self.output_dims != 2:
            raise NotImplementedError('Only defined in 2D')
        angles = np.asarray(angles)
        pts = np.asarray(pts)
        _api.check_shape((None, 2), pts=pts)
        _api.check_shape((None,), angles=angles)
        if len(angles) != len(pts):
            raise ValueError("There must be as many 'angles' as 'pts'")
        if not radians:
            angles = np.deg2rad(angles)
        pts2 = pts + pushoff * np.column_stack([np.cos(angles), np.sin(angles)])
        tpts = self.transform(pts)
        tpts2 = self.transform(pts2)
        d = tpts2 - tpts
        a = np.arctan2(d[:, 1], d[:, 0])
        if not radians:
            a = np.rad2deg(a)
        return a

    def inverted(self):
        raise NotImplementedError()

class TransformWrapper(Transform):
    pass_through = True

    def __init__(self, child):
        _api.check_isinstance(Transform, child=child)
        super().__init__()
        self.set(child)

    def __eq__(self, other):
        return self._child.__eq__(other)
    __str__ = _make_str_method('_child')

    def frozen(self):
        return self._child.frozen()

    def set(self, child):
        if hasattr(self, '_child'):
            self.invalidate()
            new_dims = (child.input_dims, child.output_dims)
            old_dims = (self._child.input_dims, self._child.output_dims)
            if new_dims != old_dims:
                raise ValueError(f'The input and output dims of the new child {new_dims} do not match those of current child {old_dims}')
            self._child._parents.pop(id(self), None)
        self._child = child
        self.set_children(child)
        self.transform = child.transform
        self.transform_affine = child.transform_affine
        self.transform_non_affine = child.transform_non_affine
        self.transform_path = child.transform_path
        self.transform_path_affine = child.transform_path_affine
        self.transform_path_non_affine = child.transform_path_non_affine
        self.get_affine = child.get_affine
        self.inverted = child.inverted
        self.get_matrix = child.get_matrix
        self._invalid = 0
        self.invalidate()
        self._invalid = 0
    input_dims = property(lambda self: self._child.input_dims)
    output_dims = property(lambda self: self._child.output_dims)
    is_affine = property(lambda self: self._child.is_affine)
    is_separable = property(lambda self: self._child.is_separable)
    has_inverse = property(lambda self: self._child.has_inverse)

class AffineBase(Transform):
    is_affine = True

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._inverted = None

    def __array__(self, *args, **kwargs):
        return self.get_matrix()

    def __eq__(self, other):
        if getattr(other, 'is_affine', False) and hasattr(other, 'get_matrix'):
            return (self.get_matrix() == other.get_matrix()).all()
        return NotImplemented

    def transform(self, values):
        return self.transform_affine(values)

    def transform_affine(self, values):
        raise NotImplementedError('Affine subclasses should override this method.')

    def transform_non_affine(self, values):
        return values

    def transform_path(self, path):
        return self.transform_path_affine(path)

    def transform_path_affine(self, path):
        return Path(self.transform_affine(path.vertices), path.codes, path._interpolation_steps)

    def transform_path_non_affine(self, path):
        return path

    def get_affine(self):
        return self

class Affine2DBase(AffineBase):
    input_dims = 2
    output_dims = 2

    def frozen(self):
        return Affine2D(self.get_matrix().copy())

    @property
    def is_separable(self):
        mtx = self.get_matrix()
        return mtx[0, 1] == mtx[1, 0] == 0.0

    def to_values(self):
        mtx = self.get_matrix()
        return tuple(mtx[:2].swapaxes(0, 1).flat)

    def transform_affine(self, values):
        mtx = self.get_matrix()
        if isinstance(values, np.ma.MaskedArray):
            tpoints = affine_transform(values.data, mtx)
            return np.ma.MaskedArray(tpoints, mask=np.ma.getmask(values))
        return affine_transform(values, mtx)
    if DEBUG:
        _transform_affine = transform_affine

        def transform_affine(self, values):
            if not isinstance(values, np.ndarray):
                _api.warn_external(f'A non-numpy array of type {type(values)} was passed in for transformation, which results in poor performance.')
            return self._transform_affine(values)

    def inverted(self):
        if self._inverted is None or self._invalid:
            mtx = self.get_matrix()
            shorthand_name = None
            if self._shorthand_name:
                shorthand_name = '(%s)-1' % self._shorthand_name
            self._inverted = Affine2D(inv(mtx), shorthand_name=shorthand_name)
            self._invalid = 0
        return self._inverted

class Affine2D(Affine2DBase):

    def __init__(self, matrix=None, **kwargs):
        super().__init__(**kwargs)
        if matrix is None:
            matrix = IdentityTransform._mtx
        self._mtx = matrix.copy()
        self._invalid = 0
    _base_str = _make_str_method('_mtx')

    def __str__(self):
        return self._base_str() if (self._mtx != np.diag(np.diag(self._mtx))).any() else f'Affine2D().scale({self._mtx[0, 0]}, {self._mtx[1, 1]})' if self._mtx[0, 0] != self._mtx[1, 1] else f'Affine2D().scale({self._mtx[0, 0]})'

    @staticmethod
    def from_values(a, b, c, d, e, f):
        return Affine2D(np.array([a, c, e, b, d, f, 0.0, 0.0, 1.0], float).reshape((3, 3)))

    def get_matrix(self):
        if self._invalid:
            self._inverted = None
            self._invalid = 0
        return self._mtx

    def set_matrix(self, mtx):
        self._mtx = mtx
        self.invalidate()

    def set(self, other):
        _api.check_isinstance(Affine2DBase, other=other)
        self._mtx = other.get_matrix()
        self.invalidate()

    def clear(self):
        self._mtx = IdentityTransform._mtx.copy()
        self.invalidate()
        return self

    def rotate(self, theta):
        a = math.cos(theta)
        b = math.sin(theta)
        mtx = self._mtx
        ((xx, xy, x0), (yx, yy, y0), _) = mtx.tolist()
        mtx[0, 0] = a * xx - b * yx
        mtx[0, 1] = a * xy - b * yy
        mtx[0, 2] = a * x0 - b * y0
        mtx[1, 0] = b * xx + a * yx
        mtx[1, 1] = b * xy + a * yy
        mtx[1, 2] = b * x0 + a * y0
        self.invalidate()
        return self

    def rotate_deg(self, degrees):
        return self.rotate(math.radians(degrees))

    def rotate_around(self, x, y, theta):
        return self.translate(-x, -y).rotate(theta).translate(x, y)

    def rotate_deg_around(self, x, y, degrees):
        (x, y) = (float(x), float(y))
        return self.translate(-x, -y).rotate_deg(degrees).translate(x, y)

    def translate(self, tx, ty):
        self._mtx[0, 2] += tx
        self._mtx[1, 2] += ty
        self.invalidate()
        return self

    def scale(self, sx, sy=None):
        if sy is None:
            sy = sx
        self._mtx[0, 0] *= sx
        self._mtx[0, 1] *= sx
        self._mtx[0, 2] *= sx
        self._mtx[1, 0] *= sy
        self._mtx[1, 1] *= sy
        self._mtx[1, 2] *= sy
        self.invalidate()
        return self

    def skew(self, xShear, yShear):
        rx = math.tan(xShear)
        ry = math.tan(yShear)
        mtx = self._mtx
        ((xx, xy, x0), (yx, yy, y0), _) = mtx.tolist()
        mtx[0, 0] += rx * yx
        mtx[0, 1] += rx * yy
        mtx[0, 2] += rx * y0
        mtx[1, 0] += ry * xx
        mtx[1, 1] += ry * xy
        mtx[1, 2] += ry * x0
        self.invalidate()
        return self

    def skew_deg(self, xShear, yShear):
        return self.skew(math.radians(xShear), math.radians(yShear))

class IdentityTransform(Affine2DBase):
    _mtx = np.identity(3)

    def frozen(self):
        return self
    __str__ = _make_str_method()

    def get_matrix(self):
        return self._mtx

    def transform(self, values):
        return np.asanyarray(values)

    def transform_affine(self, values):
        return np.asanyarray(values)

    def transform_non_affine(self, values):
        return np.asanyarray(values)

    def transform_path(self, path):
        return path

    def transform_path_affine(self, path):
        return path

    def transform_path_non_affine(self, path):
        return path

    def get_affine(self):
        return self

    def inverted(self):
        return self

class _BlendedMixin:

    def __eq__(self, other):
        if isinstance(other, (BlendedAffine2D, BlendedGenericTransform)):
            return self._x == other._x and self._y == other._y
        elif self._x == self._y:
            return self._x == other
        else:
            return NotImplemented

    def contains_branch_seperately(self, transform):
        return (self._x.contains_branch(transform), self._y.contains_branch(transform))
    __str__ = _make_str_method('_x', '_y')

class BlendedGenericTransform(_BlendedMixin, Transform):
    input_dims = 2
    output_dims = 2
    is_separable = True
    pass_through = True

    def __init__(self, x_transform, y_transform, **kwargs):
        Transform.__init__(self, **kwargs)
        self._x = x_transform
        self._y = y_transform
        self.set_children(x_transform, y_transform)
        self._affine = None

    @property
    def depth(self):
        return max(self._x.depth, self._y.depth)

    def contains_branch(self, other):
        return False
    is_affine = property(lambda self: self._x.is_affine and self._y.is_affine)
    has_inverse = property(lambda self: self._x.has_inverse and self._y.has_inverse)

    def frozen(self):
        return blended_transform_factory(self._x.frozen(), self._y.frozen())

    def transform_non_affine(self, values):
        if self._x.is_affine and self._y.is_affine:
            return values
        x = self._x
        y = self._y
        if x == y and x.input_dims == 2:
            return x.transform_non_affine(values)
        if x.input_dims == 2:
            x_points = x.transform_non_affine(values)[:, 0:1]
        else:
            x_points = x.transform_non_affine(values[:, 0])
            x_points = x_points.reshape((len(x_points), 1))
        if y.input_dims == 2:
            y_points = y.transform_non_affine(values)[:, 1:]
        else:
            y_points = y.transform_non_affine(values[:, 1])
            y_points = y_points.reshape((len(y_points), 1))
        if isinstance(x_points, np.ma.MaskedArray) or isinstance(y_points, np.ma.MaskedArray):
            return np.ma.concatenate((x_points, y_points), 1)
        else:
            return np.concatenate((x_points, y_points), 1)

    def inverted(self):
        return BlendedGenericTransform(self._x.inverted(), self._y.inverted())

    def get_affine(self):
        if self._invalid or self._affine is None:
            if self._x == self._y:
                self._affine = self._x.get_affine()
            else:
                x_mtx = self._x.get_affine().get_matrix()
                y_mtx = self._y.get_affine().get_matrix()
                mtx = np.array([x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0]])
                self._affine = Affine2D(mtx)
            self._invalid = 0
        return self._affine

class BlendedAffine2D(_BlendedMixin, Affine2DBase):
    is_separable = True

    def __init__(self, x_transform, y_transform, **kwargs):
        is_affine = x_transform.is_affine and y_transform.is_affine
        is_separable = x_transform.is_separable and y_transform.is_separable
        is_correct = is_affine and is_separable
        if not is_correct:
            raise ValueError('Both *x_transform* and *y_transform* must be 2D affine transforms')
        Transform.__init__(self, **kwargs)
        self._x = x_transform
        self._y = y_transform
        self.set_children(x_transform, y_transform)
        Affine2DBase.__init__(self)
        self._mtx = None

    def get_matrix(self):
        if self._invalid:
            if self._x == self._y:
                self._mtx = self._x.get_matrix()
            else:
                x_mtx = self._x.get_matrix()
                y_mtx = self._y.get_matrix()
                self._mtx = np.array([x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0]])
            self._inverted = None
            self._invalid = 0
        return self._mtx

def blended_transform_factory(x_transform, y_transform):
    if isinstance(x_transform, Affine2DBase) and isinstance(y_transform, Affine2DBase):
        return BlendedAffine2D(x_transform, y_transform)
    return BlendedGenericTransform(x_transform, y_transform)

class CompositeGenericTransform(Transform):
    pass_through = True

    def __init__(self, a, b, **kwargs):
        if a.output_dims != b.input_dims:
            raise ValueError("The output dimension of 'a' must be equal to the input dimensions of 'b'")
        self.input_dims = a.input_dims
        self.output_dims = b.output_dims
        super().__init__(**kwargs)
        self._a = a
        self._b = b
        self.set_children(a, b)

    def frozen(self):
        self._invalid = 0
        frozen = composite_transform_factory(self._a.frozen(), self._b.frozen())
        if not isinstance(frozen, CompositeGenericTransform):
            return frozen.frozen()
        return frozen

    def _invalidate_internal(self, level, invalidating_node):
        if invalidating_node is self._a and (not self._b.is_affine):
            level = Transform._INVALID_FULL
        super()._invalidate_internal(level, invalidating_node)

    def __eq__(self, other):
        if isinstance(other, (CompositeGenericTransform, CompositeAffine2D)):
            return self is other or (self._a == other._a and self._b == other._b)
        else:
            return False

    def _iter_break_from_left_to_right(self):
        for (left, right) in self._a._iter_break_from_left_to_right():
            yield (left, right + self._b)
        for (left, right) in self._b._iter_break_from_left_to_right():
            yield (self._a + left, right)

    def contains_branch_seperately(self, other_transform):
        if self.output_dims != 2:
            raise ValueError('contains_branch_seperately only supports transforms with 2 output dimensions')
        if self == other_transform:
            return (True, True)
        return self._b.contains_branch_seperately(other_transform)
    depth = property(lambda self: self._a.depth + self._b.depth)
    is_affine = property(lambda self: self._a.is_affine and self._b.is_affine)
    is_separable = property(lambda self: self._a.is_separable and self._b.is_separable)
    has_inverse = property(lambda self: self._a.has_inverse and self._b.has_inverse)
    __str__ = _make_str_method('_a', '_b')

    def transform_affine(self, values):
        return self.get_affine().transform(values)

    def transform_non_affine(self, values):
        if self._a.is_affine and self._b.is_affine:
            return values
        elif not self._a.is_affine and self._b.is_affine:
            return self._a.transform_non_affine(values)
        else:
            return self._b.transform_non_affine(self._a.transform(values))

    def transform_path_non_affine(self, path):
        if self._a.is_affine and self._b.is_affine:
            return path
        elif not self._a.is_affine and self._b.is_affine:
            return self._a.transform_path_non_affine(path)
        else:
            return self._b.transform_path_non_affine(self._a.transform_path(path))

    def get_affine(self):
        if not self._b.is_affine:
            return self._b.get_affine()
        else:
            return Affine2D(np.dot(self._b.get_affine().get_matrix(), self._a.get_affine().get_matrix()))

    def inverted(self):
        return CompositeGenericTransform(self._b.inverted(), self._a.inverted())

class CompositeAffine2D(Affine2DBase):

    def __init__(self, a, b, **kwargs):
        if not a.is_affine or not b.is_affine:
            raise ValueError("'a' and 'b' must be affine transforms")
        if a.output_dims != b.input_dims:
            raise ValueError("The output dimension of 'a' must be equal to the input dimensions of 'b'")
        self.input_dims = a.input_dims
        self.output_dims = b.output_dims
        super().__init__(**kwargs)
        self._a = a
        self._b = b
        self.set_children(a, b)
        self._mtx = None

    @property
    def depth(self):
        return self._a.depth + self._b.depth

    def _iter_break_from_left_to_right(self):
        for (left, right) in self._a._iter_break_from_left_to_right():
            yield (left, right + self._b)
        for (left, right) in self._b._iter_break_from_left_to_right():
            yield (self._a + left, right)
    __str__ = _make_str_method('_a', '_b')

    def get_matrix(self):
        if self._invalid:
            self._mtx = np.dot(self._b.get_matrix(), self._a.get_matrix())
            self._inverted = None
            self._invalid = 0
        return self._mtx

def composite_transform_factory(a, b):
    if isinstance(a, IdentityTransform):
        return b
    elif isinstance(b, IdentityTransform):
        return a
    elif isinstance(a, Affine2D) and isinstance(b, Affine2D):
        return CompositeAffine2D(a, b)
    return CompositeGenericTransform(a, b)

class BboxTransform(Affine2DBase):
    is_separable = True

    def __init__(self, boxin, boxout, **kwargs):
        _api.check_isinstance(BboxBase, boxin=boxin, boxout=boxout)
        super().__init__(**kwargs)
        self._boxin = boxin
        self._boxout = boxout
        self.set_children(boxin, boxout)
        self._mtx = None
        self._inverted = None
    __str__ = _make_str_method('_boxin', '_boxout')

    def get_matrix(self):
        if self._invalid:
            (inl, inb, inw, inh) = self._boxin.bounds
            (outl, outb, outw, outh) = self._boxout.bounds
            x_scale = outw / inw
            y_scale = outh / inh
            if DEBUG and (x_scale == 0 or y_scale == 0):
                raise ValueError('Transforming from or to a singular bounding box')
            self._mtx = np.array([[x_scale, 0.0, -inl * x_scale + outl], [0.0, y_scale, -inb * y_scale + outb], [0.0, 0.0, 1.0]], float)
            self._inverted = None
            self._invalid = 0
        return self._mtx

class BboxTransformTo(Affine2DBase):
    is_separable = True

    def __init__(self, boxout, **kwargs):
        _api.check_isinstance(BboxBase, boxout=boxout)
        super().__init__(**kwargs)
        self._boxout = boxout
        self.set_children(boxout)
        self._mtx = None
        self._inverted = None
    __str__ = _make_str_method('_boxout')

    def get_matrix(self):
        if self._invalid:
            (outl, outb, outw, outh) = self._boxout.bounds
            if DEBUG and (outw == 0 or outh == 0):
                raise ValueError('Transforming to a singular bounding box.')
            self._mtx = np.array([[outw, 0.0, outl], [0.0, outh, outb], [0.0, 0.0, 1.0]], float)
            self._inverted = None
            self._invalid = 0
        return self._mtx

@_api.deprecated('3.9')
class BboxTransformToMaxOnly(BboxTransformTo):

    def get_matrix(self):
        if self._invalid:
            (xmax, ymax) = self._boxout.max
            if DEBUG and (xmax == 0 or ymax == 0):
                raise ValueError('Transforming to a singular bounding box.')
            self._mtx = np.array([[xmax, 0.0, 0.0], [0.0, ymax, 0.0], [0.0, 0.0, 1.0]], float)
            self._inverted = None
            self._invalid = 0
        return self._mtx

class BboxTransformFrom(Affine2DBase):
    is_separable = True

    def __init__(self, boxin, **kwargs):
        _api.check_isinstance(BboxBase, boxin=boxin)
        super().__init__(**kwargs)
        self._boxin = boxin
        self.set_children(boxin)
        self._mtx = None
        self._inverted = None
    __str__ = _make_str_method('_boxin')

    def get_matrix(self):
        if self._invalid:
            (inl, inb, inw, inh) = self._boxin.bounds
            if DEBUG and (inw == 0 or inh == 0):
                raise ValueError('Transforming from a singular bounding box.')
            x_scale = 1.0 / inw
            y_scale = 1.0 / inh
            self._mtx = np.array([[x_scale, 0.0, -inl * x_scale], [0.0, y_scale, -inb * y_scale], [0.0, 0.0, 1.0]], float)
            self._inverted = None
            self._invalid = 0
        return self._mtx

class ScaledTranslation(Affine2DBase):

    def __init__(self, xt, yt, scale_trans, **kwargs):
        super().__init__(**kwargs)
        self._t = (xt, yt)
        self._scale_trans = scale_trans
        self.set_children(scale_trans)
        self._mtx = None
        self._inverted = None
    __str__ = _make_str_method('_t')

    def get_matrix(self):
        if self._invalid:
            self._mtx = IdentityTransform._mtx.copy()
            self._mtx[:2, 2] = self._scale_trans.transform(self._t)
            self._invalid = 0
            self._inverted = None
        return self._mtx

class AffineDeltaTransform(Affine2DBase):
    pass_through = True

    def __init__(self, transform, **kwargs):
        super().__init__(**kwargs)
        self._base_transform = transform
        self.set_children(transform)
    __str__ = _make_str_method('_base_transform')

    def get_matrix(self):
        if self._invalid:
            self._mtx = self._base_transform.get_matrix().copy()
            self._mtx[:2, -1] = 0
        return self._mtx

class TransformedPath(TransformNode):

    def __init__(self, path, transform):
        _api.check_isinstance(Transform, transform=transform)
        super().__init__()
        self._path = path
        self._transform = transform
        self.set_children(transform)
        self._transformed_path = None
        self._transformed_points = None

    def _revalidate(self):
        if self._invalid == self._INVALID_FULL or self._transformed_path is None:
            self._transformed_path = self._transform.transform_path_non_affine(self._path)
            self._transformed_points = Path._fast_from_codes_and_verts(self._transform.transform_non_affine(self._path.vertices), None, self._path)
        self._invalid = 0

    def get_transformed_points_and_affine(self):
        self._revalidate()
        return (self._transformed_points, self.get_affine())

    def get_transformed_path_and_affine(self):
        self._revalidate()
        return (self._transformed_path, self.get_affine())

    def get_fully_transformed_path(self):
        self._revalidate()
        return self._transform.transform_path_affine(self._transformed_path)

    def get_affine(self):
        return self._transform.get_affine()

class TransformedPatchPath(TransformedPath):

    def __init__(self, patch):
        super().__init__(patch.get_path(), patch.get_transform())
        self._patch = patch

    def _revalidate(self):
        patch_path = self._patch.get_path()
        if patch_path != self._path:
            self._path = patch_path
            self._transformed_path = None
        super()._revalidate()

def nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True):
    if not np.isfinite(vmin) or not np.isfinite(vmax):
        return (-expander, expander)
    swapped = False
    if vmax < vmin:
        (vmin, vmax) = (vmax, vmin)
        swapped = True
    (vmin, vmax) = map(float, [vmin, vmax])
    maxabsvalue = max(abs(vmin), abs(vmax))
    if maxabsvalue < 1000000.0 / tiny * np.finfo(float).tiny:
        vmin = -expander
        vmax = expander
    elif vmax - vmin <= maxabsvalue * tiny:
        if vmax == 0 and vmin == 0:
            vmin = -expander
            vmax = expander
        else:
            vmin -= expander * abs(vmin)
            vmax += expander * abs(vmax)
    if swapped and (not increasing):
        (vmin, vmax) = (vmax, vmin)
    return (vmin, vmax)

def interval_contains(interval, val):
    (a, b) = interval
    if a > b:
        (a, b) = (b, a)
    return a <= val <= b

def _interval_contains_close(interval, val, rtol=1e-10):
    (a, b) = interval
    if a > b:
        (a, b) = (b, a)
    rtol = (b - a) * rtol
    return a - rtol <= val <= b + rtol

def interval_contains_open(interval, val):
    (a, b) = interval
    return a < val < b or a > val > b

def offset_copy(trans, fig=None, x=0.0, y=0.0, units='inches'):
    _api.check_in_list(['dots', 'points', 'inches'], units=units)
    if units == 'dots':
        return trans + Affine2D().translate(x, y)
    if fig is None:
        raise ValueError('For units of inches or points a fig kwarg is needed')
    if units == 'points':
        x /= 72.0
        y /= 72.0
    return trans + ScaledTranslation(x, y, fig.dpi_scale_trans)

# File: matplotlib-main/lib/matplotlib/tri/__init__.py
""""""
from ._triangulation import Triangulation
from ._tricontour import TriContourSet, tricontour, tricontourf
from ._trifinder import TriFinder, TrapezoidMapTriFinder
from ._triinterpolate import TriInterpolator, LinearTriInterpolator, CubicTriInterpolator
from ._tripcolor import tripcolor
from ._triplot import triplot
from ._trirefine import TriRefiner, UniformTriRefiner
from ._tritools import TriAnalyzer
__all__ = ['Triangulation', 'TriContourSet', 'tricontour', 'tricontourf', 'TriFinder', 'TrapezoidMapTriFinder', 'TriInterpolator', 'LinearTriInterpolator', 'CubicTriInterpolator', 'tripcolor', 'triplot', 'TriRefiner', 'UniformTriRefiner', 'TriAnalyzer']

# File: matplotlib-main/lib/matplotlib/tri/_triangulation.py
import sys
import numpy as np
from matplotlib import _api

class Triangulation:

    def __init__(self, x, y, triangles=None, mask=None):
        from matplotlib import _qhull
        self.x = np.asarray(x, dtype=np.float64)
        self.y = np.asarray(y, dtype=np.float64)
        if self.x.shape != self.y.shape or self.x.ndim != 1:
            raise ValueError(f'x and y must be equal-length 1D arrays, but found shapes {self.x.shape!r} and {self.y.shape!r}')
        self.mask = None
        self._edges = None
        self._neighbors = None
        self.is_delaunay = False
        if triangles is None:
            (self.triangles, self._neighbors) = _qhull.delaunay(x, y, sys.flags.verbose)
            self.is_delaunay = True
        else:
            try:
                self.triangles = np.array(triangles, dtype=np.int32, order='C')
            except ValueError as e:
                raise ValueError(f'triangles must be a (N, 3) int array, not {triangles!r}') from e
            if self.triangles.ndim != 2 or self.triangles.shape[1] != 3:
                raise ValueError(f'triangles must be a (N, 3) int array, but found shape {self.triangles.shape!r}')
            if self.triangles.max() >= len(self.x):
                raise ValueError(f'triangles are indices into the points and must be in the range 0 <= i < {len(self.x)} but found value {self.triangles.max()}')
            if self.triangles.min() < 0:
                raise ValueError(f'triangles are indices into the points and must be in the range 0 <= i < {len(self.x)} but found value {self.triangles.min()}')
        self._cpp_triangulation = None
        self._trifinder = None
        self.set_mask(mask)

    def calculate_plane_coefficients(self, z):
        return self.get_cpp_triangulation().calculate_plane_coefficients(z)

    @property
    def edges(self):
        if self._edges is None:
            self._edges = self.get_cpp_triangulation().get_edges()
        return self._edges

    def get_cpp_triangulation(self):
        from matplotlib import _tri
        if self._cpp_triangulation is None:
            self._cpp_triangulation = _tri.Triangulation(self.x, self.y, self.triangles, self.mask if self.mask is not None else (), self._edges if self._edges is not None else (), self._neighbors if self._neighbors is not None else (), not self.is_delaunay)
        return self._cpp_triangulation

    def get_masked_triangles(self):
        if self.mask is not None:
            return self.triangles[~self.mask]
        else:
            return self.triangles

    @staticmethod
    def get_from_args_and_kwargs(*args, **kwargs):
        if isinstance(args[0], Triangulation):
            (triangulation, *args) = args
            if 'triangles' in kwargs:
                _api.warn_external("Passing the keyword 'triangles' has no effect when also passing a Triangulation")
            if 'mask' in kwargs:
                _api.warn_external("Passing the keyword 'mask' has no effect when also passing a Triangulation")
        else:
            (x, y, triangles, mask, args, kwargs) = Triangulation._extract_triangulation_params(args, kwargs)
            triangulation = Triangulation(x, y, triangles, mask)
        return (triangulation, args, kwargs)

    @staticmethod
    def _extract_triangulation_params(args, kwargs):
        (x, y, *args) = args
        triangles = kwargs.pop('triangles', None)
        from_args = False
        if triangles is None and args:
            triangles = args[0]
            from_args = True
        if triangles is not None:
            try:
                triangles = np.asarray(triangles, dtype=np.int32)
            except ValueError:
                triangles = None
        if triangles is not None and (triangles.ndim != 2 or triangles.shape[1] != 3):
            triangles = None
        if triangles is not None and from_args:
            args = args[1:]
        mask = kwargs.pop('mask', None)
        return (x, y, triangles, mask, args, kwargs)

    def get_trifinder(self):
        if self._trifinder is None:
            from matplotlib.tri._trifinder import TrapezoidMapTriFinder
            self._trifinder = TrapezoidMapTriFinder(self)
        return self._trifinder

    @property
    def neighbors(self):
        if self._neighbors is None:
            self._neighbors = self.get_cpp_triangulation().get_neighbors()
        return self._neighbors

    def set_mask(self, mask):
        if mask is None:
            self.mask = None
        else:
            self.mask = np.asarray(mask, dtype=bool)
            if self.mask.shape != (self.triangles.shape[0],):
                raise ValueError('mask array must have same length as triangles array')
        if self._cpp_triangulation is not None:
            self._cpp_triangulation.set_mask(self.mask if self.mask is not None else ())
        self._edges = None
        self._neighbors = None
        if self._trifinder is not None:
            self._trifinder._initialize()

# File: matplotlib-main/lib/matplotlib/tri/_tricontour.py
import numpy as np
from matplotlib import _docstring
from matplotlib.contour import ContourSet
from matplotlib.tri._triangulation import Triangulation

@_docstring.dedent_interpd
class TriContourSet(ContourSet):

    def __init__(self, ax, *args, **kwargs):
        super().__init__(ax, *args, **kwargs)

    def _process_args(self, *args, **kwargs):
        if isinstance(args[0], TriContourSet):
            C = args[0]._contour_generator
            if self.levels is None:
                self.levels = args[0].levels
            self.zmin = args[0].zmin
            self.zmax = args[0].zmax
            self._mins = args[0]._mins
            self._maxs = args[0]._maxs
        else:
            from matplotlib import _tri
            (tri, z) = self._contour_args(args, kwargs)
            C = _tri.TriContourGenerator(tri.get_cpp_triangulation(), z)
            self._mins = [tri.x.min(), tri.y.min()]
            self._maxs = [tri.x.max(), tri.y.max()]
        self._contour_generator = C
        return kwargs

    def _contour_args(self, args, kwargs):
        (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
        (z, *args) = args
        z = np.ma.asarray(z)
        if z.shape != tri.x.shape:
            raise ValueError('z array must have same length as triangulation x and y arrays')
        z_check = z[np.unique(tri.get_masked_triangles())]
        if np.ma.is_masked(z_check):
            raise ValueError('z must not contain masked points within the triangulation')
        if not np.isfinite(z_check).all():
            raise ValueError('z array must not contain non-finite values within the triangulation')
        z = np.ma.masked_invalid(z, copy=False)
        self.zmax = float(z_check.max())
        self.zmin = float(z_check.min())
        if self.logscale and self.zmin <= 0:
            func = 'contourf' if self.filled else 'contour'
            raise ValueError(f'Cannot {func} log of negative values.')
        self._process_contour_level_args(args, z.dtype)
        return (tri, z)
_docstring.interpd.update(_tricontour_doc='\nDraw contour %%(type)s on an unstructured triangular grid.\n\nCall signatures::\n\n    %%(func)s(triangulation, z, [levels], ...)\n    %%(func)s(x, y, z, [levels], *, [triangles=triangles], [mask=mask], ...)\n\nThe triangular grid can be specified either by passing a `.Triangulation`\nobject as the first parameter, or by passing the points *x*, *y* and\noptionally the *triangles* and a *mask*. See `.Triangulation` for an\nexplanation of these parameters. If neither of *triangulation* or\n*triangles* are given, the triangulation is calculated on the fly.\n\nIt is possible to pass *triangles* positionally, i.e.\n``%%(func)s(x, y, triangles, z, ...)``. However, this is discouraged. For more\nclarity, pass *triangles* via keyword argument.\n\nParameters\n----------\ntriangulation : `.Triangulation`, optional\n    An already created triangular grid.\n\nx, y, triangles, mask\n    Parameters defining the triangular grid. See `.Triangulation`.\n    This is mutually exclusive with specifying *triangulation*.\n\nz : array-like\n    The height values over which the contour is drawn.  Color-mapping is\n    controlled by *cmap*, *norm*, *vmin*, and *vmax*.\n\n    .. note::\n        All values in *z* must be finite. Hence, nan and inf values must\n        either be removed or `~.Triangulation.set_mask` be used.\n\nlevels : int or array-like, optional\n    Determines the number and positions of the contour lines / regions.\n\n    If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\n    automatically choose no more than *n+1* "nice" contour levels between\n    between minimum and maximum numeric values of *Z*.\n\n    If array-like, draw contour lines at the specified levels.  The values must\n    be in increasing order.\n\nReturns\n-------\n`~matplotlib.tri.TriContourSet`\n\nOther Parameters\n----------------\ncolors : :mpltype:`color` or list of :mpltype:`color`, optional\n    The colors of the levels, i.e., the contour %%(type)s.\n\n    The sequence is cycled for the levels in ascending order. If the sequence\n    is shorter than the number of levels, it is repeated.\n\n    As a shortcut, single color strings may be used in place of one-element\n    lists, i.e. ``\'red\'`` instead of ``[\'red\']`` to color all levels with the\n    same color. This shortcut does only work for color strings, not for other\n    ways of specifying colors.\n\n    By default (value *None*), the colormap specified by *cmap* will be used.\n\nalpha : float, default: 1\n    The alpha blending value, between 0 (transparent) and 1 (opaque).\n\n%(cmap_doc)s\n\n    This parameter is ignored if *colors* is set.\n\n%(norm_doc)s\n\n    This parameter is ignored if *colors* is set.\n\n%(vmin_vmax_doc)s\n\n    If *vmin* or *vmax* are not given, the default color scaling is based on\n    *levels*.\n\n    This parameter is ignored if *colors* is set.\n\norigin : {*None*, \'upper\', \'lower\', \'image\'}, default: None\n    Determines the orientation and exact position of *z* by specifying the\n    position of ``z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.\n\n    - *None*: ``z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n    - \'lower\': ``z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n    - \'upper\': ``z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\n    - \'image\': Use the value from :rc:`image.origin`.\n\nextent : (x0, x1, y0, y1), optional\n    If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\n    gives the outer pixel boundaries. In this case, the position of z[0, 0] is\n    the center of the pixel, not a corner. If *origin* is *None*, then\n    (*x0*, *y0*) is the position of z[0, 0], and (*x1*, *y1*) is the position\n    of z[-1, -1].\n\n    This argument is ignored if *X* and *Y* are specified in the call to\n    contour.\n\nlocator : ticker.Locator subclass, optional\n    The locator is used to determine the contour levels if they are not given\n    explicitly via *levels*.\n    Defaults to `~.ticker.MaxNLocator`.\n\nextend : {\'neither\', \'both\', \'min\', \'max\'}, default: \'neither\'\n    Determines the ``%%(func)s``-coloring of values that are outside the\n    *levels* range.\n\n    If \'neither\', values outside the *levels* range are not colored.  If \'min\',\n    \'max\' or \'both\', color the values below, above or below and above the\n    *levels* range.\n\n    Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\n    under/over values of the `.Colormap`. Note that most colormaps do not have\n    dedicated colors for these by default, so that the over and under values\n    are the edge values of the colormap.  You may want to set these values\n    explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\n\n    .. note::\n\n        An existing `.TriContourSet` does not get notified if properties of its\n        colormap are changed. Therefore, an explicit call to\n        `.ContourSet.changed()` is needed after modifying the colormap. The\n        explicit call can be left out, if a colorbar is assigned to the\n        `.TriContourSet` because it internally calls `.ContourSet.changed()`.\n\nxunits, yunits : registered units, optional\n    Override axis units by specifying an instance of a\n    :class:`matplotlib.units.ConversionInterface`.\n\nantialiased : bool, optional\n    Enable antialiasing, overriding the defaults.  For\n    filled contours, the default is *True*.  For line contours,\n    it is taken from :rc:`lines.antialiased`.' % _docstring.interpd.params)

@_docstring.Substitution(func='tricontour', type='lines')
@_docstring.dedent_interpd
def tricontour(ax, *args, **kwargs):
    kwargs['filled'] = False
    return TriContourSet(ax, *args, **kwargs)

@_docstring.Substitution(func='tricontourf', type='regions')
@_docstring.dedent_interpd
def tricontourf(ax, *args, **kwargs):
    kwargs['filled'] = True
    return TriContourSet(ax, *args, **kwargs)

# File: matplotlib-main/lib/matplotlib/tri/_trifinder.py
import numpy as np
from matplotlib import _api
from matplotlib.tri import Triangulation

class TriFinder:

    def __init__(self, triangulation):
        _api.check_isinstance(Triangulation, triangulation=triangulation)
        self._triangulation = triangulation

    def __call__(self, x, y):
        raise NotImplementedError

class TrapezoidMapTriFinder(TriFinder):

    def __init__(self, triangulation):
        from matplotlib import _tri
        super().__init__(triangulation)
        self._cpp_trifinder = _tri.TrapezoidMapTriFinder(triangulation.get_cpp_triangulation())
        self._initialize()

    def __call__(self, x, y):
        x = np.asarray(x, dtype=np.float64)
        y = np.asarray(y, dtype=np.float64)
        if x.shape != y.shape:
            raise ValueError('x and y must be array-like with the same shape')
        indices = self._cpp_trifinder.find_many(x.ravel(), y.ravel()).reshape(x.shape)
        return indices

    def _get_tree_stats(self):
        return self._cpp_trifinder.get_tree_stats()

    def _initialize(self):
        self._cpp_trifinder.initialize()

    def _print_tree(self):
        self._cpp_trifinder.print_tree()

# File: matplotlib-main/lib/matplotlib/tri/_triinterpolate.py
""""""
import numpy as np
from matplotlib import _api
from matplotlib.tri import Triangulation
from matplotlib.tri._trifinder import TriFinder
from matplotlib.tri._tritools import TriAnalyzer
__all__ = ('TriInterpolator', 'LinearTriInterpolator', 'CubicTriInterpolator')

class TriInterpolator:

    def __init__(self, triangulation, z, trifinder=None):
        _api.check_isinstance(Triangulation, triangulation=triangulation)
        self._triangulation = triangulation
        self._z = np.asarray(z)
        if self._z.shape != self._triangulation.x.shape:
            raise ValueError('z array must have same length as triangulation x and y arrays')
        _api.check_isinstance((TriFinder, None), trifinder=trifinder)
        self._trifinder = trifinder or self._triangulation.get_trifinder()
        self._unit_x = 1.0
        self._unit_y = 1.0
        self._tri_renum = None
    _docstring__call__ = '\n        Returns a masked array containing interpolated values at the specified\n        (x, y) points.\n\n        Parameters\n        ----------\n        x, y : array-like\n            x and y coordinates of the same shape and any number of\n            dimensions.\n\n        Returns\n        -------\n        np.ma.array\n            Masked array of the same shape as *x* and *y*; values corresponding\n            to (*x*, *y*) points outside of the triangulation are masked out.\n\n        '
    _docstringgradient = '\n        Returns a list of 2 masked arrays containing interpolated derivatives\n        at the specified (x, y) points.\n\n        Parameters\n        ----------\n        x, y : array-like\n            x and y coordinates of the same shape and any number of\n            dimensions.\n\n        Returns\n        -------\n        dzdx, dzdy : np.ma.array\n            2 masked arrays of the same shape as *x* and *y*; values\n            corresponding to (x, y) points outside of the triangulation\n            are masked out.\n            The first returned array contains the values of\n            :math:`\\frac{\\partial z}{\\partial x}` and the second those of\n            :math:`\\frac{\\partial z}{\\partial y}`.\n\n        '

    def _interpolate_multikeys(self, x, y, tri_index=None, return_keys=('z',)):
        x = np.asarray(x, dtype=np.float64)
        y = np.asarray(y, dtype=np.float64)
        sh_ret = x.shape
        if x.shape != y.shape:
            raise ValueError(f'x and y shall have same shapes. Given: {x.shape} and {y.shape}')
        x = np.ravel(x)
        y = np.ravel(y)
        x_scaled = x / self._unit_x
        y_scaled = y / self._unit_y
        size_ret = np.size(x_scaled)
        if tri_index is None:
            tri_index = self._trifinder(x, y)
        else:
            if tri_index.shape != sh_ret:
                raise ValueError(f'tri_index array is provided and shall have same shape as x and y. Given: {tri_index.shape} and {sh_ret}')
            tri_index = np.ravel(tri_index)
        mask_in = tri_index != -1
        if self._tri_renum is None:
            valid_tri_index = tri_index[mask_in]
        else:
            valid_tri_index = self._tri_renum[tri_index[mask_in]]
        valid_x = x_scaled[mask_in]
        valid_y = y_scaled[mask_in]
        ret = []
        for return_key in return_keys:
            try:
                return_index = {'z': 0, 'dzdx': 1, 'dzdy': 2}[return_key]
            except KeyError as err:
                raise ValueError("return_keys items shall take values in {'z', 'dzdx', 'dzdy'}") from err
            scale = [1.0, 1.0 / self._unit_x, 1.0 / self._unit_y][return_index]
            ret_loc = np.empty(size_ret, dtype=np.float64)
            ret_loc[~mask_in] = np.nan
            ret_loc[mask_in] = self._interpolate_single_key(return_key, valid_tri_index, valid_x, valid_y) * scale
            ret += [np.ma.masked_invalid(ret_loc.reshape(sh_ret), copy=False)]
        return ret

    def _interpolate_single_key(self, return_key, tri_index, x, y):
        raise NotImplementedError('TriInterpolator subclasses' + 'should implement _interpolate_single_key!')

class LinearTriInterpolator(TriInterpolator):

    def __init__(self, triangulation, z, trifinder=None):
        super().__init__(triangulation, z, trifinder)
        self._plane_coefficients = self._triangulation.calculate_plane_coefficients(self._z)

    def __call__(self, x, y):
        return self._interpolate_multikeys(x, y, tri_index=None, return_keys=('z',))[0]
    __call__.__doc__ = TriInterpolator._docstring__call__

    def gradient(self, x, y):
        return self._interpolate_multikeys(x, y, tri_index=None, return_keys=('dzdx', 'dzdy'))
    gradient.__doc__ = TriInterpolator._docstringgradient

    def _interpolate_single_key(self, return_key, tri_index, x, y):
        _api.check_in_list(['z', 'dzdx', 'dzdy'], return_key=return_key)
        if return_key == 'z':
            return self._plane_coefficients[tri_index, 0] * x + self._plane_coefficients[tri_index, 1] * y + self._plane_coefficients[tri_index, 2]
        elif return_key == 'dzdx':
            return self._plane_coefficients[tri_index, 0]
        else:
            return self._plane_coefficients[tri_index, 1]

class CubicTriInterpolator(TriInterpolator):

    def __init__(self, triangulation, z, kind='min_E', trifinder=None, dz=None):
        super().__init__(triangulation, z, trifinder)
        self._triangulation.get_cpp_triangulation()
        tri_analyzer = TriAnalyzer(self._triangulation)
        (compressed_triangles, compressed_x, compressed_y, tri_renum, node_renum) = tri_analyzer._get_compressed_triangulation()
        self._triangles = compressed_triangles
        self._tri_renum = tri_renum
        valid_node = node_renum != -1
        self._z[node_renum[valid_node]] = self._z[valid_node]
        self._unit_x = np.ptp(compressed_x)
        self._unit_y = np.ptp(compressed_y)
        self._pts = np.column_stack([compressed_x / self._unit_x, compressed_y / self._unit_y])
        self._tris_pts = self._pts[self._triangles]
        self._eccs = self._compute_tri_eccentricities(self._tris_pts)
        _api.check_in_list(['user', 'geom', 'min_E'], kind=kind)
        self._dof = self._compute_dof(kind, dz=dz)
        self._ReferenceElement = _ReducedHCT_Element()

    def __call__(self, x, y):
        return self._interpolate_multikeys(x, y, tri_index=None, return_keys=('z',))[0]
    __call__.__doc__ = TriInterpolator._docstring__call__

    def gradient(self, x, y):
        return self._interpolate_multikeys(x, y, tri_index=None, return_keys=('dzdx', 'dzdy'))
    gradient.__doc__ = TriInterpolator._docstringgradient

    def _interpolate_single_key(self, return_key, tri_index, x, y):
        _api.check_in_list(['z', 'dzdx', 'dzdy'], return_key=return_key)
        tris_pts = self._tris_pts[tri_index]
        alpha = self._get_alpha_vec(x, y, tris_pts)
        ecc = self._eccs[tri_index]
        dof = np.expand_dims(self._dof[tri_index], axis=1)
        if return_key == 'z':
            return self._ReferenceElement.get_function_values(alpha, ecc, dof)
        else:
            J = self._get_jacobian(tris_pts)
            dzdx = self._ReferenceElement.get_function_derivatives(alpha, J, ecc, dof)
            if return_key == 'dzdx':
                return dzdx[:, 0, 0]
            else:
                return dzdx[:, 1, 0]

    def _compute_dof(self, kind, dz=None):
        if kind == 'user':
            if dz is None:
                raise ValueError("For a CubicTriInterpolator with *kind*='user', a valid *dz* argument is expected.")
            TE = _DOF_estimator_user(self, dz=dz)
        elif kind == 'geom':
            TE = _DOF_estimator_geom(self)
        else:
            TE = _DOF_estimator_min_E(self)
        return TE.compute_dof_from_df()

    @staticmethod
    def _get_alpha_vec(x, y, tris_pts):
        ndim = tris_pts.ndim - 2
        a = tris_pts[:, 1, :] - tris_pts[:, 0, :]
        b = tris_pts[:, 2, :] - tris_pts[:, 0, :]
        abT = np.stack([a, b], axis=-1)
        ab = _transpose_vectorized(abT)
        OM = np.stack([x, y], axis=1) - tris_pts[:, 0, :]
        metric = ab @ abT
        metric_inv = _pseudo_inv22sym_vectorized(metric)
        Covar = ab @ _transpose_vectorized(np.expand_dims(OM, ndim))
        ksi = metric_inv @ Covar
        alpha = _to_matrix_vectorized([[1 - ksi[:, 0, 0] - ksi[:, 1, 0]], [ksi[:, 0, 0]], [ksi[:, 1, 0]]])
        return alpha

    @staticmethod
    def _get_jacobian(tris_pts):
        a = np.array(tris_pts[:, 1, :] - tris_pts[:, 0, :])
        b = np.array(tris_pts[:, 2, :] - tris_pts[:, 0, :])
        J = _to_matrix_vectorized([[a[:, 0], a[:, 1]], [b[:, 0], b[:, 1]]])
        return J

    @staticmethod
    def _compute_tri_eccentricities(tris_pts):
        a = np.expand_dims(tris_pts[:, 2, :] - tris_pts[:, 1, :], axis=2)
        b = np.expand_dims(tris_pts[:, 0, :] - tris_pts[:, 2, :], axis=2)
        c = np.expand_dims(tris_pts[:, 1, :] - tris_pts[:, 0, :], axis=2)
        dot_a = (_transpose_vectorized(a) @ a)[:, 0, 0]
        dot_b = (_transpose_vectorized(b) @ b)[:, 0, 0]
        dot_c = (_transpose_vectorized(c) @ c)[:, 0, 0]
        return _to_matrix_vectorized([[(dot_c - dot_b) / dot_a], [(dot_a - dot_c) / dot_b], [(dot_b - dot_a) / dot_c]])

class _ReducedHCT_Element:
    M = np.array([[0.0, 0.0, 0.0, 4.5, 4.5, 0.0, 0.0, 0.0, 0.0, 0.0], [-0.25, 0.0, 0.0, 0.5, 1.25, 0.0, 0.0, 0.0, 0.0, 0.0], [-0.25, 0.0, 0.0, 1.25, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0], [0.5, 1.0, 0.0, -1.5, 0.0, 3.0, 3.0, 0.0, 0.0, 3.0], [0.0, 0.0, 0.0, -0.25, 0.25, 0.0, 1.0, 0.0, 0.0, 0.5], [0.25, 0.0, 0.0, -0.5, -0.25, 1.0, 0.0, 0.0, 0.0, 1.0], [0.5, 0.0, 1.0, 0.0, -1.5, 0.0, 0.0, 3.0, 3.0, 3.0], [0.25, 0.0, 0.0, -0.25, -0.5, 0.0, 0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.25, -0.25, 0.0, 0.0, 1.0, 0.0, 0.5]])
    M0 = np.array([[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 1.5, 1.5, 0.0, 0.0, 0.0, 0.0, -3.0], [-0.5, 0.0, 0.0, 0.75, 0.75, 0.0, 0.0, 0.0, 0.0, -1.5], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, -1.5, -1.5, 0.0, 0.0, 0.0, 0.0, 3.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.5, 0.0, 0.0, -0.75, -0.75, 0.0, 0.0, 0.0, 0.0, 1.5]])
    M1 = np.array([[-0.5, 0.0, 0.0, 1.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [-0.25, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.5, 0.0, 0.0, -1.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.25, 0.0, 0.0, -0.75, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])
    M2 = np.array([[0.5, 0.0, 0.0, 0.0, -1.5, 0.0, 0.0, 0.0, 0.0, 0.0], [0.25, 0.0, 0.0, 0.0, -0.75, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [-0.5, 0.0, 0.0, 0.0, 1.5, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [-0.25, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])
    rotate_dV = np.array([[1.0, 0.0], [0.0, 1.0], [0.0, 1.0], [-1.0, -1.0], [-1.0, -1.0], [1.0, 0.0]])
    rotate_d2V = np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0], [1.0, 1.0, 1.0], [0.0, -2.0, -1.0], [1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [-2.0, 0.0, -1.0]])
    n_gauss = 9
    gauss_pts = np.array([[13.0 / 18.0, 4.0 / 18.0, 1.0 / 18.0], [4.0 / 18.0, 13.0 / 18.0, 1.0 / 18.0], [7.0 / 18.0, 7.0 / 18.0, 4.0 / 18.0], [1.0 / 18.0, 13.0 / 18.0, 4.0 / 18.0], [1.0 / 18.0, 4.0 / 18.0, 13.0 / 18.0], [4.0 / 18.0, 7.0 / 18.0, 7.0 / 18.0], [4.0 / 18.0, 1.0 / 18.0, 13.0 / 18.0], [13.0 / 18.0, 1.0 / 18.0, 4.0 / 18.0], [7.0 / 18.0, 4.0 / 18.0, 7.0 / 18.0]], dtype=np.float64)
    gauss_w = np.ones([9], dtype=np.float64) / 9.0
    E = np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 2.0]])
    J0_to_J1 = np.array([[-1.0, 1.0], [-1.0, 0.0]])
    J0_to_J2 = np.array([[0.0, -1.0], [1.0, -1.0]])

    def get_function_values(self, alpha, ecc, dofs):
        subtri = np.argmin(alpha, axis=1)[:, 0]
        ksi = _roll_vectorized(alpha, -subtri, axis=0)
        E = _roll_vectorized(ecc, -subtri, axis=0)
        x = ksi[:, 0, 0]
        y = ksi[:, 1, 0]
        z = ksi[:, 2, 0]
        x_sq = x * x
        y_sq = y * y
        z_sq = z * z
        V = _to_matrix_vectorized([[x_sq * x], [y_sq * y], [z_sq * z], [x_sq * z], [x_sq * y], [y_sq * x], [y_sq * z], [z_sq * y], [z_sq * x], [x * y * z]])
        prod = self.M @ V
        prod += _scalar_vectorized(E[:, 0, 0], self.M0 @ V)
        prod += _scalar_vectorized(E[:, 1, 0], self.M1 @ V)
        prod += _scalar_vectorized(E[:, 2, 0], self.M2 @ V)
        s = _roll_vectorized(prod, 3 * subtri, axis=0)
        return (dofs @ s)[:, 0, 0]

    def get_function_derivatives(self, alpha, J, ecc, dofs):
        subtri = np.argmin(alpha, axis=1)[:, 0]
        ksi = _roll_vectorized(alpha, -subtri, axis=0)
        E = _roll_vectorized(ecc, -subtri, axis=0)
        x = ksi[:, 0, 0]
        y = ksi[:, 1, 0]
        z = ksi[:, 2, 0]
        x_sq = x * x
        y_sq = y * y
        z_sq = z * z
        dV = _to_matrix_vectorized([[-3.0 * x_sq, -3.0 * x_sq], [3.0 * y_sq, 0.0], [0.0, 3.0 * z_sq], [-2.0 * x * z, -2.0 * x * z + x_sq], [-2.0 * x * y + x_sq, -2.0 * x * y], [2.0 * x * y - y_sq, -y_sq], [2.0 * y * z, y_sq], [z_sq, 2.0 * y * z], [-z_sq, 2.0 * x * z - z_sq], [x * z - y * z, x * y - y * z]])
        dV = dV @ _extract_submatrices(self.rotate_dV, subtri, block_size=2, axis=0)
        prod = self.M @ dV
        prod += _scalar_vectorized(E[:, 0, 0], self.M0 @ dV)
        prod += _scalar_vectorized(E[:, 1, 0], self.M1 @ dV)
        prod += _scalar_vectorized(E[:, 2, 0], self.M2 @ dV)
        dsdksi = _roll_vectorized(prod, 3 * subtri, axis=0)
        dfdksi = dofs @ dsdksi
        J_inv = _safe_inv22_vectorized(J)
        dfdx = J_inv @ _transpose_vectorized(dfdksi)
        return dfdx

    def get_function_hessians(self, alpha, J, ecc, dofs):
        d2sdksi2 = self.get_d2Sidksij2(alpha, ecc)
        d2fdksi2 = dofs @ d2sdksi2
        H_rot = self.get_Hrot_from_J(J)
        d2fdx2 = d2fdksi2 @ H_rot
        return _transpose_vectorized(d2fdx2)

    def get_d2Sidksij2(self, alpha, ecc):
        subtri = np.argmin(alpha, axis=1)[:, 0]
        ksi = _roll_vectorized(alpha, -subtri, axis=0)
        E = _roll_vectorized(ecc, -subtri, axis=0)
        x = ksi[:, 0, 0]
        y = ksi[:, 1, 0]
        z = ksi[:, 2, 0]
        d2V = _to_matrix_vectorized([[6.0 * x, 6.0 * x, 6.0 * x], [6.0 * y, 0.0, 0.0], [0.0, 6.0 * z, 0.0], [2.0 * z, 2.0 * z - 4.0 * x, 2.0 * z - 2.0 * x], [2.0 * y - 4.0 * x, 2.0 * y, 2.0 * y - 2.0 * x], [2.0 * x - 4.0 * y, 0.0, -2.0 * y], [2.0 * z, 0.0, 2.0 * y], [0.0, 2.0 * y, 2.0 * z], [0.0, 2.0 * x - 4.0 * z, -2.0 * z], [-2.0 * z, -2.0 * y, x - y - z]])
        d2V = d2V @ _extract_submatrices(self.rotate_d2V, subtri, block_size=3, axis=0)
        prod = self.M @ d2V
        prod += _scalar_vectorized(E[:, 0, 0], self.M0 @ d2V)
        prod += _scalar_vectorized(E[:, 1, 0], self.M1 @ d2V)
        prod += _scalar_vectorized(E[:, 2, 0], self.M2 @ d2V)
        d2sdksi2 = _roll_vectorized(prod, 3 * subtri, axis=0)
        return d2sdksi2

    def get_bending_matrices(self, J, ecc):
        n = np.size(ecc, 0)
        J1 = self.J0_to_J1 @ J
        J2 = self.J0_to_J2 @ J
        DOF_rot = np.zeros([n, 9, 9], dtype=np.float64)
        DOF_rot[:, 0, 0] = 1
        DOF_rot[:, 3, 3] = 1
        DOF_rot[:, 6, 6] = 1
        DOF_rot[:, 1:3, 1:3] = J
        DOF_rot[:, 4:6, 4:6] = J1
        DOF_rot[:, 7:9, 7:9] = J2
        (H_rot, area) = self.get_Hrot_from_J(J, return_area=True)
        K = np.zeros([n, 9, 9], dtype=np.float64)
        weights = self.gauss_w
        pts = self.gauss_pts
        for igauss in range(self.n_gauss):
            alpha = np.tile(pts[igauss, :], n).reshape(n, 3)
            alpha = np.expand_dims(alpha, 2)
            weight = weights[igauss]
            d2Skdksi2 = self.get_d2Sidksij2(alpha, ecc)
            d2Skdx2 = d2Skdksi2 @ H_rot
            K += weight * (d2Skdx2 @ self.E @ _transpose_vectorized(d2Skdx2))
        K = _transpose_vectorized(DOF_rot) @ K @ DOF_rot
        return _scalar_vectorized(area, K)

    def get_Hrot_from_J(self, J, return_area=False):
        J_inv = _safe_inv22_vectorized(J)
        Ji00 = J_inv[:, 0, 0]
        Ji11 = J_inv[:, 1, 1]
        Ji10 = J_inv[:, 1, 0]
        Ji01 = J_inv[:, 0, 1]
        H_rot = _to_matrix_vectorized([[Ji00 * Ji00, Ji10 * Ji10, Ji00 * Ji10], [Ji01 * Ji01, Ji11 * Ji11, Ji01 * Ji11], [2 * Ji00 * Ji01, 2 * Ji11 * Ji10, Ji00 * Ji11 + Ji10 * Ji01]])
        if not return_area:
            return H_rot
        else:
            area = 0.5 * (J[:, 0, 0] * J[:, 1, 1] - J[:, 0, 1] * J[:, 1, 0])
            return (H_rot, area)

    def get_Kff_and_Ff(self, J, ecc, triangles, Uc):
        ntri = np.size(ecc, 0)
        vec_range = np.arange(ntri, dtype=np.int32)
        c_indices = np.full(ntri, -1, dtype=np.int32)
        f_dof = [1, 2, 4, 5, 7, 8]
        c_dof = [0, 3, 6]
        f_dof_indices = _to_matrix_vectorized([[c_indices, triangles[:, 0] * 2, triangles[:, 0] * 2 + 1, c_indices, triangles[:, 1] * 2, triangles[:, 1] * 2 + 1, c_indices, triangles[:, 2] * 2, triangles[:, 2] * 2 + 1]])
        expand_indices = np.ones([ntri, 9, 1], dtype=np.int32)
        f_row_indices = _transpose_vectorized(expand_indices @ f_dof_indices)
        f_col_indices = expand_indices @ f_dof_indices
        K_elem = self.get_bending_matrices(J, ecc)
        Kff_vals = np.ravel(K_elem[np.ix_(vec_range, f_dof, f_dof)])
        Kff_rows = np.ravel(f_row_indices[np.ix_(vec_range, f_dof, f_dof)])
        Kff_cols = np.ravel(f_col_indices[np.ix_(vec_range, f_dof, f_dof)])
        Kfc_elem = K_elem[np.ix_(vec_range, f_dof, c_dof)]
        Uc_elem = np.expand_dims(Uc, axis=2)
        Ff_elem = -(Kfc_elem @ Uc_elem)[:, :, 0]
        Ff_indices = f_dof_indices[np.ix_(vec_range, [0], f_dof)][:, 0, :]
        Ff = np.bincount(np.ravel(Ff_indices), weights=np.ravel(Ff_elem))
        return (Kff_rows, Kff_cols, Kff_vals, Ff)

class _DOF_estimator:

    def __init__(self, interpolator, **kwargs):
        _api.check_isinstance(CubicTriInterpolator, interpolator=interpolator)
        self._pts = interpolator._pts
        self._tris_pts = interpolator._tris_pts
        self.z = interpolator._z
        self._triangles = interpolator._triangles
        (self._unit_x, self._unit_y) = (interpolator._unit_x, interpolator._unit_y)
        self.dz = self.compute_dz(**kwargs)
        self.compute_dof_from_df()

    def compute_dz(self, **kwargs):
        raise NotImplementedError

    def compute_dof_from_df(self):
        J = CubicTriInterpolator._get_jacobian(self._tris_pts)
        tri_z = self.z[self._triangles]
        tri_dz = self.dz[self._triangles]
        tri_dof = self.get_dof_vec(tri_z, tri_dz, J)
        return tri_dof

    @staticmethod
    def get_dof_vec(tri_z, tri_dz, J):
        npt = tri_z.shape[0]
        dof = np.zeros([npt, 9], dtype=np.float64)
        J1 = _ReducedHCT_Element.J0_to_J1 @ J
        J2 = _ReducedHCT_Element.J0_to_J2 @ J
        col0 = J @ np.expand_dims(tri_dz[:, 0, :], axis=2)
        col1 = J1 @ np.expand_dims(tri_dz[:, 1, :], axis=2)
        col2 = J2 @ np.expand_dims(tri_dz[:, 2, :], axis=2)
        dfdksi = _to_matrix_vectorized([[col0[:, 0, 0], col1[:, 0, 0], col2[:, 0, 0]], [col0[:, 1, 0], col1[:, 1, 0], col2[:, 1, 0]]])
        dof[:, 0:7:3] = tri_z
        dof[:, 1:8:3] = dfdksi[:, 0]
        dof[:, 2:9:3] = dfdksi[:, 1]
        return dof

class _DOF_estimator_user(_DOF_estimator):

    def compute_dz(self, dz):
        (dzdx, dzdy) = dz
        dzdx = dzdx * self._unit_x
        dzdy = dzdy * self._unit_y
        return np.vstack([dzdx, dzdy]).T

class _DOF_estimator_geom(_DOF_estimator):

    def compute_dz(self):
        el_geom_w = self.compute_geom_weights()
        el_geom_grad = self.compute_geom_grads()
        w_node_sum = np.bincount(np.ravel(self._triangles), weights=np.ravel(el_geom_w))
        dfx_el_w = np.empty_like(el_geom_w)
        dfy_el_w = np.empty_like(el_geom_w)
        for iapex in range(3):
            dfx_el_w[:, iapex] = el_geom_w[:, iapex] * el_geom_grad[:, 0]
            dfy_el_w[:, iapex] = el_geom_w[:, iapex] * el_geom_grad[:, 1]
        dfx_node_sum = np.bincount(np.ravel(self._triangles), weights=np.ravel(dfx_el_w))
        dfy_node_sum = np.bincount(np.ravel(self._triangles), weights=np.ravel(dfy_el_w))
        dfx_estim = dfx_node_sum / w_node_sum
        dfy_estim = dfy_node_sum / w_node_sum
        return np.vstack([dfx_estim, dfy_estim]).T

    def compute_geom_weights(self):
        weights = np.zeros([np.size(self._triangles, 0), 3])
        tris_pts = self._tris_pts
        for ipt in range(3):
            p0 = tris_pts[:, ipt % 3, :]
            p1 = tris_pts[:, (ipt + 1) % 3, :]
            p2 = tris_pts[:, (ipt - 1) % 3, :]
            alpha1 = np.arctan2(p1[:, 1] - p0[:, 1], p1[:, 0] - p0[:, 0])
            alpha2 = np.arctan2(p2[:, 1] - p0[:, 1], p2[:, 0] - p0[:, 0])
            angle = np.abs((alpha2 - alpha1) / np.pi % 1)
            weights[:, ipt] = 0.5 - np.abs(angle - 0.5)
        return weights

    def compute_geom_grads(self):
        tris_pts = self._tris_pts
        tris_f = self.z[self._triangles]
        dM1 = tris_pts[:, 1, :] - tris_pts[:, 0, :]
        dM2 = tris_pts[:, 2, :] - tris_pts[:, 0, :]
        dM = np.dstack([dM1, dM2])
        dM_inv = _safe_inv22_vectorized(dM)
        dZ1 = tris_f[:, 1] - tris_f[:, 0]
        dZ2 = tris_f[:, 2] - tris_f[:, 0]
        dZ = np.vstack([dZ1, dZ2]).T
        df = np.empty_like(dZ)
        df[:, 0] = dZ[:, 0] * dM_inv[:, 0, 0] + dZ[:, 1] * dM_inv[:, 1, 0]
        df[:, 1] = dZ[:, 0] * dM_inv[:, 0, 1] + dZ[:, 1] * dM_inv[:, 1, 1]
        return df

class _DOF_estimator_min_E(_DOF_estimator_geom):

    def __init__(self, Interpolator):
        self._eccs = Interpolator._eccs
        super().__init__(Interpolator)

    def compute_dz(self):
        dz_init = super().compute_dz()
        Uf0 = np.ravel(dz_init)
        reference_element = _ReducedHCT_Element()
        J = CubicTriInterpolator._get_jacobian(self._tris_pts)
        eccs = self._eccs
        triangles = self._triangles
        Uc = self.z[self._triangles]
        (Kff_rows, Kff_cols, Kff_vals, Ff) = reference_element.get_Kff_and_Ff(J, eccs, triangles, Uc)
        tol = 1e-10
        n_dof = Ff.shape[0]
        Kff_coo = _Sparse_Matrix_coo(Kff_vals, Kff_rows, Kff_cols, shape=(n_dof, n_dof))
        Kff_coo.compress_csc()
        (Uf, err) = _cg(A=Kff_coo, b=Ff, x0=Uf0, tol=tol)
        err0 = np.linalg.norm(Kff_coo.dot(Uf0) - Ff)
        if err0 < err:
            _api.warn_external('In TriCubicInterpolator initialization, PCG sparse solver did not converge after 1000 iterations. `geom` approximation is used instead of `min_E`')
            Uf = Uf0
        dz = np.empty([self._pts.shape[0], 2], dtype=np.float64)
        dz[:, 0] = Uf[::2]
        dz[:, 1] = Uf[1::2]
        return dz

class _Sparse_Matrix_coo:

    def __init__(self, vals, rows, cols, shape):
        (self.n, self.m) = shape
        self.vals = np.asarray(vals, dtype=np.float64)
        self.rows = np.asarray(rows, dtype=np.int32)
        self.cols = np.asarray(cols, dtype=np.int32)

    def dot(self, V):
        assert V.shape == (self.m,)
        return np.bincount(self.rows, weights=self.vals * V[self.cols], minlength=self.m)

    def compress_csc(self):
        (_, unique, indices) = np.unique(self.rows + self.n * self.cols, return_index=True, return_inverse=True)
        self.rows = self.rows[unique]
        self.cols = self.cols[unique]
        self.vals = np.bincount(indices, weights=self.vals)

    def compress_csr(self):
        (_, unique, indices) = np.unique(self.m * self.rows + self.cols, return_index=True, return_inverse=True)
        self.rows = self.rows[unique]
        self.cols = self.cols[unique]
        self.vals = np.bincount(indices, weights=self.vals)

    def to_dense(self):
        ret = np.zeros([self.n, self.m], dtype=np.float64)
        nvals = self.vals.size
        for i in range(nvals):
            ret[self.rows[i], self.cols[i]] += self.vals[i]
        return ret

    def __str__(self):
        return self.to_dense().__str__()

    @property
    def diag(self):
        in_diag = self.rows == self.cols
        diag = np.zeros(min(self.n, self.n), dtype=np.float64)
        diag[self.rows[in_diag]] = self.vals[in_diag]
        return diag

def _cg(A, b, x0=None, tol=1e-10, maxiter=1000):
    n = b.size
    assert A.n == n
    assert A.m == n
    b_norm = np.linalg.norm(b)
    kvec = A.diag
    kvec = np.maximum(kvec, 1e-06)
    if x0 is None:
        x = np.zeros(n)
    else:
        x = x0
    r = b - A.dot(x)
    w = r / kvec
    p = np.zeros(n)
    beta = 0.0
    rho = np.dot(r, w)
    k = 0
    while np.sqrt(abs(rho)) > tol * b_norm and k < maxiter:
        p = w + beta * p
        z = A.dot(p)
        alpha = rho / np.dot(p, z)
        r = r - alpha * z
        w = r / kvec
        rhoold = rho
        rho = np.dot(r, w)
        x = x + alpha * p
        beta = rho / rhoold
        k += 1
    err = np.linalg.norm(A.dot(x) - b)
    return (x, err)

def _safe_inv22_vectorized(M):
    _api.check_shape((None, 2, 2), M=M)
    M_inv = np.empty_like(M)
    prod1 = M[:, 0, 0] * M[:, 1, 1]
    delta = prod1 - M[:, 0, 1] * M[:, 1, 0]
    rank2 = np.abs(delta) > 1e-08 * np.abs(prod1)
    if np.all(rank2):
        delta_inv = 1.0 / delta
    else:
        delta_inv = np.zeros(M.shape[0])
        delta_inv[rank2] = 1.0 / delta[rank2]
    M_inv[:, 0, 0] = M[:, 1, 1] * delta_inv
    M_inv[:, 0, 1] = -M[:, 0, 1] * delta_inv
    M_inv[:, 1, 0] = -M[:, 1, 0] * delta_inv
    M_inv[:, 1, 1] = M[:, 0, 0] * delta_inv
    return M_inv

def _pseudo_inv22sym_vectorized(M):
    _api.check_shape((None, 2, 2), M=M)
    M_inv = np.empty_like(M)
    prod1 = M[:, 0, 0] * M[:, 1, 1]
    delta = prod1 - M[:, 0, 1] * M[:, 1, 0]
    rank2 = np.abs(delta) > 1e-08 * np.abs(prod1)
    if np.all(rank2):
        M_inv[:, 0, 0] = M[:, 1, 1] / delta
        M_inv[:, 0, 1] = -M[:, 0, 1] / delta
        M_inv[:, 1, 0] = -M[:, 1, 0] / delta
        M_inv[:, 1, 1] = M[:, 0, 0] / delta
    else:
        delta = delta[rank2]
        M_inv[rank2, 0, 0] = M[rank2, 1, 1] / delta
        M_inv[rank2, 0, 1] = -M[rank2, 0, 1] / delta
        M_inv[rank2, 1, 0] = -M[rank2, 1, 0] / delta
        M_inv[rank2, 1, 1] = M[rank2, 0, 0] / delta
        rank01 = ~rank2
        tr = M[rank01, 0, 0] + M[rank01, 1, 1]
        tr_zeros = np.abs(tr) < 1e-08
        sq_tr_inv = (1.0 - tr_zeros) / (tr ** 2 + tr_zeros)
        M_inv[rank01, 0, 0] = M[rank01, 0, 0] * sq_tr_inv
        M_inv[rank01, 0, 1] = M[rank01, 0, 1] * sq_tr_inv
        M_inv[rank01, 1, 0] = M[rank01, 1, 0] * sq_tr_inv
        M_inv[rank01, 1, 1] = M[rank01, 1, 1] * sq_tr_inv
    return M_inv

def _scalar_vectorized(scalar, M):
    return scalar[:, np.newaxis, np.newaxis] * M

def _transpose_vectorized(M):
    return np.transpose(M, [0, 2, 1])

def _roll_vectorized(M, roll_indices, axis):
    assert axis in [0, 1]
    ndim = M.ndim
    assert ndim == 3
    ndim_roll = roll_indices.ndim
    assert ndim_roll == 1
    sh = M.shape
    (r, c) = sh[-2:]
    assert sh[0] == roll_indices.shape[0]
    vec_indices = np.arange(sh[0], dtype=np.int32)
    M_roll = np.empty_like(M)
    if axis == 0:
        for ir in range(r):
            for ic in range(c):
                M_roll[:, ir, ic] = M[vec_indices, (-roll_indices + ir) % r, ic]
    else:
        for ir in range(r):
            for ic in range(c):
                M_roll[:, ir, ic] = M[vec_indices, ir, (-roll_indices + ic) % c]
    return M_roll

def _to_matrix_vectorized(M):
    assert isinstance(M, (tuple, list))
    assert all((isinstance(item, (tuple, list)) for item in M))
    c_vec = np.asarray([len(item) for item in M])
    assert np.all(c_vec - c_vec[0] == 0)
    r = len(M)
    c = c_vec[0]
    M00 = np.asarray(M[0][0])
    dt = M00.dtype
    sh = [M00.shape[0], r, c]
    M_ret = np.empty(sh, dtype=dt)
    for irow in range(r):
        for icol in range(c):
            M_ret[:, irow, icol] = np.asarray(M[irow][icol])
    return M_ret

def _extract_submatrices(M, block_indices, block_size, axis):
    assert block_indices.ndim == 1
    assert axis in [0, 1]
    (r, c) = M.shape
    if axis == 0:
        sh = [block_indices.shape[0], block_size, c]
    else:
        sh = [block_indices.shape[0], r, block_size]
    dt = M.dtype
    M_res = np.empty(sh, dtype=dt)
    if axis == 0:
        for ir in range(block_size):
            M_res[:, ir, :] = M[block_indices * block_size + ir, :]
    else:
        for ic in range(block_size):
            M_res[:, :, ic] = M[:, block_indices * block_size + ic]
    return M_res

# File: matplotlib-main/lib/matplotlib/tri/_tripcolor.py
import numpy as np
from matplotlib import _api
from matplotlib.collections import PolyCollection, TriMesh
from matplotlib.tri._triangulation import Triangulation

def tripcolor(ax, *args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs):
    _api.check_in_list(['flat', 'gouraud'], shading=shading)
    (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
    if facecolors is not None:
        if args:
            _api.warn_external('Positional parameter c has no effect when the keyword facecolors is given')
        point_colors = None
        if len(facecolors) != len(tri.triangles):
            raise ValueError('The length of facecolors must match the number of triangles')
    else:
        if not args:
            raise TypeError("tripcolor() missing 1 required positional argument: 'c'; or 1 required keyword-only argument: 'facecolors'")
        elif len(args) > 1:
            raise TypeError(f'Unexpected positional parameters: {args[1:]!r}')
        c = np.asarray(args[0])
        if len(c) == len(tri.x):
            point_colors = c
            facecolors = None
        elif len(c) == len(tri.triangles):
            point_colors = None
            facecolors = c
        else:
            raise ValueError('The length of c must match either the number of points or the number of triangles')
    linewidths = (0.25,)
    if 'linewidth' in kwargs:
        kwargs['linewidths'] = kwargs.pop('linewidth')
    kwargs.setdefault('linewidths', linewidths)
    edgecolors = 'none'
    if 'edgecolor' in kwargs:
        kwargs['edgecolors'] = kwargs.pop('edgecolor')
    ec = kwargs.setdefault('edgecolors', edgecolors)
    if 'antialiased' in kwargs:
        kwargs['antialiaseds'] = kwargs.pop('antialiased')
    if 'antialiaseds' not in kwargs and ec.lower() == 'none':
        kwargs['antialiaseds'] = False
    if shading == 'gouraud':
        if facecolors is not None:
            raise ValueError("shading='gouraud' can only be used when the colors are specified at the points, not at the faces.")
        collection = TriMesh(tri, alpha=alpha, array=point_colors, cmap=cmap, norm=norm, **kwargs)
    else:
        maskedTris = tri.get_masked_triangles()
        verts = np.stack((tri.x[maskedTris], tri.y[maskedTris]), axis=-1)
        if facecolors is None:
            colors = point_colors[maskedTris].mean(axis=1)
        elif tri.mask is not None:
            colors = facecolors[~tri.mask]
        else:
            colors = facecolors
        collection = PolyCollection(verts, alpha=alpha, array=colors, cmap=cmap, norm=norm, **kwargs)
    collection._scale_norm(norm, vmin, vmax)
    ax.grid(False)
    minx = tri.x.min()
    maxx = tri.x.max()
    miny = tri.y.min()
    maxy = tri.y.max()
    corners = ((minx, miny), (maxx, maxy))
    ax.update_datalim(corners)
    ax.autoscale_view()
    ax.add_collection(collection)
    return collection

# File: matplotlib-main/lib/matplotlib/tri/_triplot.py
import numpy as np
from matplotlib.tri._triangulation import Triangulation
import matplotlib.cbook as cbook
import matplotlib.lines as mlines

def triplot(ax, *args, **kwargs):
    import matplotlib.axes
    (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
    (x, y, edges) = (tri.x, tri.y, tri.edges)
    fmt = args[0] if args else ''
    (linestyle, marker, color) = matplotlib.axes._base._process_plot_format(fmt)
    kw = cbook.normalize_kwargs(kwargs, mlines.Line2D)
    for (key, val) in zip(('linestyle', 'marker', 'color'), (linestyle, marker, color)):
        if val is not None:
            kw.setdefault(key, val)
    linestyle = kw['linestyle']
    kw_lines = {**kw, 'marker': 'None', 'zorder': kw.get('zorder', 1)}
    if linestyle not in [None, 'None', '', ' ']:
        tri_lines_x = np.insert(x[edges], 2, np.nan, axis=1)
        tri_lines_y = np.insert(y[edges], 2, np.nan, axis=1)
        tri_lines = ax.plot(tri_lines_x.ravel(), tri_lines_y.ravel(), **kw_lines)
    else:
        tri_lines = ax.plot([], [], **kw_lines)
    marker = kw['marker']
    kw_markers = {**kw, 'linestyle': 'None'}
    kw_markers.pop('label', None)
    if marker not in [None, 'None', '', ' ']:
        tri_markers = ax.plot(x, y, **kw_markers)
    else:
        tri_markers = ax.plot([], [], **kw_markers)
    return tri_lines + tri_markers

# File: matplotlib-main/lib/matplotlib/tri/_trirefine.py
""""""
import numpy as np
from matplotlib import _api
from matplotlib.tri._triangulation import Triangulation
import matplotlib.tri._triinterpolate

class TriRefiner:

    def __init__(self, triangulation):
        _api.check_isinstance(Triangulation, triangulation=triangulation)
        self._triangulation = triangulation

class UniformTriRefiner(TriRefiner):

    def __init__(self, triangulation):
        super().__init__(triangulation)

    def refine_triangulation(self, return_tri_index=False, subdiv=3):
        refi_triangulation = self._triangulation
        ntri = refi_triangulation.triangles.shape[0]
        ancestors = np.arange(ntri, dtype=np.int32)
        for _ in range(subdiv):
            (refi_triangulation, ancestors) = self._refine_triangulation_once(refi_triangulation, ancestors)
        refi_npts = refi_triangulation.x.shape[0]
        refi_triangles = refi_triangulation.triangles
        if return_tri_index:
            found_index = np.full(refi_npts, -1, dtype=np.int32)
            tri_mask = self._triangulation.mask
            if tri_mask is None:
                found_index[refi_triangles] = np.repeat(ancestors, 3).reshape(-1, 3)
            else:
                ancestor_mask = tri_mask[ancestors]
                found_index[refi_triangles[ancestor_mask, :]] = np.repeat(ancestors[ancestor_mask], 3).reshape(-1, 3)
                found_index[refi_triangles[~ancestor_mask, :]] = np.repeat(ancestors[~ancestor_mask], 3).reshape(-1, 3)
            return (refi_triangulation, found_index)
        else:
            return refi_triangulation

    def refine_field(self, z, triinterpolator=None, subdiv=3):
        if triinterpolator is None:
            interp = matplotlib.tri.CubicTriInterpolator(self._triangulation, z)
        else:
            _api.check_isinstance(matplotlib.tri.TriInterpolator, triinterpolator=triinterpolator)
            interp = triinterpolator
        (refi_tri, found_index) = self.refine_triangulation(subdiv=subdiv, return_tri_index=True)
        refi_z = interp._interpolate_multikeys(refi_tri.x, refi_tri.y, tri_index=found_index)[0]
        return (refi_tri, refi_z)

    @staticmethod
    def _refine_triangulation_once(triangulation, ancestors=None):
        x = triangulation.x
        y = triangulation.y
        neighbors = triangulation.neighbors
        triangles = triangulation.triangles
        npts = np.shape(x)[0]
        ntri = np.shape(triangles)[0]
        if ancestors is not None:
            ancestors = np.asarray(ancestors)
            if np.shape(ancestors) != (ntri,):
                raise ValueError(f'Incompatible shapes provide for triangulation.masked_triangles and ancestors: {np.shape(triangles)} and {np.shape(ancestors)}')
        borders = np.sum(neighbors == -1)
        added_pts = (3 * ntri + borders) // 2
        refi_npts = npts + added_pts
        refi_x = np.zeros(refi_npts)
        refi_y = np.zeros(refi_npts)
        refi_x[:npts] = x
        refi_y[:npts] = y
        edge_elems = np.tile(np.arange(ntri, dtype=np.int32), 3)
        edge_apexes = np.repeat(np.arange(3, dtype=np.int32), ntri)
        edge_neighbors = neighbors[edge_elems, edge_apexes]
        mask_masters = edge_elems > edge_neighbors
        masters = edge_elems[mask_masters]
        apex_masters = edge_apexes[mask_masters]
        x_add = (x[triangles[masters, apex_masters]] + x[triangles[masters, (apex_masters + 1) % 3]]) * 0.5
        y_add = (y[triangles[masters, apex_masters]] + y[triangles[masters, (apex_masters + 1) % 3]]) * 0.5
        refi_x[npts:] = x_add
        refi_y[npts:] = y_add
        new_pt_corner = triangles
        new_pt_midside = np.empty([ntri, 3], dtype=np.int32)
        cum_sum = npts
        for imid in range(3):
            mask_st_loc = imid == apex_masters
            n_masters_loc = np.sum(mask_st_loc)
            elem_masters_loc = masters[mask_st_loc]
            new_pt_midside[:, imid][elem_masters_loc] = np.arange(n_masters_loc, dtype=np.int32) + cum_sum
            cum_sum += n_masters_loc
        mask_slaves = np.logical_not(mask_masters)
        slaves = edge_elems[mask_slaves]
        slaves_masters = edge_neighbors[mask_slaves]
        diff_table = np.abs(neighbors[slaves_masters, :] - np.outer(slaves, np.ones(3, dtype=np.int32)))
        slave_masters_apex = np.argmin(diff_table, axis=1)
        slaves_apex = edge_apexes[mask_slaves]
        new_pt_midside[slaves, slaves_apex] = new_pt_midside[slaves_masters, slave_masters_apex]
        child_triangles = np.empty([ntri * 4, 3], dtype=np.int32)
        child_triangles[0::4, :] = np.vstack([new_pt_corner[:, 0], new_pt_midside[:, 0], new_pt_midside[:, 2]]).T
        child_triangles[1::4, :] = np.vstack([new_pt_corner[:, 1], new_pt_midside[:, 1], new_pt_midside[:, 0]]).T
        child_triangles[2::4, :] = np.vstack([new_pt_corner[:, 2], new_pt_midside[:, 2], new_pt_midside[:, 1]]).T
        child_triangles[3::4, :] = np.vstack([new_pt_midside[:, 0], new_pt_midside[:, 1], new_pt_midside[:, 2]]).T
        child_triangulation = Triangulation(refi_x, refi_y, child_triangles)
        if triangulation.mask is not None:
            child_triangulation.set_mask(np.repeat(triangulation.mask, 4))
        if ancestors is None:
            return child_triangulation
        else:
            return (child_triangulation, np.repeat(ancestors, 4))

# File: matplotlib-main/lib/matplotlib/tri/_tritools.py
""""""
import numpy as np
from matplotlib import _api
from matplotlib.tri import Triangulation

class TriAnalyzer:

    def __init__(self, triangulation):
        _api.check_isinstance(Triangulation, triangulation=triangulation)
        self._triangulation = triangulation

    @property
    def scale_factors(self):
        compressed_triangles = self._triangulation.get_masked_triangles()
        node_used = np.bincount(np.ravel(compressed_triangles), minlength=self._triangulation.x.size) != 0
        return (1 / np.ptp(self._triangulation.x[node_used]), 1 / np.ptp(self._triangulation.y[node_used]))

    def circle_ratios(self, rescale=True):
        if rescale:
            (kx, ky) = self.scale_factors
        else:
            (kx, ky) = (1.0, 1.0)
        pts = np.vstack([self._triangulation.x * kx, self._triangulation.y * ky]).T
        tri_pts = pts[self._triangulation.triangles]
        a = tri_pts[:, 1, :] - tri_pts[:, 0, :]
        b = tri_pts[:, 2, :] - tri_pts[:, 1, :]
        c = tri_pts[:, 0, :] - tri_pts[:, 2, :]
        a = np.hypot(a[:, 0], a[:, 1])
        b = np.hypot(b[:, 0], b[:, 1])
        c = np.hypot(c[:, 0], c[:, 1])
        s = (a + b + c) * 0.5
        prod = s * (a + b - s) * (a + c - s) * (b + c - s)
        bool_flat = prod == 0.0
        if np.any(bool_flat):
            ntri = tri_pts.shape[0]
            circum_radius = np.empty(ntri, dtype=np.float64)
            circum_radius[bool_flat] = np.inf
            abc = a * b * c
            circum_radius[~bool_flat] = abc[~bool_flat] / (4.0 * np.sqrt(prod[~bool_flat]))
        else:
            circum_radius = a * b * c / (4.0 * np.sqrt(prod))
        in_radius = a * b * c / (4.0 * circum_radius * s)
        circle_ratio = in_radius / circum_radius
        mask = self._triangulation.mask
        if mask is None:
            return circle_ratio
        else:
            return np.ma.array(circle_ratio, mask=mask)

    def get_flat_tri_mask(self, min_circle_ratio=0.01, rescale=True):
        ntri = self._triangulation.triangles.shape[0]
        mask_bad_ratio = self.circle_ratios(rescale) < min_circle_ratio
        current_mask = self._triangulation.mask
        if current_mask is None:
            current_mask = np.zeros(ntri, dtype=bool)
        valid_neighbors = np.copy(self._triangulation.neighbors)
        renum_neighbors = np.arange(ntri, dtype=np.int32)
        nadd = -1
        while nadd != 0:
            wavefront = (np.min(valid_neighbors, axis=1) == -1) & ~current_mask
            added_mask = wavefront & mask_bad_ratio
            current_mask = added_mask | current_mask
            nadd = np.sum(added_mask)
            valid_neighbors[added_mask, :] = -1
            renum_neighbors[added_mask] = -1
            valid_neighbors = np.where(valid_neighbors == -1, -1, renum_neighbors[valid_neighbors])
        return np.ma.filled(current_mask, True)

    def _get_compressed_triangulation(self):
        tri_mask = self._triangulation.mask
        compressed_triangles = self._triangulation.get_masked_triangles()
        ntri = self._triangulation.triangles.shape[0]
        if tri_mask is not None:
            tri_renum = self._total_to_compress_renum(~tri_mask)
        else:
            tri_renum = np.arange(ntri, dtype=np.int32)
        valid_node = np.bincount(np.ravel(compressed_triangles), minlength=self._triangulation.x.size) != 0
        compressed_x = self._triangulation.x[valid_node]
        compressed_y = self._triangulation.y[valid_node]
        node_renum = self._total_to_compress_renum(valid_node)
        compressed_triangles = node_renum[compressed_triangles]
        return (compressed_triangles, compressed_x, compressed_y, tri_renum, node_renum)

    @staticmethod
    def _total_to_compress_renum(valid):
        renum = np.full(np.size(valid), -1, dtype=np.int32)
        n_valid = np.sum(valid)
        renum[valid] = np.arange(n_valid, dtype=np.int32)
        return renum

# File: matplotlib-main/lib/matplotlib/typing.py
""""""
from collections.abc import Hashable, Sequence
import pathlib
from typing import Any, Literal, TypeAlias, TypeVar
from . import path
from ._enums import JoinStyle, CapStyle
from .markers import MarkerStyle
RGBColorType: TypeAlias = tuple[float, float, float] | str
RGBAColorType: TypeAlias = str | tuple[float, float, float, float] | tuple[RGBColorType, float] | tuple[tuple[float, float, float, float], float]
ColorType: TypeAlias = RGBColorType | RGBAColorType
RGBColourType: TypeAlias = RGBColorType
RGBAColourType: TypeAlias = RGBAColorType
ColourType: TypeAlias = ColorType
LineStyleType: TypeAlias = str | tuple[float, Sequence[float]]
DrawStyleType: TypeAlias = Literal['default', 'steps', 'steps-pre', 'steps-mid', 'steps-post']
MarkEveryType: TypeAlias = None | int | tuple[int, int] | slice | list[int] | float | tuple[float, float] | list[bool]
MarkerType: TypeAlias = str | path.Path | MarkerStyle
FillStyleType: TypeAlias = Literal['full', 'left', 'right', 'bottom', 'top', 'none']
JoinStyleType: TypeAlias = JoinStyle | Literal['miter', 'round', 'bevel']
CapStyleType: TypeAlias = CapStyle | Literal['butt', 'projecting', 'round']
RcStyleType: TypeAlias = str | dict[str, Any] | pathlib.Path | Sequence[str | pathlib.Path | dict[str, Any]]
_HT = TypeVar('_HT', bound=Hashable)
HashableList: TypeAlias = list[_HT | 'HashableList[_HT]']
''

# File: matplotlib-main/lib/matplotlib/units.py
""""""
from decimal import Decimal
from numbers import Number
import numpy as np
from numpy import ma
from matplotlib import cbook

class ConversionError(TypeError):
    pass

def _is_natively_supported(x):
    if np.iterable(x):
        for thisx in x:
            if thisx is ma.masked:
                continue
            return isinstance(thisx, Number) and (not isinstance(thisx, Decimal))
    else:
        return isinstance(x, Number) and (not isinstance(x, Decimal))

class AxisInfo:

    def __init__(self, majloc=None, minloc=None, majfmt=None, minfmt=None, label=None, default_limits=None):
        self.majloc = majloc
        self.minloc = minloc
        self.majfmt = majfmt
        self.minfmt = minfmt
        self.label = label
        self.default_limits = default_limits

class ConversionInterface:

    @staticmethod
    def axisinfo(unit, axis):
        return None

    @staticmethod
    def default_units(x, axis):
        return None

    @staticmethod
    def convert(obj, unit, axis):
        return obj

class DecimalConverter(ConversionInterface):

    @staticmethod
    def convert(value, unit, axis):
        if isinstance(value, Decimal):
            return float(value)
        elif isinstance(value, ma.MaskedArray):
            return ma.asarray(value, dtype=float)
        else:
            return np.asarray(value, dtype=float)

class Registry(dict):

    def get_converter(self, x):
        x = cbook._unpack_to_numpy(x)
        if isinstance(x, np.ndarray):
            x = np.ma.getdata(x).ravel()
            if not x.size:
                return self.get_converter(np.array([0], dtype=x.dtype))
        for cls in type(x).__mro__:
            try:
                return self[cls]
            except KeyError:
                pass
        try:
            first = cbook._safe_first_finite(x)
        except (TypeError, StopIteration):
            pass
        else:
            if type(first) is not type(x):
                return self.get_converter(first)
        return None
registry = Registry()
registry[Decimal] = DecimalConverter()

# File: matplotlib-main/lib/matplotlib/widgets.py
""""""
from contextlib import ExitStack
import copy
import itertools
from numbers import Integral, Number
from cycler import cycler
import numpy as np
import matplotlib as mpl
from . import _api, _docstring, backend_tools, cbook, collections, colors, text as mtext, ticker, transforms
from .lines import Line2D
from .patches import Rectangle, Ellipse, Polygon
from .transforms import TransformedPatchPath, Affine2D

class LockDraw:

    def __init__(self):
        self._owner = None

    def __call__(self, o):
        if not self.available(o):
            raise ValueError('already locked')
        self._owner = o

    def release(self, o):
        if not self.available(o):
            raise ValueError('you do not own this lock')
        self._owner = None

    def available(self, o):
        return not self.locked() or self.isowner(o)

    def isowner(self, o):
        return self._owner is o

    def locked(self):
        return self._owner is not None

class Widget:
    drawon = True
    eventson = True
    _active = True

    def set_active(self, active):
        self._active = active

    def get_active(self):
        return self._active
    active = property(get_active, set_active, doc='Is the widget active?')

    def ignore(self, event):
        return not self.active

class AxesWidget(Widget):

    def __init__(self, ax):
        self.ax = ax
        self._cids = []
    canvas = property(lambda self: self.ax.get_figure(root=True).canvas)

    def connect_event(self, event, callback):
        cid = self.canvas.mpl_connect(event, callback)
        self._cids.append(cid)

    def disconnect_events(self):
        for c in self._cids:
            self.canvas.mpl_disconnect(c)

    def _get_data_coords(self, event):
        return (event.xdata, event.ydata) if event.inaxes is self.ax else self.ax.transData.inverted().transform((event.x, event.y))

class Button(AxesWidget):

    def __init__(self, ax, label, image=None, color='0.85', hovercolor='0.95', *, useblit=True):
        super().__init__(ax)
        if image is not None:
            ax.imshow(image)
        self.label = ax.text(0.5, 0.5, label, verticalalignment='center', horizontalalignment='center', transform=ax.transAxes)
        self._useblit = useblit and self.canvas.supports_blit
        self._observers = cbook.CallbackRegistry(signals=['clicked'])
        self.connect_event('button_press_event', self._click)
        self.connect_event('button_release_event', self._release)
        self.connect_event('motion_notify_event', self._motion)
        ax.set_navigate(False)
        ax.set_facecolor(color)
        ax.set_xticks([])
        ax.set_yticks([])
        self.color = color
        self.hovercolor = hovercolor

    def _click(self, event):
        if not self.eventson or self.ignore(event) or (not self.ax.contains(event)[0]):
            return
        if event.canvas.mouse_grabber != self.ax:
            event.canvas.grab_mouse(self.ax)

    def _release(self, event):
        if self.ignore(event) or event.canvas.mouse_grabber != self.ax:
            return
        event.canvas.release_mouse(self.ax)
        if self.eventson and self.ax.contains(event)[0]:
            self._observers.process('clicked', event)

    def _motion(self, event):
        if self.ignore(event):
            return
        c = self.hovercolor if self.ax.contains(event)[0] else self.color
        if not colors.same_color(c, self.ax.get_facecolor()):
            self.ax.set_facecolor(c)
            if self.drawon:
                if self._useblit:
                    self.ax.draw_artist(self.ax)
                    self.canvas.blit(self.ax.bbox)
                else:
                    self.canvas.draw()

    def on_clicked(self, func):
        return self._observers.connect('clicked', lambda event: func(event))

    def disconnect(self, cid):
        self._observers.disconnect(cid)

class SliderBase(AxesWidget):

    def __init__(self, ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep):
        if ax.name == '3d':
            raise ValueError('Sliders cannot be added to 3D Axes')
        super().__init__(ax)
        _api.check_in_list(['horizontal', 'vertical'], orientation=orientation)
        self.orientation = orientation
        self.closedmin = closedmin
        self.closedmax = closedmax
        self.valmin = valmin
        self.valmax = valmax
        self.valstep = valstep
        self.drag_active = False
        self.valfmt = valfmt
        if orientation == 'vertical':
            ax.set_ylim((valmin, valmax))
            axis = ax.yaxis
        else:
            ax.set_xlim((valmin, valmax))
            axis = ax.xaxis
        self._fmt = axis.get_major_formatter()
        if not isinstance(self._fmt, ticker.ScalarFormatter):
            self._fmt = ticker.ScalarFormatter()
            self._fmt.set_axis(axis)
        self._fmt.set_useOffset(False)
        self._fmt.set_useMathText(True)
        ax.set_axis_off()
        ax.set_navigate(False)
        self.connect_event('button_press_event', self._update)
        self.connect_event('button_release_event', self._update)
        if dragging:
            self.connect_event('motion_notify_event', self._update)
        self._observers = cbook.CallbackRegistry(signals=['changed'])

    def _stepped_value(self, val):
        if isinstance(self.valstep, Number):
            val = self.valmin + round((val - self.valmin) / self.valstep) * self.valstep
        elif self.valstep is not None:
            valstep = np.asanyarray(self.valstep)
            if valstep.ndim != 1:
                raise ValueError(f'valstep must have 1 dimension but has {valstep.ndim}')
            val = valstep[np.argmin(np.abs(valstep - val))]
        return val

    def disconnect(self, cid):
        self._observers.disconnect(cid)

    def reset(self):
        if np.any(self.val != self.valinit):
            self.set_val(self.valinit)

class Slider(SliderBase):

    def __init__(self, ax, label, valmin, valmax, *, valinit=0.5, valfmt=None, closedmin=True, closedmax=True, slidermin=None, slidermax=None, dragging=True, valstep=None, orientation='horizontal', initcolor='r', track_color='lightgrey', handle_style=None, **kwargs):
        super().__init__(ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep)
        if slidermin is not None and (not hasattr(slidermin, 'val')):
            raise ValueError(f"Argument slidermin ({type(slidermin)}) has no 'val'")
        if slidermax is not None and (not hasattr(slidermax, 'val')):
            raise ValueError(f"Argument slidermax ({type(slidermax)}) has no 'val'")
        self.slidermin = slidermin
        self.slidermax = slidermax
        valinit = self._value_in_bounds(valinit)
        if valinit is None:
            valinit = valmin
        self.val = valinit
        self.valinit = valinit
        defaults = {'facecolor': 'white', 'edgecolor': '.75', 'size': 10}
        handle_style = {} if handle_style is None else handle_style
        marker_props = {f'marker{k}': v for (k, v) in {**defaults, **handle_style}.items()}
        if orientation == 'vertical':
            self.track = Rectangle((0.25, 0), 0.5, 1, transform=ax.transAxes, facecolor=track_color)
            ax.add_patch(self.track)
            self.poly = ax.axhspan(valmin, valinit, 0.25, 0.75, **kwargs)
            self.hline = ax.axhline(valinit, 0, 1, color=initcolor, lw=1, clip_path=TransformedPatchPath(self.track))
            handleXY = [[0.5], [valinit]]
        else:
            self.track = Rectangle((0, 0.25), 1, 0.5, transform=ax.transAxes, facecolor=track_color)
            ax.add_patch(self.track)
            self.poly = ax.axvspan(valmin, valinit, 0.25, 0.75, **kwargs)
            self.vline = ax.axvline(valinit, 0, 1, color=initcolor, lw=1, clip_path=TransformedPatchPath(self.track))
            handleXY = [[valinit], [0.5]]
        (self._handle,) = ax.plot(*handleXY, 'o', **marker_props, clip_on=False)
        if orientation == 'vertical':
            self.label = ax.text(0.5, 1.02, label, transform=ax.transAxes, verticalalignment='bottom', horizontalalignment='center')
            self.valtext = ax.text(0.5, -0.02, self._format(valinit), transform=ax.transAxes, verticalalignment='top', horizontalalignment='center')
        else:
            self.label = ax.text(-0.02, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right')
            self.valtext = ax.text(1.02, 0.5, self._format(valinit), transform=ax.transAxes, verticalalignment='center', horizontalalignment='left')
        self.set_val(valinit)

    def _value_in_bounds(self, val):
        val = self._stepped_value(val)
        if val <= self.valmin:
            if not self.closedmin:
                return
            val = self.valmin
        elif val >= self.valmax:
            if not self.closedmax:
                return
            val = self.valmax
        if self.slidermin is not None and val <= self.slidermin.val:
            if not self.closedmin:
                return
            val = self.slidermin.val
        if self.slidermax is not None and val >= self.slidermax.val:
            if not self.closedmax:
                return
            val = self.slidermax.val
        return val

    def _update(self, event):
        if self.ignore(event) or event.button != 1:
            return
        if event.name == 'button_press_event' and self.ax.contains(event)[0]:
            self.drag_active = True
            event.canvas.grab_mouse(self.ax)
        if not self.drag_active:
            return
        if event.name == 'button_release_event' or (event.name == 'button_press_event' and (not self.ax.contains(event)[0])):
            self.drag_active = False
            event.canvas.release_mouse(self.ax)
            return
        (xdata, ydata) = self._get_data_coords(event)
        val = self._value_in_bounds(xdata if self.orientation == 'horizontal' else ydata)
        if val not in [None, self.val]:
            self.set_val(val)

    def _format(self, val):
        if self.valfmt is not None:
            return self.valfmt % val
        else:
            (_, s, _) = self._fmt.format_ticks([self.valmin, val, self.valmax])
            return s + self._fmt.get_offset()

    def set_val(self, val):
        if self.orientation == 'vertical':
            self.poly.set_height(val - self.poly.get_y())
            self._handle.set_ydata([val])
        else:
            self.poly.set_width(val - self.poly.get_x())
            self._handle.set_xdata([val])
        self.valtext.set_text(self._format(val))
        if self.drawon:
            self.ax.get_figure(root=True).canvas.draw_idle()
        self.val = val
        if self.eventson:
            self._observers.process('changed', val)

    def on_changed(self, func):
        return self._observers.connect('changed', lambda val: func(val))

class RangeSlider(SliderBase):

    def __init__(self, ax, label, valmin, valmax, *, valinit=None, valfmt=None, closedmin=True, closedmax=True, dragging=True, valstep=None, orientation='horizontal', track_color='lightgrey', handle_style=None, **kwargs):
        super().__init__(ax, orientation, closedmin, closedmax, valmin, valmax, valfmt, dragging, valstep)
        self.val = (valmin, valmax)
        if valinit is None:
            extent = valmax - valmin
            valinit = np.array([valmin + extent * 0.25, valmin + extent * 0.75])
        else:
            valinit = self._value_in_bounds(valinit)
        self.val = valinit
        self.valinit = valinit
        defaults = {'facecolor': 'white', 'edgecolor': '.75', 'size': 10}
        handle_style = {} if handle_style is None else handle_style
        marker_props = {f'marker{k}': v for (k, v) in {**defaults, **handle_style}.items()}
        if orientation == 'vertical':
            self.track = Rectangle((0.25, 0), 0.5, 2, transform=ax.transAxes, facecolor=track_color)
            ax.add_patch(self.track)
            poly_transform = self.ax.get_yaxis_transform(which='grid')
            handleXY_1 = [0.5, valinit[0]]
            handleXY_2 = [0.5, valinit[1]]
        else:
            self.track = Rectangle((0, 0.25), 1, 0.5, transform=ax.transAxes, facecolor=track_color)
            ax.add_patch(self.track)
            poly_transform = self.ax.get_xaxis_transform(which='grid')
            handleXY_1 = [valinit[0], 0.5]
            handleXY_2 = [valinit[1], 0.5]
        self.poly = Polygon(np.zeros([5, 2]), **kwargs)
        self._update_selection_poly(*valinit)
        self.poly.set_transform(poly_transform)
        self.poly.get_path()._interpolation_steps = 100
        self.ax.add_patch(self.poly)
        self.ax._request_autoscale_view()
        self._handles = [ax.plot(*handleXY_1, 'o', **marker_props, clip_on=False)[0], ax.plot(*handleXY_2, 'o', **marker_props, clip_on=False)[0]]
        if orientation == 'vertical':
            self.label = ax.text(0.5, 1.02, label, transform=ax.transAxes, verticalalignment='bottom', horizontalalignment='center')
            self.valtext = ax.text(0.5, -0.02, self._format(valinit), transform=ax.transAxes, verticalalignment='top', horizontalalignment='center')
        else:
            self.label = ax.text(-0.02, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right')
            self.valtext = ax.text(1.02, 0.5, self._format(valinit), transform=ax.transAxes, verticalalignment='center', horizontalalignment='left')
        self._active_handle = None
        self.set_val(valinit)

    def _update_selection_poly(self, vmin, vmax):
        verts = self.poly.xy
        if self.orientation == 'vertical':
            verts[0] = verts[4] = (0.25, vmin)
            verts[1] = (0.25, vmax)
            verts[2] = (0.75, vmax)
            verts[3] = (0.75, vmin)
        else:
            verts[0] = verts[4] = (vmin, 0.25)
            verts[1] = (vmin, 0.75)
            verts[2] = (vmax, 0.75)
            verts[3] = (vmax, 0.25)

    def _min_in_bounds(self, min):
        if min <= self.valmin:
            if not self.closedmin:
                return self.val[0]
            min = self.valmin
        if min > self.val[1]:
            min = self.val[1]
        return self._stepped_value(min)

    def _max_in_bounds(self, max):
        if max >= self.valmax:
            if not self.closedmax:
                return self.val[1]
            max = self.valmax
        if max <= self.val[0]:
            max = self.val[0]
        return self._stepped_value(max)

    def _value_in_bounds(self, vals):
        return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1]))

    def _update_val_from_pos(self, pos):
        idx = np.argmin(np.abs(self.val - pos))
        if idx == 0:
            val = self._min_in_bounds(pos)
            self.set_min(val)
        else:
            val = self._max_in_bounds(pos)
            self.set_max(val)
        if self._active_handle:
            if self.orientation == 'vertical':
                self._active_handle.set_ydata([val])
            else:
                self._active_handle.set_xdata([val])

    def _update(self, event):
        if self.ignore(event) or event.button != 1:
            return
        if event.name == 'button_press_event' and self.ax.contains(event)[0]:
            self.drag_active = True
            event.canvas.grab_mouse(self.ax)
        if not self.drag_active:
            return
        if event.name == 'button_release_event' or (event.name == 'button_press_event' and (not self.ax.contains(event)[0])):
            self.drag_active = False
            event.canvas.release_mouse(self.ax)
            self._active_handle = None
            return
        (xdata, ydata) = self._get_data_coords(event)
        handle_index = np.argmin(np.abs([h.get_xdata()[0] - xdata for h in self._handles] if self.orientation == 'horizontal' else [h.get_ydata()[0] - ydata for h in self._handles]))
        handle = self._handles[handle_index]
        if handle is not self._active_handle:
            self._active_handle = handle
        self._update_val_from_pos(xdata if self.orientation == 'horizontal' else ydata)

    def _format(self, val):
        if self.valfmt is not None:
            return f'({self.valfmt % val[0]}, {self.valfmt % val[1]})'
        else:
            (_, s1, s2, _) = self._fmt.format_ticks([self.valmin, *val, self.valmax])
            s1 += self._fmt.get_offset()
            s2 += self._fmt.get_offset()
            return f'({s1}, {s2})'

    def set_min(self, min):
        self.set_val((min, self.val[1]))

    def set_max(self, max):
        self.set_val((self.val[0], max))

    def set_val(self, val):
        val = np.sort(val)
        _api.check_shape((2,), val=val)
        self.val = (self.valmin, self.valmax)
        (vmin, vmax) = self._value_in_bounds(val)
        self._update_selection_poly(vmin, vmax)
        if self.orientation == 'vertical':
            self._handles[0].set_ydata([vmin])
            self._handles[1].set_ydata([vmax])
        else:
            self._handles[0].set_xdata([vmin])
            self._handles[1].set_xdata([vmax])
        self.valtext.set_text(self._format((vmin, vmax)))
        if self.drawon:
            self.ax.get_figure(root=True).canvas.draw_idle()
        self.val = (vmin, vmax)
        if self.eventson:
            self._observers.process('changed', (vmin, vmax))

    def on_changed(self, func):
        return self._observers.connect('changed', lambda val: func(val))

def _expand_text_props(props):
    props = cbook.normalize_kwargs(props, mtext.Text)
    return cycler(**props)() if props else itertools.repeat({})

class CheckButtons(AxesWidget):

    def __init__(self, ax, labels, actives=None, *, useblit=True, label_props=None, frame_props=None, check_props=None):
        super().__init__(ax)
        _api.check_isinstance((dict, None), label_props=label_props, frame_props=frame_props, check_props=check_props)
        ax.set_xticks([])
        ax.set_yticks([])
        ax.set_navigate(False)
        if actives is None:
            actives = [False] * len(labels)
        self._useblit = useblit and self.canvas.supports_blit
        self._background = None
        ys = np.linspace(1, 0, len(labels) + 2)[1:-1]
        label_props = _expand_text_props(label_props)
        self.labels = [ax.text(0.25, y, label, transform=ax.transAxes, horizontalalignment='left', verticalalignment='center', **props) for (y, label, props) in zip(ys, labels, label_props)]
        text_size = np.array([text.get_fontsize() for text in self.labels]) / 2
        frame_props = {'s': text_size ** 2, 'linewidth': 1, **cbook.normalize_kwargs(frame_props, collections.PathCollection), 'marker': 's', 'transform': ax.transAxes}
        frame_props.setdefault('facecolor', frame_props.get('color', 'none'))
        frame_props.setdefault('edgecolor', frame_props.pop('color', 'black'))
        self._frames = ax.scatter([0.15] * len(ys), ys, **frame_props)
        check_props = {'linewidth': 1, 's': text_size ** 2, **cbook.normalize_kwargs(check_props, collections.PathCollection), 'marker': 'x', 'transform': ax.transAxes, 'animated': self._useblit}
        check_props.setdefault('facecolor', check_props.pop('color', 'black'))
        self._checks = ax.scatter([0.15] * len(ys), ys, **check_props)
        self._init_status(actives)
        self.connect_event('button_press_event', self._clicked)
        if self._useblit:
            self.connect_event('draw_event', self._clear)
        self._observers = cbook.CallbackRegistry(signals=['clicked'])

    def _clear(self, event):
        if self.ignore(event) or self.canvas.is_saving():
            return
        self._background = self.canvas.copy_from_bbox(self.ax.bbox)
        self.ax.draw_artist(self._checks)

    def _clicked(self, event):
        if self.ignore(event) or event.button != 1 or (not self.ax.contains(event)[0]):
            return
        idxs = [*self._frames.contains(event)[1]['ind'], *[i for (i, text) in enumerate(self.labels) if text.contains(event)[0]]]
        if idxs:
            coords = self._frames.get_offset_transform().transform(self._frames.get_offsets())
            self.set_active(idxs[(((event.x, event.y) - coords[idxs]) ** 2).sum(-1).argmin()])

    def set_label_props(self, props):
        _api.check_isinstance(dict, props=props)
        props = _expand_text_props(props)
        for (text, prop) in zip(self.labels, props):
            text.update(prop)

    def set_frame_props(self, props):
        _api.check_isinstance(dict, props=props)
        if 's' in props:
            props['sizes'] = np.broadcast_to(props.pop('s'), len(self.labels))
        self._frames.update(props)

    def set_check_props(self, props):
        _api.check_isinstance(dict, props=props)
        if 's' in props:
            props['sizes'] = np.broadcast_to(props.pop('s'), len(self.labels))
        actives = self.get_status()
        self._checks.update(props)
        self._init_status(actives)

    def set_active(self, index, state=None):
        if index not in range(len(self.labels)):
            raise ValueError(f'Invalid CheckButton index: {index}')
        _api.check_isinstance((bool, None), state=state)
        invisible = colors.to_rgba('none')
        facecolors = self._checks.get_facecolor()
        if state is None:
            state = colors.same_color(facecolors[index], invisible)
        facecolors[index] = self._active_check_colors[index] if state else invisible
        self._checks.set_facecolor(facecolors)
        if self.drawon:
            if self._useblit:
                if self._background is not None:
                    self.canvas.restore_region(self._background)
                self.ax.draw_artist(self._checks)
                self.canvas.blit(self.ax.bbox)
            else:
                self.canvas.draw()
        if self.eventson:
            self._observers.process('clicked', self.labels[index].get_text())

    def _init_status(self, actives):
        self._active_check_colors = self._checks.get_facecolor()
        if len(self._active_check_colors) == 1:
            self._active_check_colors = np.repeat(self._active_check_colors, len(actives), axis=0)
        self._checks.set_facecolor([ec if active else 'none' for (ec, active) in zip(self._active_check_colors, actives)])

    def clear(self):
        self._checks.set_facecolor(['none'] * len(self._active_check_colors))
        if hasattr(self, '_lines'):
            for (l1, l2) in self._lines:
                l1.set_visible(False)
                l2.set_visible(False)
        if self.drawon:
            self.canvas.draw()
        if self.eventson:
            self._observers.process('clicked', None)

    def get_status(self):
        return [not colors.same_color(color, colors.to_rgba('none')) for color in self._checks.get_facecolors()]

    def get_checked_labels(self):
        return [l.get_text() for (l, box_checked) in zip(self.labels, self.get_status()) if box_checked]

    def on_clicked(self, func):
        return self._observers.connect('clicked', lambda text: func(text))

    def disconnect(self, cid):
        self._observers.disconnect(cid)

class TextBox(AxesWidget):

    def __init__(self, ax, label, initial='', *, color='.95', hovercolor='1', label_pad=0.01, textalignment='left'):
        super().__init__(ax)
        self._text_position = _api.check_getitem({'left': 0.05, 'center': 0.5, 'right': 0.95}, textalignment=textalignment)
        self.label = ax.text(-label_pad, 0.5, label, transform=ax.transAxes, verticalalignment='center', horizontalalignment='right')
        self.text_disp = self.ax.text(self._text_position, 0.5, initial, transform=self.ax.transAxes, verticalalignment='center', horizontalalignment=textalignment, parse_math=False)
        self._observers = cbook.CallbackRegistry(signals=['change', 'submit'])
        ax.set(xlim=(0, 1), ylim=(0, 1), navigate=False, facecolor=color, xticks=[], yticks=[])
        self.cursor_index = 0
        self.cursor = ax.vlines(0, 0, 0, visible=False, color='k', lw=1, transform=mpl.transforms.IdentityTransform())
        self.connect_event('button_press_event', self._click)
        self.connect_event('button_release_event', self._release)
        self.connect_event('motion_notify_event', self._motion)
        self.connect_event('key_press_event', self._keypress)
        self.connect_event('resize_event', self._resize)
        self.color = color
        self.hovercolor = hovercolor
        self.capturekeystrokes = False

    @property
    def text(self):
        return self.text_disp.get_text()

    def _rendercursor(self):
        fig = self.ax.get_figure(root=True)
        if fig._get_renderer() is None:
            fig.canvas.draw()
        text = self.text_disp.get_text()
        widthtext = text[:self.cursor_index]
        bb_text = self.text_disp.get_window_extent()
        self.text_disp.set_text(widthtext or ',')
        bb_widthtext = self.text_disp.get_window_extent()
        if bb_text.y0 == bb_text.y1:
            bb_text.y0 -= bb_widthtext.height / 2
            bb_text.y1 += bb_widthtext.height / 2
        elif not widthtext:
            bb_text.x1 = bb_text.x0
        else:
            bb_text.x1 = bb_text.x0 + bb_widthtext.width
        self.cursor.set(segments=[[(bb_text.x1, bb_text.y0), (bb_text.x1, bb_text.y1)]], visible=True)
        self.text_disp.set_text(text)
        fig.canvas.draw()

    def _release(self, event):
        if self.ignore(event):
            return
        if event.canvas.mouse_grabber != self.ax:
            return
        event.canvas.release_mouse(self.ax)

    def _keypress(self, event):
        if self.ignore(event):
            return
        if self.capturekeystrokes:
            key = event.key
            text = self.text
            if len(key) == 1:
                text = text[:self.cursor_index] + key + text[self.cursor_index:]
                self.cursor_index += 1
            elif key == 'right':
                if self.cursor_index != len(text):
                    self.cursor_index += 1
            elif key == 'left':
                if self.cursor_index != 0:
                    self.cursor_index -= 1
            elif key == 'home':
                self.cursor_index = 0
            elif key == 'end':
                self.cursor_index = len(text)
            elif key == 'backspace':
                if self.cursor_index != 0:
                    text = text[:self.cursor_index - 1] + text[self.cursor_index:]
                    self.cursor_index -= 1
            elif key == 'delete':
                if self.cursor_index != len(self.text):
                    text = text[:self.cursor_index] + text[self.cursor_index + 1:]
            self.text_disp.set_text(text)
            self._rendercursor()
            if self.eventson:
                self._observers.process('change', self.text)
                if key in ['enter', 'return']:
                    self._observers.process('submit', self.text)

    def set_val(self, val):
        newval = str(val)
        if self.text == newval:
            return
        self.text_disp.set_text(newval)
        self._rendercursor()
        if self.eventson:
            self._observers.process('change', self.text)
            self._observers.process('submit', self.text)

    def begin_typing(self):
        self.capturekeystrokes = True
        stack = ExitStack()
        self._on_stop_typing = stack.close
        toolmanager = getattr(self.ax.get_figure(root=True).canvas.manager, 'toolmanager', None)
        if toolmanager is not None:
            toolmanager.keypresslock(self)
            stack.callback(toolmanager.keypresslock.release, self)
        else:
            with _api.suppress_matplotlib_deprecation_warning():
                stack.enter_context(mpl.rc_context({k: [] for k in mpl.rcParams if k.startswith('keymap.')}))

    def stop_typing(self):
        if self.capturekeystrokes:
            self._on_stop_typing()
            self._on_stop_typing = None
            notifysubmit = True
        else:
            notifysubmit = False
        self.capturekeystrokes = False
        self.cursor.set_visible(False)
        self.ax.get_figure(root=True).canvas.draw()
        if notifysubmit and self.eventson:
            self._observers.process('submit', self.text)

    def _click(self, event):
        if self.ignore(event):
            return
        if not self.ax.contains(event)[0]:
            self.stop_typing()
            return
        if not self.eventson:
            return
        if event.canvas.mouse_grabber != self.ax:
            event.canvas.grab_mouse(self.ax)
        if not self.capturekeystrokes:
            self.begin_typing()
        self.cursor_index = self.text_disp._char_index_at(event.x)
        self._rendercursor()

    def _resize(self, event):
        self.stop_typing()

    def _motion(self, event):
        if self.ignore(event):
            return
        c = self.hovercolor if self.ax.contains(event)[0] else self.color
        if not colors.same_color(c, self.ax.get_facecolor()):
            self.ax.set_facecolor(c)
            if self.drawon:
                self.ax.get_figure(root=True).canvas.draw()

    def on_text_change(self, func):
        return self._observers.connect('change', lambda text: func(text))

    def on_submit(self, func):
        return self._observers.connect('submit', lambda text: func(text))

    def disconnect(self, cid):
        self._observers.disconnect(cid)

class RadioButtons(AxesWidget):

    def __init__(self, ax, labels, active=0, activecolor=None, *, useblit=True, label_props=None, radio_props=None):
        super().__init__(ax)
        _api.check_isinstance((dict, None), label_props=label_props, radio_props=radio_props)
        radio_props = cbook.normalize_kwargs(radio_props, collections.PathCollection)
        if activecolor is not None:
            if 'facecolor' in radio_props:
                _api.warn_external('Both the *activecolor* parameter and the *facecolor* key in the *radio_props* parameter has been specified. *activecolor* will be ignored.')
        else:
            activecolor = 'blue'
        self._activecolor = activecolor
        self._initial_active = active
        self.value_selected = labels[active]
        self.index_selected = active
        ax.set_xticks([])
        ax.set_yticks([])
        ax.set_navigate(False)
        ys = np.linspace(1, 0, len(labels) + 2)[1:-1]
        self._useblit = useblit and self.canvas.supports_blit
        self._background = None
        label_props = _expand_text_props(label_props)
        self.labels = [ax.text(0.25, y, label, transform=ax.transAxes, horizontalalignment='left', verticalalignment='center', **props) for (y, label, props) in zip(ys, labels, label_props)]
        text_size = np.array([text.get_fontsize() for text in self.labels]) / 2
        radio_props = {'s': text_size ** 2, **radio_props, 'marker': 'o', 'transform': ax.transAxes, 'animated': self._useblit}
        radio_props.setdefault('edgecolor', radio_props.get('color', 'black'))
        radio_props.setdefault('facecolor', radio_props.pop('color', activecolor))
        self._buttons = ax.scatter([0.15] * len(ys), ys, **radio_props)
        self._active_colors = self._buttons.get_facecolor()
        if len(self._active_colors) == 1:
            self._active_colors = np.repeat(self._active_colors, len(labels), axis=0)
        self._buttons.set_facecolor([activecolor if i == active else 'none' for (i, activecolor) in enumerate(self._active_colors)])
        self.connect_event('button_press_event', self._clicked)
        if self._useblit:
            self.connect_event('draw_event', self._clear)
        self._observers = cbook.CallbackRegistry(signals=['clicked'])

    def _clear(self, event):
        if self.ignore(event) or self.canvas.is_saving():
            return
        self._background = self.canvas.copy_from_bbox(self.ax.bbox)
        self.ax.draw_artist(self._buttons)

    def _clicked(self, event):
        if self.ignore(event) or event.button != 1 or (not self.ax.contains(event)[0]):
            return
        idxs = [*self._buttons.contains(event)[1]['ind'], *[i for (i, text) in enumerate(self.labels) if text.contains(event)[0]]]
        if idxs:
            coords = self._buttons.get_offset_transform().transform(self._buttons.get_offsets())
            self.set_active(idxs[(((event.x, event.y) - coords[idxs]) ** 2).sum(-1).argmin()])

    def set_label_props(self, props):
        _api.check_isinstance(dict, props=props)
        props = _expand_text_props(props)
        for (text, prop) in zip(self.labels, props):
            text.update(prop)

    def set_radio_props(self, props):
        _api.check_isinstance(dict, props=props)
        if 's' in props:
            props['sizes'] = np.broadcast_to(props.pop('s'), len(self.labels))
        self._buttons.update(props)
        self._active_colors = self._buttons.get_facecolor()
        if len(self._active_colors) == 1:
            self._active_colors = np.repeat(self._active_colors, len(self.labels), axis=0)
        self._buttons.set_facecolor([activecolor if text.get_text() == self.value_selected else 'none' for (text, activecolor) in zip(self.labels, self._active_colors)])

    @property
    def activecolor(self):
        return self._activecolor

    @activecolor.setter
    def activecolor(self, activecolor):
        colors._check_color_like(activecolor=activecolor)
        self._activecolor = activecolor
        self.set_radio_props({'facecolor': activecolor})

    def set_active(self, index):
        if index not in range(len(self.labels)):
            raise ValueError(f'Invalid RadioButton index: {index}')
        self.value_selected = self.labels[index].get_text()
        self.index_selected = index
        button_facecolors = self._buttons.get_facecolor()
        button_facecolors[:] = colors.to_rgba('none')
        button_facecolors[index] = colors.to_rgba(self._active_colors[index])
        self._buttons.set_facecolor(button_facecolors)
        if self.drawon:
            if self._useblit:
                if self._background is not None:
                    self.canvas.restore_region(self._background)
                self.ax.draw_artist(self._buttons)
                self.canvas.blit(self.ax.bbox)
            else:
                self.canvas.draw()
        if self.eventson:
            self._observers.process('clicked', self.labels[index].get_text())

    def clear(self):
        self.set_active(self._initial_active)

    def on_clicked(self, func):
        return self._observers.connect('clicked', func)

    def disconnect(self, cid):
        self._observers.disconnect(cid)

class SubplotTool(Widget):

    def __init__(self, targetfig, toolfig):
        self.figure = toolfig
        self.targetfig = targetfig
        toolfig.subplots_adjust(left=0.2, right=0.9)
        toolfig.suptitle('Click on slider to adjust subplot param')
        self._sliders = []
        names = ['left', 'bottom', 'right', 'top', 'wspace', 'hspace']
        for (name, ax) in zip(names, toolfig.subplots(len(names) + 1)):
            ax.set_navigate(False)
            slider = Slider(ax, name, 0, 1, valinit=getattr(targetfig.subplotpars, name))
            slider.on_changed(self._on_slider_changed)
            self._sliders.append(slider)
        toolfig.axes[-1].remove()
        (self.sliderleft, self.sliderbottom, self.sliderright, self.slidertop, self.sliderwspace, self.sliderhspace) = self._sliders
        for slider in [self.sliderleft, self.sliderbottom, self.sliderwspace, self.sliderhspace]:
            slider.closedmax = False
        for slider in [self.sliderright, self.slidertop]:
            slider.closedmin = False
        self.sliderleft.slidermax = self.sliderright
        self.sliderright.slidermin = self.sliderleft
        self.sliderbottom.slidermax = self.slidertop
        self.slidertop.slidermin = self.sliderbottom
        bax = toolfig.add_axes([0.8, 0.05, 0.15, 0.075])
        self.buttonreset = Button(bax, 'Reset')
        self.buttonreset.on_clicked(self._on_reset)

    def _on_slider_changed(self, _):
        self.targetfig.subplots_adjust(**{slider.label.get_text(): slider.val for slider in self._sliders})
        if self.drawon:
            self.targetfig.canvas.draw()

    def _on_reset(self, event):
        with ExitStack() as stack:
            stack.enter_context(cbook._setattr_cm(self, drawon=False))
            for slider in self._sliders:
                stack.enter_context(cbook._setattr_cm(slider, drawon=False, eventson=False))
            for slider in self._sliders:
                slider.reset()
        if self.drawon:
            event.canvas.draw()
        self._on_slider_changed(None)

class Cursor(AxesWidget):

    def __init__(self, ax, *, horizOn=True, vertOn=True, useblit=False, **lineprops):
        super().__init__(ax)
        self.connect_event('motion_notify_event', self.onmove)
        self.connect_event('draw_event', self.clear)
        self.visible = True
        self.horizOn = horizOn
        self.vertOn = vertOn
        self.useblit = useblit and self.canvas.supports_blit
        if self.useblit:
            lineprops['animated'] = True
        self.lineh = ax.axhline(ax.get_ybound()[0], visible=False, **lineprops)
        self.linev = ax.axvline(ax.get_xbound()[0], visible=False, **lineprops)
        self.background = None
        self.needclear = False

    def clear(self, event):
        if self.ignore(event) or self.canvas.is_saving():
            return
        if self.useblit:
            self.background = self.canvas.copy_from_bbox(self.ax.bbox)

    def onmove(self, event):
        if self.ignore(event):
            return
        if not self.canvas.widgetlock.available(self):
            return
        if not self.ax.contains(event)[0]:
            self.linev.set_visible(False)
            self.lineh.set_visible(False)
            if self.needclear:
                self.canvas.draw()
                self.needclear = False
            return
        self.needclear = True
        (xdata, ydata) = self._get_data_coords(event)
        self.linev.set_xdata((xdata, xdata))
        self.linev.set_visible(self.visible and self.vertOn)
        self.lineh.set_ydata((ydata, ydata))
        self.lineh.set_visible(self.visible and self.horizOn)
        if not (self.visible and (self.vertOn or self.horizOn)):
            return
        if self.useblit:
            if self.background is not None:
                self.canvas.restore_region(self.background)
            self.ax.draw_artist(self.linev)
            self.ax.draw_artist(self.lineh)
            self.canvas.blit(self.ax.bbox)
        else:
            self.canvas.draw_idle()

class MultiCursor(Widget):

    def __init__(self, canvas, axes, *, useblit=True, horizOn=False, vertOn=True, **lineprops):
        self._canvas = canvas
        self.axes = axes
        self.horizOn = horizOn
        self.vertOn = vertOn
        self._canvas_infos = {ax.get_figure(root=True).canvas: {'cids': [], 'background': None} for ax in axes}
        (xmin, xmax) = axes[-1].get_xlim()
        (ymin, ymax) = axes[-1].get_ylim()
        xmid = 0.5 * (xmin + xmax)
        ymid = 0.5 * (ymin + ymax)
        self.visible = True
        self.useblit = useblit and all((canvas.supports_blit for canvas in self._canvas_infos))
        if self.useblit:
            lineprops['animated'] = True
        self.vlines = [ax.axvline(xmid, visible=False, **lineprops) for ax in axes]
        self.hlines = [ax.axhline(ymid, visible=False, **lineprops) for ax in axes]
        self.connect()

    def connect(self):
        for (canvas, info) in self._canvas_infos.items():
            info['cids'] = [canvas.mpl_connect('motion_notify_event', self.onmove), canvas.mpl_connect('draw_event', self.clear)]

    def disconnect(self):
        for (canvas, info) in self._canvas_infos.items():
            for cid in info['cids']:
                canvas.mpl_disconnect(cid)
            info['cids'].clear()

    def clear(self, event):
        if self.ignore(event):
            return
        if self.useblit:
            for (canvas, info) in self._canvas_infos.items():
                if canvas is not canvas.figure.canvas:
                    continue
                info['background'] = canvas.copy_from_bbox(canvas.figure.bbox)

    def onmove(self, event):
        axs = [ax for ax in self.axes if ax.contains(event)[0]]
        if self.ignore(event) or not axs or (not event.canvas.widgetlock.available(self)):
            return
        ax = cbook._topmost_artist(axs)
        (xdata, ydata) = (event.xdata, event.ydata) if event.inaxes is ax else ax.transData.inverted().transform((event.x, event.y))
        for line in self.vlines:
            line.set_xdata((xdata, xdata))
            line.set_visible(self.visible and self.vertOn)
        for line in self.hlines:
            line.set_ydata((ydata, ydata))
            line.set_visible(self.visible and self.horizOn)
        if not (self.visible and (self.vertOn or self.horizOn)):
            return
        if self.useblit:
            for (canvas, info) in self._canvas_infos.items():
                if info['background']:
                    canvas.restore_region(info['background'])
            if self.vertOn:
                for (ax, line) in zip(self.axes, self.vlines):
                    ax.draw_artist(line)
            if self.horizOn:
                for (ax, line) in zip(self.axes, self.hlines):
                    ax.draw_artist(line)
            for canvas in self._canvas_infos:
                canvas.blit()
        else:
            for canvas in self._canvas_infos:
                canvas.draw_idle()

class _SelectorWidget(AxesWidget):

    def __init__(self, ax, onselect, useblit=False, button=None, state_modifier_keys=None, use_data_coordinates=False):
        super().__init__(ax)
        self._visible = True
        self.onselect = onselect
        self.useblit = useblit and self.canvas.supports_blit
        self.connect_default_events()
        self._state_modifier_keys = dict(move=' ', clear='escape', square='shift', center='control', rotate='r')
        self._state_modifier_keys.update(state_modifier_keys or {})
        self._use_data_coordinates = use_data_coordinates
        self.background = None
        if isinstance(button, Integral):
            self.validButtons = [button]
        else:
            self.validButtons = button
        self._selection_completed = False
        self._eventpress = None
        self._eventrelease = None
        self._prev_event = None
        self._state = set()

    def set_active(self, active):
        super().set_active(active)
        if active:
            self.update_background(None)

    def _get_animated_artists(self):
        return tuple((a for ax_ in self.ax.get_figure().get_axes() for a in ax_.get_children() if a.get_animated() and a not in self.artists))

    def update_background(self, event):
        if not self.useblit:
            return
        artists = sorted(self.artists + self._get_animated_artists(), key=lambda a: a.get_zorder())
        needs_redraw = any((artist.get_visible() for artist in artists))
        with ExitStack() as stack:
            if needs_redraw:
                for artist in artists:
                    stack.enter_context(artist._cm_set(visible=False))
                self.canvas.draw()
            self.background = self.canvas.copy_from_bbox(self.ax.bbox)
        if needs_redraw:
            for artist in artists:
                self.ax.draw_artist(artist)

    def connect_default_events(self):
        self.connect_event('motion_notify_event', self.onmove)
        self.connect_event('button_press_event', self.press)
        self.connect_event('button_release_event', self.release)
        self.connect_event('draw_event', self.update_background)
        self.connect_event('key_press_event', self.on_key_press)
        self.connect_event('key_release_event', self.on_key_release)
        self.connect_event('scroll_event', self.on_scroll)

    def ignore(self, event):
        if not self.active or not self.ax.get_visible():
            return True
        if not self.canvas.widgetlock.available(self):
            return True
        if not hasattr(event, 'button'):
            event.button = None
        if self.validButtons is not None and event.button not in self.validButtons:
            return True
        if self._eventpress is None:
            return not self.ax.contains(event)[0]
        if event.button == self._eventpress.button:
            return False
        return not self.ax.contains(event)[0] or event.button != self._eventpress.button

    def update(self):
        if not self.ax.get_visible() or self.ax.get_figure(root=True)._get_renderer() is None:
            return
        if self.useblit:
            if self.background is not None:
                self.canvas.restore_region(self.background)
            else:
                self.update_background(None)
            artists = sorted(self.artists + self._get_animated_artists(), key=lambda a: a.get_zorder())
            for artist in artists:
                self.ax.draw_artist(artist)
            self.canvas.blit(self.ax.bbox)
        else:
            self.canvas.draw_idle()

    def _get_data(self, event):
        if event.xdata is None:
            return (None, None)
        (xdata, ydata) = self._get_data_coords(event)
        xdata = np.clip(xdata, *self.ax.get_xbound())
        ydata = np.clip(ydata, *self.ax.get_ybound())
        return (xdata, ydata)

    def _clean_event(self, event):
        if event.xdata is None:
            event = self._prev_event
        else:
            event = copy.copy(event)
        (event.xdata, event.ydata) = self._get_data(event)
        self._prev_event = event
        return event

    def press(self, event):
        if not self.ignore(event):
            event = self._clean_event(event)
            self._eventpress = event
            self._prev_event = event
            key = event.key or ''
            key = key.replace('ctrl', 'control')
            if key == self._state_modifier_keys['move']:
                self._state.add('move')
            self._press(event)
            return True
        return False

    def _press(self, event):

    def release(self, event):
        if not self.ignore(event) and self._eventpress:
            event = self._clean_event(event)
            self._eventrelease = event
            self._release(event)
            self._eventpress = None
            self._eventrelease = None
            self._state.discard('move')
            return True
        return False

    def _release(self, event):

    def onmove(self, event):
        if not self.ignore(event) and self._eventpress:
            event = self._clean_event(event)
            self._onmove(event)
            return True
        return False

    def _onmove(self, event):

    def on_scroll(self, event):
        if not self.ignore(event):
            self._on_scroll(event)

    def _on_scroll(self, event):

    def on_key_press(self, event):
        if self.active:
            key = event.key or ''
            key = key.replace('ctrl', 'control')
            if key == self._state_modifier_keys['clear']:
                self.clear()
                return
            for (state, modifier) in self._state_modifier_keys.items():
                if modifier in key.split('+'):
                    if state == 'rotate':
                        if state in self._state:
                            self._state.discard(state)
                        else:
                            self._state.add(state)
                    else:
                        self._state.add(state)
            self._on_key_press(event)

    def _on_key_press(self, event):

    def on_key_release(self, event):
        if self.active:
            key = event.key or ''
            for (state, modifier) in self._state_modifier_keys.items():
                if modifier in key.split('+') and state != 'rotate':
                    self._state.discard(state)
            self._on_key_release(event)

    def _on_key_release(self, event):

    def set_visible(self, visible):
        self._visible = visible
        for artist in self.artists:
            artist.set_visible(visible)

    def get_visible(self):
        return self._visible

    @property
    def visible(self):
        _api.warn_deprecated('3.8', alternative='get_visible')
        return self.get_visible()

    def clear(self):
        self._clear_without_update()
        self.update()

    def _clear_without_update(self):
        self._selection_completed = False
        self.set_visible(False)

    @property
    def artists(self):
        handles_artists = getattr(self, '_handles_artists', ())
        return (self._selection_artist,) + handles_artists

    def set_props(self, **props):
        artist = self._selection_artist
        props = cbook.normalize_kwargs(props, artist)
        artist.set(**props)
        if self.useblit:
            self.update()

    def set_handle_props(self, **handle_props):
        if not hasattr(self, '_handles_artists'):
            raise NotImplementedError("This selector doesn't have handles.")
        artist = self._handles_artists[0]
        handle_props = cbook.normalize_kwargs(handle_props, artist)
        for handle in self._handles_artists:
            handle.set(**handle_props)
        if self.useblit:
            self.update()
        self._handle_props.update(handle_props)

    def _validate_state(self, state):
        supported_state = [key for (key, value) in self._state_modifier_keys.items() if key != 'clear' and value != 'not-applicable']
        _api.check_in_list(supported_state, state=state)

    def add_state(self, state):
        self._validate_state(state)
        self._state.add(state)

    def remove_state(self, state):
        self._validate_state(state)
        self._state.remove(state)

class SpanSelector(_SelectorWidget):

    def __init__(self, ax, onselect, direction, *, minspan=0, useblit=False, props=None, onmove_callback=None, interactive=False, button=None, handle_props=None, grab_range=10, state_modifier_keys=None, drag_from_anywhere=False, ignore_event_outside=False, snap_values=None):
        if state_modifier_keys is None:
            state_modifier_keys = dict(clear='escape', square='not-applicable', center='not-applicable', rotate='not-applicable')
        super().__init__(ax, onselect, useblit=useblit, button=button, state_modifier_keys=state_modifier_keys)
        if props is None:
            props = dict(facecolor='red', alpha=0.5)
        props['animated'] = self.useblit
        self.direction = direction
        self._extents_on_press = None
        self.snap_values = snap_values
        self.onmove_callback = onmove_callback
        self.minspan = minspan
        self.grab_range = grab_range
        self._interactive = interactive
        self._edge_handles = None
        self.drag_from_anywhere = drag_from_anywhere
        self.ignore_event_outside = ignore_event_outside
        self.new_axes(ax, _props=props, _init=True)
        self._handle_props = {'color': props.get('facecolor', 'r'), **cbook.normalize_kwargs(handle_props, Line2D)}
        if self._interactive:
            self._edge_order = ['min', 'max']
            self._setup_edge_handles(self._handle_props)
        self._active_handle = None

    def new_axes(self, ax, *, _props=None, _init=False):
        reconnect = False
        if _init or self.canvas is not ax.get_figure(root=True).canvas:
            if self.canvas is not None:
                self.disconnect_events()
            reconnect = True
        self.ax = ax
        if reconnect:
            self.connect_default_events()
        self._selection_completed = False
        if self.direction == 'horizontal':
            trans = ax.get_xaxis_transform()
            (w, h) = (0, 1)
        else:
            trans = ax.get_yaxis_transform()
            (w, h) = (1, 0)
        rect_artist = Rectangle((0, 0), w, h, transform=trans, visible=False)
        if _props is not None:
            rect_artist.update(_props)
        elif self._selection_artist is not None:
            rect_artist.update_from(self._selection_artist)
        self.ax.add_patch(rect_artist)
        self._selection_artist = rect_artist

    def _setup_edge_handles(self, props):
        if self.direction == 'horizontal':
            positions = self.ax.get_xbound()
        else:
            positions = self.ax.get_ybound()
        self._edge_handles = ToolLineHandles(self.ax, positions, direction=self.direction, line_props=props, useblit=self.useblit)

    @property
    def _handles_artists(self):
        if self._edge_handles is not None:
            return self._edge_handles.artists
        else:
            return ()

    def _set_cursor(self, enabled):
        if enabled:
            cursor = backend_tools.Cursors.RESIZE_HORIZONTAL if self.direction == 'horizontal' else backend_tools.Cursors.RESIZE_VERTICAL
        else:
            cursor = backend_tools.Cursors.POINTER
        self.ax.get_figure(root=True).canvas.set_cursor(cursor)

    def connect_default_events(self):
        super().connect_default_events()
        if getattr(self, '_interactive', False):
            self.connect_event('motion_notify_event', self._hover)

    def _press(self, event):
        self._set_cursor(True)
        if self._interactive and self._selection_artist.get_visible():
            self._set_active_handle(event)
        else:
            self._active_handle = None
        if self._active_handle is None or not self._interactive:
            self.update()
        (xdata, ydata) = self._get_data_coords(event)
        v = xdata if self.direction == 'horizontal' else ydata
        if self._active_handle is None and (not self.ignore_event_outside):
            self._visible = False
            self._set_extents((v, v))
            self._visible = True
        else:
            self.set_visible(True)
        return False

    @property
    def direction(self):
        return self._direction

    @direction.setter
    def direction(self, direction):
        _api.check_in_list(['horizontal', 'vertical'], direction=direction)
        if hasattr(self, '_direction') and direction != self._direction:
            self._selection_artist.remove()
            if self._interactive:
                self._edge_handles.remove()
            self._direction = direction
            self.new_axes(self.ax)
            if self._interactive:
                self._setup_edge_handles(self._handle_props)
        else:
            self._direction = direction

    def _release(self, event):
        self._set_cursor(False)
        if not self._interactive:
            self._selection_artist.set_visible(False)
        if self._active_handle is None and self._selection_completed and self.ignore_event_outside:
            return
        (vmin, vmax) = self.extents
        span = vmax - vmin
        if span <= self.minspan:
            self.set_visible(False)
            if self._selection_completed:
                self.onselect(vmin, vmax)
            self._selection_completed = False
        else:
            self.onselect(vmin, vmax)
            self._selection_completed = True
        self.update()
        self._active_handle = None
        return False

    def _hover(self, event):
        if self.ignore(event):
            return
        if self._active_handle is not None or not self._selection_completed:
            return
        (_, e_dist) = self._edge_handles.closest(event.x, event.y)
        self._set_cursor(e_dist <= self.grab_range)

    def _onmove(self, event):
        (xdata, ydata) = self._get_data_coords(event)
        if self.direction == 'horizontal':
            v = xdata
            vpress = self._eventpress.xdata
        else:
            v = ydata
            vpress = self._eventpress.ydata
        if self._active_handle == 'C' and self._extents_on_press is not None:
            (vmin, vmax) = self._extents_on_press
            dv = v - vpress
            vmin += dv
            vmax += dv
        elif self._active_handle and self._active_handle != 'C':
            (vmin, vmax) = self._extents_on_press
            if self._active_handle == 'min':
                vmin = v
            else:
                vmax = v
        else:
            if self.ignore_event_outside and self._selection_completed:
                return
            (vmin, vmax) = (vpress, v)
            if vmin > vmax:
                (vmin, vmax) = (vmax, vmin)
        self._set_extents((vmin, vmax))
        if self.onmove_callback is not None:
            self.onmove_callback(vmin, vmax)
        return False

    def _draw_shape(self, vmin, vmax):
        if vmin > vmax:
            (vmin, vmax) = (vmax, vmin)
        if self.direction == 'horizontal':
            self._selection_artist.set_x(vmin)
            self._selection_artist.set_width(vmax - vmin)
        else:
            self._selection_artist.set_y(vmin)
            self._selection_artist.set_height(vmax - vmin)

    def _set_active_handle(self, event):
        (e_idx, e_dist) = self._edge_handles.closest(event.x, event.y)
        if 'move' in self._state:
            self._active_handle = 'C'
        elif e_dist > self.grab_range:
            self._active_handle = None
            if self.drag_from_anywhere and self._contains(event):
                self._active_handle = 'C'
                self._extents_on_press = self.extents
            else:
                self._active_handle = None
                return
        else:
            self._active_handle = self._edge_order[e_idx]
        self._extents_on_press = self.extents

    def _contains(self, event):
        return self._selection_artist.contains(event, radius=0)[0]

    @staticmethod
    def _snap(values, snap_values):
        eps = np.min(np.abs(np.diff(snap_values))) * 1e-12
        return tuple((snap_values[np.abs(snap_values - v + np.sign(v) * eps).argmin()] for v in values))

    @property
    def extents(self):
        if self.direction == 'horizontal':
            vmin = self._selection_artist.get_x()
            vmax = vmin + self._selection_artist.get_width()
        else:
            vmin = self._selection_artist.get_y()
            vmax = vmin + self._selection_artist.get_height()
        return (vmin, vmax)

    @extents.setter
    def extents(self, extents):
        self._set_extents(extents)
        self._selection_completed = True

    def _set_extents(self, extents):
        if self.snap_values is not None:
            extents = tuple(self._snap(extents, self.snap_values))
        self._draw_shape(*extents)
        if self._interactive:
            self._edge_handles.set_data(self.extents)
        self.set_visible(self._visible)
        self.update()

class ToolLineHandles:

    def __init__(self, ax, positions, direction, *, line_props=None, useblit=True):
        self.ax = ax
        _api.check_in_list(['horizontal', 'vertical'], direction=direction)
        self._direction = direction
        line_props = {**(line_props if line_props is not None else {}), 'visible': False, 'animated': useblit}
        line_fun = ax.axvline if self.direction == 'horizontal' else ax.axhline
        self._artists = [line_fun(p, **line_props) for p in positions]

    @property
    def artists(self):
        return tuple(self._artists)

    @property
    def positions(self):
        method = 'get_xdata' if self.direction == 'horizontal' else 'get_ydata'
        return [getattr(line, method)()[0] for line in self.artists]

    @property
    def direction(self):
        return self._direction

    def set_data(self, positions):
        method = 'set_xdata' if self.direction == 'horizontal' else 'set_ydata'
        for (line, p) in zip(self.artists, positions):
            getattr(line, method)([p, p])

    def set_visible(self, value):
        for artist in self.artists:
            artist.set_visible(value)

    def set_animated(self, value):
        for artist in self.artists:
            artist.set_animated(value)

    def remove(self):
        for artist in self._artists:
            artist.remove()

    def closest(self, x, y):
        if self.direction == 'horizontal':
            p_pts = np.array([self.ax.transData.transform((p, 0))[0] for p in self.positions])
            dist = abs(p_pts - x)
        else:
            p_pts = np.array([self.ax.transData.transform((0, p))[1] for p in self.positions])
            dist = abs(p_pts - y)
        index = np.argmin(dist)
        return (index, dist[index])

class ToolHandles:

    def __init__(self, ax, x, y, *, marker='o', marker_props=None, useblit=True):
        self.ax = ax
        props = {'marker': marker, 'markersize': 7, 'markerfacecolor': 'w', 'linestyle': 'none', 'alpha': 0.5, 'visible': False, 'label': '_nolegend_', **cbook.normalize_kwargs(marker_props, Line2D._alias_map)}
        self._markers = Line2D(x, y, animated=useblit, **props)
        self.ax.add_line(self._markers)

    @property
    def x(self):
        return self._markers.get_xdata()

    @property
    def y(self):
        return self._markers.get_ydata()

    @property
    def artists(self):
        return (self._markers,)

    def set_data(self, pts, y=None):
        if y is not None:
            x = pts
            pts = np.array([x, y])
        self._markers.set_data(pts)

    def set_visible(self, val):
        self._markers.set_visible(val)

    def set_animated(self, val):
        self._markers.set_animated(val)

    def closest(self, x, y):
        pts = np.column_stack([self.x, self.y])
        pts = self.ax.transData.transform(pts)
        diff = pts - [x, y]
        dist = np.hypot(*diff.T)
        min_index = np.argmin(dist)
        return (min_index, dist[min_index])
_RECTANGLESELECTOR_PARAMETERS_DOCSTRING = '\n    Parameters\n    ----------\n    ax : `~matplotlib.axes.Axes`\n        The parent Axes for the widget.\n\n    onselect : function\n        A callback function that is called after a release event and the\n        selection is created, changed or removed.\n        It must have the signature::\n\n            def onselect(eclick: MouseEvent, erelease: MouseEvent)\n\n        where *eclick* and *erelease* are the mouse click and release\n        `.MouseEvent`\\s that start and complete the selection.\n\n    minspanx : float, default: 0\n        Selections with an x-span less than or equal to *minspanx* are removed\n        (when already existing) or cancelled.\n\n    minspany : float, default: 0\n        Selections with an y-span less than or equal to *minspanx* are removed\n        (when already existing) or cancelled.\n\n    useblit : bool, default: False\n        Whether to use blitting for faster drawing (if supported by the\n        backend). See the tutorial :ref:`blitting`\n        for details.\n\n    props : dict, optional\n        Properties with which the __ARTIST_NAME__ is drawn. See\n        `.Patch` for valid properties.\n        Default:\n\n        ``dict(facecolor=\'red\', edgecolor=\'black\', alpha=0.2, fill=True)``\n\n    spancoords : {"data", "pixels"}, default: "data"\n        Whether to interpret *minspanx* and *minspany* in data or in pixel\n        coordinates.\n\n    button : `.MouseButton`, list of `.MouseButton`, default: all buttons\n        Button(s) that trigger rectangle selection.\n\n    grab_range : float, default: 10\n        Distance in pixels within which the interactive tool handles can be\n        activated.\n\n    handle_props : dict, optional\n        Properties with which the interactive handles (marker artists) are\n        drawn. See the marker arguments in `.Line2D` for valid\n        properties.  Default values are defined in ``mpl.rcParams`` except for\n        the default value of ``markeredgecolor`` which will be the same as the\n        ``edgecolor`` property in *props*.\n\n    interactive : bool, default: False\n        Whether to draw a set of handles that allow interaction with the\n        widget after it is drawn.\n\n    state_modifier_keys : dict, optional\n        Keyboard modifiers which affect the widget\'s behavior.  Values\n        amend the defaults, which are:\n\n        - "move": Move the existing shape, default: no modifier.\n        - "clear": Clear the current shape, default: "escape".\n        - "square": Make the shape square, default: "shift".\n        - "center": change the shape around its center, default: "ctrl".\n        - "rotate": Rotate the shape around its center between -45° and 45°,\n          default: "r".\n\n        "square" and "center" can be combined. The square shape can be defined\n        in data or display coordinates as determined by the\n        ``use_data_coordinates`` argument specified when creating the selector.\n\n    drag_from_anywhere : bool, default: False\n        If `True`, the widget can be moved by clicking anywhere within\n        its bounds.\n\n    ignore_event_outside : bool, default: False\n        If `True`, the event triggered outside the span selector will be\n        ignored.\n\n    use_data_coordinates : bool, default: False\n        If `True`, the "square" shape of the selector is defined in\n        data coordinates instead of display coordinates.\n    '

@_docstring.Substitution(_RECTANGLESELECTOR_PARAMETERS_DOCSTRING.replace('__ARTIST_NAME__', 'rectangle'))
class RectangleSelector(_SelectorWidget):

    def __init__(self, ax, onselect, *, minspanx=0, minspany=0, useblit=False, props=None, spancoords='data', button=None, grab_range=10, handle_props=None, interactive=False, state_modifier_keys=None, drag_from_anywhere=False, ignore_event_outside=False, use_data_coordinates=False):
        super().__init__(ax, onselect, useblit=useblit, button=button, state_modifier_keys=state_modifier_keys, use_data_coordinates=use_data_coordinates)
        self._interactive = interactive
        self.drag_from_anywhere = drag_from_anywhere
        self.ignore_event_outside = ignore_event_outside
        self._rotation = 0.0
        self._aspect_ratio_correction = 1.0
        self._allow_creation = True
        if props is None:
            props = dict(facecolor='red', edgecolor='black', alpha=0.2, fill=True)
        props = {**props, 'animated': self.useblit}
        self._visible = props.pop('visible', self._visible)
        to_draw = self._init_shape(**props)
        self.ax.add_patch(to_draw)
        self._selection_artist = to_draw
        self._set_aspect_ratio_correction()
        self.minspanx = minspanx
        self.minspany = minspany
        _api.check_in_list(['data', 'pixels'], spancoords=spancoords)
        self.spancoords = spancoords
        self.grab_range = grab_range
        if self._interactive:
            self._handle_props = {'markeredgecolor': (props or {}).get('edgecolor', 'black'), **cbook.normalize_kwargs(handle_props, Line2D)}
            self._corner_order = ['SW', 'SE', 'NE', 'NW']
            (xc, yc) = self.corners
            self._corner_handles = ToolHandles(self.ax, xc, yc, marker_props=self._handle_props, useblit=self.useblit)
            self._edge_order = ['W', 'S', 'E', 'N']
            (xe, ye) = self.edge_centers
            self._edge_handles = ToolHandles(self.ax, xe, ye, marker='s', marker_props=self._handle_props, useblit=self.useblit)
            (xc, yc) = self.center
            self._center_handle = ToolHandles(self.ax, [xc], [yc], marker='s', marker_props=self._handle_props, useblit=self.useblit)
            self._active_handle = None
        self._extents_on_press = None

    @property
    def _handles_artists(self):
        return (*self._center_handle.artists, *self._corner_handles.artists, *self._edge_handles.artists)

    def _init_shape(self, **props):
        return Rectangle((0, 0), 0, 1, visible=False, rotation_point='center', **props)

    def _press(self, event):
        if self._interactive and self._selection_artist.get_visible():
            self._set_active_handle(event)
        else:
            self._active_handle = None
        if (self._active_handle is None or not self._interactive) and self._allow_creation:
            self.update()
        if self._active_handle is None and (not self.ignore_event_outside) and self._allow_creation:
            (x, y) = self._get_data_coords(event)
            self._visible = False
            self.extents = (x, x, y, y)
            self._visible = True
        else:
            self.set_visible(True)
        self._extents_on_press = self.extents
        self._rotation_on_press = self._rotation
        self._set_aspect_ratio_correction()
        return False

    def _release(self, event):
        if not self._interactive:
            self._selection_artist.set_visible(False)
        if self._active_handle is None and self._selection_completed and self.ignore_event_outside:
            return
        (x0, x1, y0, y1) = self.extents
        self._eventpress.xdata = x0
        self._eventpress.ydata = y0
        xy0 = self.ax.transData.transform([x0, y0])
        (self._eventpress.x, self._eventpress.y) = xy0
        self._eventrelease.xdata = x1
        self._eventrelease.ydata = y1
        xy1 = self.ax.transData.transform([x1, y1])
        (self._eventrelease.x, self._eventrelease.y) = xy1
        if self.spancoords == 'data':
            spanx = abs(self._eventpress.xdata - self._eventrelease.xdata)
            spany = abs(self._eventpress.ydata - self._eventrelease.ydata)
        elif self.spancoords == 'pixels':
            spanx = abs(self._eventpress.x - self._eventrelease.x)
            spany = abs(self._eventpress.y - self._eventrelease.y)
        else:
            _api.check_in_list(['data', 'pixels'], spancoords=self.spancoords)
        if spanx <= self.minspanx or spany <= self.minspany:
            if self._selection_completed:
                self.onselect(self._eventpress, self._eventrelease)
            self._clear_without_update()
        else:
            self.onselect(self._eventpress, self._eventrelease)
            self._selection_completed = True
        self.update()
        self._active_handle = None
        self._extents_on_press = None
        return False

    def _onmove(self, event):
        eventpress = self._eventpress
        state = self._state
        rotate = 'rotate' in state and self._active_handle in self._corner_order
        move = self._active_handle == 'C'
        resize = self._active_handle and (not move)
        (xdata, ydata) = self._get_data_coords(event)
        if resize:
            inv_tr = self._get_rotation_transform().inverted()
            (xdata, ydata) = inv_tr.transform([xdata, ydata])
            (eventpress.xdata, eventpress.ydata) = inv_tr.transform((eventpress.xdata, eventpress.ydata))
        dx = xdata - eventpress.xdata
        dy = ydata - eventpress.ydata
        refmax = None
        if self._use_data_coordinates:
            (refx, refy) = (dx, dy)
        else:
            refx = event.x - eventpress.x
            refy = event.y - eventpress.y
        (x0, x1, y0, y1) = self._extents_on_press
        if rotate:
            a = (eventpress.xdata, eventpress.ydata)
            b = self.center
            c = (xdata, ydata)
            angle = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
            self.rotation = np.rad2deg(self._rotation_on_press + angle)
        elif resize:
            size_on_press = [x1 - x0, y1 - y0]
            center = (x0 + size_on_press[0] / 2, y0 + size_on_press[1] / 2)
            if 'center' in state:
                if 'square' in state:
                    if self._active_handle in self._corner_order:
                        refmax = max(refx, refy, key=abs)
                    if self._active_handle in ['E', 'W'] or refmax == refx:
                        hw = xdata - center[0]
                        hh = hw / self._aspect_ratio_correction
                    else:
                        hh = ydata - center[1]
                        hw = hh * self._aspect_ratio_correction
                else:
                    hw = size_on_press[0] / 2
                    hh = size_on_press[1] / 2
                    if self._active_handle in ['E', 'W'] + self._corner_order:
                        hw = abs(xdata - center[0])
                    if self._active_handle in ['N', 'S'] + self._corner_order:
                        hh = abs(ydata - center[1])
                (x0, x1, y0, y1) = (center[0] - hw, center[0] + hw, center[1] - hh, center[1] + hh)
            else:
                if 'W' in self._active_handle:
                    x0 = x1
                if 'S' in self._active_handle:
                    y0 = y1
                if self._active_handle in ['E', 'W'] + self._corner_order:
                    x1 = xdata
                if self._active_handle in ['N', 'S'] + self._corner_order:
                    y1 = ydata
                if 'square' in state:
                    if self._active_handle in self._corner_order:
                        refmax = max(refx, refy, key=abs)
                    if self._active_handle in ['E', 'W'] or refmax == refx:
                        sign = np.sign(ydata - y0)
                        y1 = y0 + sign * abs(x1 - x0) / self._aspect_ratio_correction
                    else:
                        sign = np.sign(xdata - x0)
                        x1 = x0 + sign * abs(y1 - y0) * self._aspect_ratio_correction
        elif move:
            (x0, x1, y0, y1) = self._extents_on_press
            dx = xdata - eventpress.xdata
            dy = ydata - eventpress.ydata
            x0 += dx
            x1 += dx
            y0 += dy
            y1 += dy
        else:
            self._rotation = 0
            if self.ignore_event_outside and self._selection_completed or not self._allow_creation:
                return
            center = [eventpress.xdata, eventpress.ydata]
            dx = (xdata - center[0]) / 2
            dy = (ydata - center[1]) / 2
            if 'square' in state:
                refmax = max(refx, refy, key=abs)
                if refmax == refx:
                    dy = np.sign(dy) * abs(dx) / self._aspect_ratio_correction
                else:
                    dx = np.sign(dx) * abs(dy) * self._aspect_ratio_correction
            if 'center' in state:
                dx *= 2
                dy *= 2
            else:
                center[0] += dx
                center[1] += dy
            (x0, x1, y0, y1) = (center[0] - dx, center[0] + dx, center[1] - dy, center[1] + dy)
        self.extents = (x0, x1, y0, y1)

    @property
    def _rect_bbox(self):
        return self._selection_artist.get_bbox().bounds

    def _set_aspect_ratio_correction(self):
        aspect_ratio = self.ax._get_aspect_ratio()
        self._selection_artist._aspect_ratio_correction = aspect_ratio
        if self._use_data_coordinates:
            self._aspect_ratio_correction = 1
        else:
            self._aspect_ratio_correction = aspect_ratio

    def _get_rotation_transform(self):
        aspect_ratio = self.ax._get_aspect_ratio()
        return Affine2D().translate(-self.center[0], -self.center[1]).scale(1, aspect_ratio).rotate(self._rotation).scale(1, 1 / aspect_ratio).translate(*self.center)

    @property
    def corners(self):
        (x0, y0, width, height) = self._rect_bbox
        xc = (x0, x0 + width, x0 + width, x0)
        yc = (y0, y0, y0 + height, y0 + height)
        transform = self._get_rotation_transform()
        coords = transform.transform(np.array([xc, yc]).T).T
        return (coords[0], coords[1])

    @property
    def edge_centers(self):
        (x0, y0, width, height) = self._rect_bbox
        w = width / 2.0
        h = height / 2.0
        xe = (x0, x0 + w, x0 + width, x0 + w)
        ye = (y0 + h, y0, y0 + h, y0 + height)
        transform = self._get_rotation_transform()
        coords = transform.transform(np.array([xe, ye]).T).T
        return (coords[0], coords[1])

    @property
    def center(self):
        (x0, y0, width, height) = self._rect_bbox
        return (x0 + width / 2.0, y0 + height / 2.0)

    @property
    def extents(self):
        (x0, y0, width, height) = self._rect_bbox
        (xmin, xmax) = sorted([x0, x0 + width])
        (ymin, ymax) = sorted([y0, y0 + height])
        return (xmin, xmax, ymin, ymax)

    @extents.setter
    def extents(self, extents):
        self._draw_shape(extents)
        if self._interactive:
            self._corner_handles.set_data(*self.corners)
            self._edge_handles.set_data(*self.edge_centers)
            (x, y) = self.center
            self._center_handle.set_data([x], [y])
        self.set_visible(self._visible)
        self.update()

    @property
    def rotation(self):
        return np.rad2deg(self._rotation)

    @rotation.setter
    def rotation(self, value):
        if -45 <= value and value <= 45:
            self._rotation = np.deg2rad(value)
            self.extents = self.extents

    def _draw_shape(self, extents):
        (x0, x1, y0, y1) = extents
        (xmin, xmax) = sorted([x0, x1])
        (ymin, ymax) = sorted([y0, y1])
        xlim = sorted(self.ax.get_xlim())
        ylim = sorted(self.ax.get_ylim())
        xmin = max(xlim[0], xmin)
        ymin = max(ylim[0], ymin)
        xmax = min(xmax, xlim[1])
        ymax = min(ymax, ylim[1])
        self._selection_artist.set_x(xmin)
        self._selection_artist.set_y(ymin)
        self._selection_artist.set_width(xmax - xmin)
        self._selection_artist.set_height(ymax - ymin)
        self._selection_artist.set_angle(self.rotation)

    def _set_active_handle(self, event):
        (c_idx, c_dist) = self._corner_handles.closest(event.x, event.y)
        (e_idx, e_dist) = self._edge_handles.closest(event.x, event.y)
        (m_idx, m_dist) = self._center_handle.closest(event.x, event.y)
        if 'move' in self._state:
            self._active_handle = 'C'
        elif m_dist < self.grab_range * 2:
            self._active_handle = 'C'
        elif c_dist > self.grab_range and e_dist > self.grab_range:
            if self.drag_from_anywhere and self._contains(event):
                self._active_handle = 'C'
            else:
                self._active_handle = None
                return
        elif c_dist < e_dist:
            self._active_handle = self._corner_order[c_idx]
        else:
            self._active_handle = self._edge_order[e_idx]

    def _contains(self, event):
        return self._selection_artist.contains(event, radius=0)[0]

    @property
    def geometry(self):
        if hasattr(self._selection_artist, 'get_verts'):
            xfm = self.ax.transData.inverted()
            (y, x) = xfm.transform(self._selection_artist.get_verts()).T
            return np.array([x, y])
        else:
            return np.array(self._selection_artist.get_data())

@_docstring.Substitution(_RECTANGLESELECTOR_PARAMETERS_DOCSTRING.replace('__ARTIST_NAME__', 'ellipse'))
class EllipseSelector(RectangleSelector):

    def _init_shape(self, **props):
        return Ellipse((0, 0), 0, 1, visible=False, **props)

    def _draw_shape(self, extents):
        (x0, x1, y0, y1) = extents
        (xmin, xmax) = sorted([x0, x1])
        (ymin, ymax) = sorted([y0, y1])
        center = [x0 + (x1 - x0) / 2.0, y0 + (y1 - y0) / 2.0]
        a = (xmax - xmin) / 2.0
        b = (ymax - ymin) / 2.0
        self._selection_artist.center = center
        self._selection_artist.width = 2 * a
        self._selection_artist.height = 2 * b
        self._selection_artist.angle = self.rotation

    @property
    def _rect_bbox(self):
        (x, y) = self._selection_artist.center
        width = self._selection_artist.width
        height = self._selection_artist.height
        return (x - width / 2.0, y - height / 2.0, width, height)

class LassoSelector(_SelectorWidget):

    def __init__(self, ax, onselect, *, useblit=True, props=None, button=None):
        super().__init__(ax, onselect, useblit=useblit, button=button)
        self.verts = None
        props = {**(props if props is not None else {}), 'animated': self.useblit, 'visible': False}
        line = Line2D([], [], **props)
        self.ax.add_line(line)
        self._selection_artist = line

    def _press(self, event):
        self.verts = [self._get_data(event)]
        self._selection_artist.set_visible(True)

    def _release(self, event):
        if self.verts is not None:
            self.verts.append(self._get_data(event))
            self.onselect(self.verts)
        self._selection_artist.set_data([[], []])
        self._selection_artist.set_visible(False)
        self.verts = None

    def _onmove(self, event):
        if self.verts is None:
            return
        self.verts.append(self._get_data(event))
        self._selection_artist.set_data(list(zip(*self.verts)))
        self.update()

class PolygonSelector(_SelectorWidget):

    def __init__(self, ax, onselect, *, useblit=False, props=None, handle_props=None, grab_range=10, draw_bounding_box=False, box_handle_props=None, box_props=None):
        state_modifier_keys = dict(clear='escape', move_vertex='control', move_all='shift', move='not-applicable', square='not-applicable', center='not-applicable', rotate='not-applicable')
        super().__init__(ax, onselect, useblit=useblit, state_modifier_keys=state_modifier_keys)
        self._xys = [(0, 0)]
        if props is None:
            props = dict(color='k', linestyle='-', linewidth=2, alpha=0.5)
        props = {**props, 'animated': self.useblit}
        self._selection_artist = line = Line2D([], [], **props)
        self.ax.add_line(line)
        if handle_props is None:
            handle_props = dict(markeredgecolor='k', markerfacecolor=props.get('color', 'k'))
        self._handle_props = handle_props
        self._polygon_handles = ToolHandles(self.ax, [], [], useblit=self.useblit, marker_props=self._handle_props)
        self._active_handle_idx = -1
        self.grab_range = grab_range
        self.set_visible(True)
        self._draw_box = draw_bounding_box
        self._box = None
        if box_handle_props is None:
            box_handle_props = {}
        self._box_handle_props = self._handle_props.update(box_handle_props)
        self._box_props = box_props

    def _get_bbox(self):
        return self._selection_artist.get_bbox()

    def _add_box(self):
        self._box = RectangleSelector(self.ax, onselect=lambda *args, **kwargs: None, useblit=self.useblit, grab_range=self.grab_range, handle_props=self._box_handle_props, props=self._box_props, interactive=True)
        self._box._state_modifier_keys.pop('rotate')
        self._box.connect_event('motion_notify_event', self._scale_polygon)
        self._update_box()
        self._box._allow_creation = False
        self._box._selection_completed = True
        self._draw_polygon()

    def _remove_box(self):
        if self._box is not None:
            self._box.set_visible(False)
            self._box = None

    def _update_box(self):
        if self._box is not None:
            bbox = self._get_bbox()
            self._box.extents = [bbox.x0, bbox.x1, bbox.y0, bbox.y1]
            self._old_box_extents = self._box.extents

    def _scale_polygon(self, event):
        if not self._selection_completed:
            return
        if self._old_box_extents == self._box.extents:
            return
        (x1, y1, w1, h1) = self._box._rect_bbox
        old_bbox = self._get_bbox()
        t = transforms.Affine2D().translate(-old_bbox.x0, -old_bbox.y0).scale(1 / old_bbox.width, 1 / old_bbox.height).scale(w1, h1).translate(x1, y1)
        new_verts = [(x, y) for (x, y) in t.transform(np.array(self.verts))]
        self._xys = [*new_verts, new_verts[0]]
        self._draw_polygon()
        self._old_box_extents = self._box.extents

    @property
    def _handles_artists(self):
        return self._polygon_handles.artists

    def _remove_vertex(self, i):
        if len(self._xys) > 2 and self._selection_completed and (i in (0, len(self._xys) - 1)):
            self._xys.pop(0)
            self._xys.pop(-1)
            self._xys.append(self._xys[0])
        else:
            self._xys.pop(i)
        if len(self._xys) <= 2:
            self._selection_completed = False
            self._remove_box()

    def _press(self, event):
        if (self._selection_completed or 'move_vertex' in self._state) and len(self._xys) > 0:
            (h_idx, h_dist) = self._polygon_handles.closest(event.x, event.y)
            if h_dist < self.grab_range:
                self._active_handle_idx = h_idx
        self._xys_at_press = self._xys.copy()

    def _release(self, event):
        if self._active_handle_idx >= 0:
            if event.button == 3:
                self._remove_vertex(self._active_handle_idx)
                self._draw_polygon()
            self._active_handle_idx = -1
        elif len(self._xys) > 3 and self._xys[-1] == self._xys[0]:
            self._selection_completed = True
            if self._draw_box and self._box is None:
                self._add_box()
        elif not self._selection_completed and 'move_all' not in self._state and ('move_vertex' not in self._state):
            self._xys.insert(-1, self._get_data_coords(event))
        if self._selection_completed:
            self.onselect(self.verts)

    def onmove(self, event):
        if self.ignore(event):
            if not self.canvas.widgetlock.available(self) and self._xys:
                self._xys[-1] = (np.nan, np.nan)
                self._draw_polygon()
            return False
        else:
            event = self._clean_event(event)
            self._onmove(event)
            return True

    def _onmove(self, event):
        if self._active_handle_idx >= 0:
            idx = self._active_handle_idx
            self._xys[idx] = self._get_data_coords(event)
            if idx == 0 and self._selection_completed:
                self._xys[-1] = self._get_data_coords(event)
        elif 'move_all' in self._state and self._eventpress:
            (xdata, ydata) = self._get_data_coords(event)
            dx = xdata - self._eventpress.xdata
            dy = ydata - self._eventpress.ydata
            for k in range(len(self._xys)):
                (x_at_press, y_at_press) = self._xys_at_press[k]
                self._xys[k] = (x_at_press + dx, y_at_press + dy)
        elif self._selection_completed or 'move_vertex' in self._state or 'move_all' in self._state:
            return
        else:
            (x0, y0) = self._selection_artist.get_transform().transform(self._xys[0])
            v0_dist = np.hypot(x0 - event.x, y0 - event.y)
            if len(self._xys) > 3 and v0_dist < self.grab_range:
                self._xys[-1] = self._xys[0]
            else:
                self._xys[-1] = self._get_data_coords(event)
        self._draw_polygon()

    def _on_key_press(self, event):
        if not self._selection_completed and ('move_vertex' in self._state or 'move_all' in self._state):
            self._xys.pop()
            self._draw_polygon()

    def _on_key_release(self, event):
        if not self._selection_completed and (event.key == self._state_modifier_keys.get('move_vertex') or event.key == self._state_modifier_keys.get('move_all')):
            self._xys.append(self._get_data_coords(event))
            self._draw_polygon()
        elif event.key == self._state_modifier_keys.get('clear'):
            event = self._clean_event(event)
            self._xys = [self._get_data_coords(event)]
            self._selection_completed = False
            self._remove_box()
            self.set_visible(True)

    def _draw_polygon_without_update(self):
        (xs, ys) = zip(*self._xys) if self._xys else ([], [])
        self._selection_artist.set_data(xs, ys)
        self._update_box()
        if self._selection_completed or (len(self._xys) > 3 and self._xys[-1] == self._xys[0]):
            self._polygon_handles.set_data(xs[:-1], ys[:-1])
        else:
            self._polygon_handles.set_data(xs, ys)

    def _draw_polygon(self):
        self._draw_polygon_without_update()
        self.update()

    @property
    def verts(self):
        return self._xys[:-1]

    @verts.setter
    def verts(self, xys):
        self._xys = [*xys, xys[0]]
        self._selection_completed = True
        self.set_visible(True)
        if self._draw_box and self._box is None:
            self._add_box()
        self._draw_polygon()

    def _clear_without_update(self):
        self._selection_completed = False
        self._xys = [(0, 0)]
        self._draw_polygon_without_update()

class Lasso(AxesWidget):

    def __init__(self, ax, xy, callback, *, useblit=True, props=None):
        super().__init__(ax)
        self.useblit = useblit and self.canvas.supports_blit
        if self.useblit:
            self.background = self.canvas.copy_from_bbox(self.ax.bbox)
        style = {'linestyle': '-', 'color': 'black', 'lw': 2}
        if props is not None:
            style.update(props)
        (x, y) = xy
        self.verts = [(x, y)]
        self.line = Line2D([x], [y], **style)
        self.ax.add_line(self.line)
        self.callback = callback
        self.connect_event('button_release_event', self.onrelease)
        self.connect_event('motion_notify_event', self.onmove)

    def onrelease(self, event):
        if self.ignore(event):
            return
        if self.verts is not None:
            self.verts.append(self._get_data_coords(event))
            if len(self.verts) > 2:
                self.callback(self.verts)
            self.line.remove()
        self.verts = None
        self.disconnect_events()

    def onmove(self, event):
        if self.ignore(event) or self.verts is None or event.button != 1 or (not self.ax.contains(event)[0]):
            return
        self.verts.append(self._get_data_coords(event))
        self.line.set_data(list(zip(*self.verts)))
        if self.useblit:
            self.canvas.restore_region(self.background)
            self.ax.draw_artist(self.line)
            self.canvas.blit(self.ax.bbox)
        else:
            self.canvas.draw_idle()

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/anchored_artists.py
from matplotlib import _api, transforms
from matplotlib.offsetbox import AnchoredOffsetbox, AuxTransformBox, DrawingArea, TextArea, VPacker
from matplotlib.patches import Rectangle, Ellipse, ArrowStyle, FancyArrowPatch, PathPatch
from matplotlib.text import TextPath
__all__ = ['AnchoredDrawingArea', 'AnchoredAuxTransformBox', 'AnchoredEllipse', 'AnchoredSizeBar', 'AnchoredDirectionArrows']

class AnchoredDrawingArea(AnchoredOffsetbox):

    def __init__(self, width, height, xdescent, ydescent, loc, pad=0.4, borderpad=0.5, prop=None, frameon=True, **kwargs):
        self.da = DrawingArea(width, height, xdescent, ydescent)
        self.drawing_area = self.da
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self.da, prop=None, frameon=frameon, **kwargs)

class AnchoredAuxTransformBox(AnchoredOffsetbox):

    def __init__(self, transform, loc, pad=0.4, borderpad=0.5, prop=None, frameon=True, **kwargs):
        self.drawing_area = AuxTransformBox(transform)
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self.drawing_area, prop=prop, frameon=frameon, **kwargs)

@_api.deprecated('3.8')
class AnchoredEllipse(AnchoredOffsetbox):

    def __init__(self, transform, width, height, angle, loc, pad=0.1, borderpad=0.1, prop=None, frameon=True, **kwargs):
        self._box = AuxTransformBox(transform)
        self.ellipse = Ellipse((0, 0), width, height, angle=angle)
        self._box.add_artist(self.ellipse)
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self._box, prop=prop, frameon=frameon, **kwargs)

class AnchoredSizeBar(AnchoredOffsetbox):

    def __init__(self, transform, size, label, loc, pad=0.1, borderpad=0.1, sep=2, frameon=True, size_vertical=0, color='black', label_top=False, fontproperties=None, fill_bar=None, **kwargs):
        if fill_bar is None:
            fill_bar = size_vertical > 0
        self.size_bar = AuxTransformBox(transform)
        self.size_bar.add_artist(Rectangle((0, 0), size, size_vertical, fill=fill_bar, facecolor=color, edgecolor=color))
        if fontproperties is None and 'prop' in kwargs:
            fontproperties = kwargs.pop('prop')
        if fontproperties is None:
            textprops = {'color': color}
        else:
            textprops = {'color': color, 'fontproperties': fontproperties}
        self.txt_label = TextArea(label, textprops=textprops)
        if label_top:
            _box_children = [self.txt_label, self.size_bar]
        else:
            _box_children = [self.size_bar, self.txt_label]
        self._box = VPacker(children=_box_children, align='center', pad=0, sep=sep)
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self._box, prop=fontproperties, frameon=frameon, **kwargs)

class AnchoredDirectionArrows(AnchoredOffsetbox):

    def __init__(self, transform, label_x, label_y, length=0.15, fontsize=0.08, loc='upper left', angle=0, aspect_ratio=1, pad=0.4, borderpad=0.4, frameon=False, color='w', alpha=1, sep_x=0.01, sep_y=0, fontproperties=None, back_length=0.15, head_width=10, head_length=15, tail_width=2, text_props=None, arrow_props=None, **kwargs):
        if arrow_props is None:
            arrow_props = {}
        if text_props is None:
            text_props = {}
        arrowstyle = ArrowStyle('Simple', head_width=head_width, head_length=head_length, tail_width=tail_width)
        if fontproperties is None and 'prop' in kwargs:
            fontproperties = kwargs.pop('prop')
        if 'color' not in arrow_props:
            arrow_props['color'] = color
        if 'alpha' not in arrow_props:
            arrow_props['alpha'] = alpha
        if 'color' not in text_props:
            text_props['color'] = color
        if 'alpha' not in text_props:
            text_props['alpha'] = alpha
        t_start = transform
        t_end = t_start + transforms.Affine2D().rotate_deg(angle)
        self.box = AuxTransformBox(t_end)
        length_x = length
        length_y = length * aspect_ratio
        self.arrow_x = FancyArrowPatch((0, back_length * length_y), (length_x, back_length * length_y), arrowstyle=arrowstyle, shrinkA=0.0, shrinkB=0.0, **arrow_props)
        self.arrow_y = FancyArrowPatch((back_length * length_x, 0), (back_length * length_x, length_y), arrowstyle=arrowstyle, shrinkA=0.0, shrinkB=0.0, **arrow_props)
        self.box.add_artist(self.arrow_x)
        self.box.add_artist(self.arrow_y)
        text_path_x = TextPath((length_x + sep_x, back_length * length_y + sep_y), label_x, size=fontsize, prop=fontproperties)
        self.p_x = PathPatch(text_path_x, transform=t_start, **text_props)
        self.box.add_artist(self.p_x)
        text_path_y = TextPath((length_x * back_length + sep_x, length_y * (1 - back_length) + sep_y), label_y, size=fontsize, prop=fontproperties)
        self.p_y = PathPatch(text_path_y, **text_props)
        self.box.add_artist(self.p_y)
        super().__init__(loc, pad=pad, borderpad=borderpad, child=self.box, frameon=frameon, **kwargs)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/axes_divider.py
""""""
import functools
import numpy as np
import matplotlib as mpl
from matplotlib import _api
from matplotlib.gridspec import SubplotSpec
import matplotlib.transforms as mtransforms
from . import axes_size as Size

class Divider:

    def __init__(self, fig, pos, horizontal, vertical, aspect=None, anchor='C'):
        self._fig = fig
        self._pos = pos
        self._horizontal = horizontal
        self._vertical = vertical
        self._anchor = anchor
        self.set_anchor(anchor)
        self._aspect = aspect
        self._xrefindex = 0
        self._yrefindex = 0
        self._locator = None

    def get_horizontal_sizes(self, renderer):
        return np.array([s.get_size(renderer) for s in self.get_horizontal()])

    def get_vertical_sizes(self, renderer):
        return np.array([s.get_size(renderer) for s in self.get_vertical()])

    def set_position(self, pos):
        self._pos = pos

    def get_position(self):
        return self._pos

    def set_anchor(self, anchor):
        if isinstance(anchor, str):
            _api.check_in_list(mtransforms.Bbox.coefs, anchor=anchor)
        elif not isinstance(anchor, (tuple, list)) or len(anchor) != 2:
            raise TypeError('anchor must be str or 2-tuple')
        self._anchor = anchor

    def get_anchor(self):
        return self._anchor

    def get_subplotspec(self):
        return None

    def set_horizontal(self, h):
        self._horizontal = h

    def get_horizontal(self):
        return self._horizontal

    def set_vertical(self, v):
        self._vertical = v

    def get_vertical(self):
        return self._vertical

    def set_aspect(self, aspect=False):
        self._aspect = aspect

    def get_aspect(self):
        return self._aspect

    def set_locator(self, _locator):
        self._locator = _locator

    def get_locator(self):
        return self._locator

    def get_position_runtime(self, ax, renderer):
        if self._locator is None:
            return self.get_position()
        else:
            return self._locator(ax, renderer).bounds

    @staticmethod
    def _calc_k(sizes, total):
        (rel_sum, abs_sum) = sizes.sum(0)
        return (total - abs_sum) / rel_sum if rel_sum else 0

    @staticmethod
    def _calc_offsets(sizes, k):
        return np.cumsum([0, *sizes @ [k, 1]])

    def new_locator(self, nx, ny, nx1=None, ny1=None):
        if nx1 is None:
            nx1 = nx + 1
        if ny1 is None:
            ny1 = ny + 1
        xref = self._xrefindex
        yref = self._yrefindex
        locator = functools.partial(self._locate, nx - xref, ny - yref, nx1 - xref, ny1 - yref)
        locator.get_subplotspec = self.get_subplotspec
        return locator

    @_api.deprecated('3.8', alternative='divider.new_locator(...)(ax, renderer)')
    def locate(self, nx, ny, nx1=None, ny1=None, axes=None, renderer=None):
        xref = self._xrefindex
        yref = self._yrefindex
        return self._locate(nx - xref, (nx + 1 if nx1 is None else nx1) - xref, ny - yref, (ny + 1 if ny1 is None else ny1) - yref, axes, renderer)

    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
        nx += self._xrefindex
        nx1 += self._xrefindex
        ny += self._yrefindex
        ny1 += self._yrefindex
        (fig_w, fig_h) = self._fig.bbox.size / self._fig.dpi
        (x, y, w, h) = self.get_position_runtime(axes, renderer)
        hsizes = self.get_horizontal_sizes(renderer)
        vsizes = self.get_vertical_sizes(renderer)
        k_h = self._calc_k(hsizes, fig_w * w)
        k_v = self._calc_k(vsizes, fig_h * h)
        if self.get_aspect():
            k = min(k_h, k_v)
            ox = self._calc_offsets(hsizes, k)
            oy = self._calc_offsets(vsizes, k)
            ww = (ox[-1] - ox[0]) / fig_w
            hh = (oy[-1] - oy[0]) / fig_h
            pb = mtransforms.Bbox.from_bounds(x, y, w, h)
            pb1 = mtransforms.Bbox.from_bounds(x, y, ww, hh)
            (x0, y0) = pb1.anchored(self.get_anchor(), pb).p0
        else:
            ox = self._calc_offsets(hsizes, k_h)
            oy = self._calc_offsets(vsizes, k_v)
            (x0, y0) = (x, y)
        if nx1 is None:
            nx1 = -1
        if ny1 is None:
            ny1 = -1
        (x1, w1) = (x0 + ox[nx] / fig_w, (ox[nx1] - ox[nx]) / fig_w)
        (y1, h1) = (y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h)
        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)

    def append_size(self, position, size):
        _api.check_in_list(['left', 'right', 'bottom', 'top'], position=position)
        if position == 'left':
            self._horizontal.insert(0, size)
            self._xrefindex += 1
        elif position == 'right':
            self._horizontal.append(size)
        elif position == 'bottom':
            self._vertical.insert(0, size)
            self._yrefindex += 1
        else:
            self._vertical.append(size)

    def add_auto_adjustable_area(self, use_axes, pad=0.1, adjust_dirs=None):
        if adjust_dirs is None:
            adjust_dirs = ['left', 'right', 'bottom', 'top']
        for d in adjust_dirs:
            self.append_size(d, Size._AxesDecorationsSize(use_axes, d) + pad)

@_api.deprecated('3.8')
class AxesLocator:

    def __init__(self, axes_divider, nx, ny, nx1=None, ny1=None):
        self._axes_divider = axes_divider
        _xrefindex = axes_divider._xrefindex
        _yrefindex = axes_divider._yrefindex
        (self._nx, self._ny) = (nx - _xrefindex, ny - _yrefindex)
        if nx1 is None:
            nx1 = len(self._axes_divider)
        if ny1 is None:
            ny1 = len(self._axes_divider[0])
        self._nx1 = nx1 - _xrefindex
        self._ny1 = ny1 - _yrefindex

    def __call__(self, axes, renderer):
        _xrefindex = self._axes_divider._xrefindex
        _yrefindex = self._axes_divider._yrefindex
        return self._axes_divider.locate(self._nx + _xrefindex, self._ny + _yrefindex, self._nx1 + _xrefindex, self._ny1 + _yrefindex, axes, renderer)

    def get_subplotspec(self):
        return self._axes_divider.get_subplotspec()

class SubplotDivider(Divider):

    def __init__(self, fig, *args, horizontal=None, vertical=None, aspect=None, anchor='C'):
        self.figure = fig
        super().__init__(fig, [0, 0, 1, 1], horizontal=horizontal or [], vertical=vertical or [], aspect=aspect, anchor=anchor)
        self.set_subplotspec(SubplotSpec._from_subplot_args(fig, args))

    def get_position(self):
        return self.get_subplotspec().get_position(self.figure).bounds

    def get_subplotspec(self):
        return self._subplotspec

    def set_subplotspec(self, subplotspec):
        self._subplotspec = subplotspec
        self.set_position(subplotspec.get_position(self.figure))

class AxesDivider(Divider):

    def __init__(self, axes, xref=None, yref=None):
        self._axes = axes
        if xref is None:
            self._xref = Size.AxesX(axes)
        else:
            self._xref = xref
        if yref is None:
            self._yref = Size.AxesY(axes)
        else:
            self._yref = yref
        super().__init__(fig=axes.get_figure(), pos=None, horizontal=[self._xref], vertical=[self._yref], aspect=None, anchor='C')

    def _get_new_axes(self, *, axes_class=None, **kwargs):
        axes = self._axes
        if axes_class is None:
            axes_class = type(axes)
        return axes_class(axes.get_figure(), axes.get_position(original=True), **kwargs)

    def new_horizontal(self, size, pad=None, pack_start=False, **kwargs):
        if pad is None:
            pad = mpl.rcParams['figure.subplot.wspace'] * self._xref
        pos = 'left' if pack_start else 'right'
        if pad:
            if not isinstance(pad, Size._Base):
                pad = Size.from_any(pad, fraction_ref=self._xref)
            self.append_size(pos, pad)
        if not isinstance(size, Size._Base):
            size = Size.from_any(size, fraction_ref=self._xref)
        self.append_size(pos, size)
        locator = self.new_locator(nx=0 if pack_start else len(self._horizontal) - 1, ny=self._yrefindex)
        ax = self._get_new_axes(**kwargs)
        ax.set_axes_locator(locator)
        return ax

    def new_vertical(self, size, pad=None, pack_start=False, **kwargs):
        if pad is None:
            pad = mpl.rcParams['figure.subplot.hspace'] * self._yref
        pos = 'bottom' if pack_start else 'top'
        if pad:
            if not isinstance(pad, Size._Base):
                pad = Size.from_any(pad, fraction_ref=self._yref)
            self.append_size(pos, pad)
        if not isinstance(size, Size._Base):
            size = Size.from_any(size, fraction_ref=self._yref)
        self.append_size(pos, size)
        locator = self.new_locator(nx=self._xrefindex, ny=0 if pack_start else len(self._vertical) - 1)
        ax = self._get_new_axes(**kwargs)
        ax.set_axes_locator(locator)
        return ax

    def append_axes(self, position, size, pad=None, *, axes_class=None, **kwargs):
        (create_axes, pack_start) = _api.check_getitem({'left': (self.new_horizontal, True), 'right': (self.new_horizontal, False), 'bottom': (self.new_vertical, True), 'top': (self.new_vertical, False)}, position=position)
        ax = create_axes(size, pad, pack_start=pack_start, axes_class=axes_class, **kwargs)
        self._fig.add_axes(ax)
        return ax

    def get_aspect(self):
        if self._aspect is None:
            aspect = self._axes.get_aspect()
            if aspect == 'auto':
                return False
            else:
                return True
        else:
            return self._aspect

    def get_position(self):
        if self._pos is None:
            bbox = self._axes.get_position(original=True)
            return bbox.bounds
        else:
            return self._pos

    def get_anchor(self):
        if self._anchor is None:
            return self._axes.get_anchor()
        else:
            return self._anchor

    def get_subplotspec(self):
        return self._axes.get_subplotspec()

def _locate(x, y, w, h, summed_widths, equal_heights, fig_w, fig_h, anchor):
    total_width = fig_w * w
    max_height = fig_h * h
    n = len(equal_heights)
    (eq_rels, eq_abss) = equal_heights.T
    (sm_rels, sm_abss) = summed_widths.T
    A = np.diag([*eq_rels, 0])
    A[:n, -1] = -1
    A[-1, :-1] = sm_rels
    B = [*-eq_abss, total_width - sm_abss.sum()]
    (*karray, height) = np.linalg.solve(A, B)
    if height > max_height:
        karray = (max_height - eq_abss) / eq_rels
    ox = np.cumsum([0, *sm_rels * karray + sm_abss])
    ww = (ox[-1] - ox[0]) / fig_w
    (h0_rel, h0_abs) = equal_heights[0]
    hh = (karray[0] * h0_rel + h0_abs) / fig_h
    pb = mtransforms.Bbox.from_bounds(x, y, w, h)
    pb1 = mtransforms.Bbox.from_bounds(x, y, ww, hh)
    (x0, y0) = pb1.anchored(anchor, pb).p0
    return (x0, y0, ox, hh)

class HBoxDivider(SubplotDivider):

    def new_locator(self, nx, nx1=None):
        return super().new_locator(nx, 0, nx1, 0)

    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
        nx += self._xrefindex
        nx1 += self._xrefindex
        (fig_w, fig_h) = self._fig.bbox.size / self._fig.dpi
        (x, y, w, h) = self.get_position_runtime(axes, renderer)
        summed_ws = self.get_horizontal_sizes(renderer)
        equal_hs = self.get_vertical_sizes(renderer)
        (x0, y0, ox, hh) = _locate(x, y, w, h, summed_ws, equal_hs, fig_w, fig_h, self.get_anchor())
        if nx1 is None:
            nx1 = -1
        (x1, w1) = (x0 + ox[nx] / fig_w, (ox[nx1] - ox[nx]) / fig_w)
        (y1, h1) = (y0, hh)
        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)

class VBoxDivider(SubplotDivider):

    def new_locator(self, ny, ny1=None):
        return super().new_locator(0, ny, 0, ny1)

    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
        ny += self._yrefindex
        ny1 += self._yrefindex
        (fig_w, fig_h) = self._fig.bbox.size / self._fig.dpi
        (x, y, w, h) = self.get_position_runtime(axes, renderer)
        summed_hs = self.get_vertical_sizes(renderer)
        equal_ws = self.get_horizontal_sizes(renderer)
        (y0, x0, oy, ww) = _locate(y, x, h, w, summed_hs, equal_ws, fig_h, fig_w, self.get_anchor())
        if ny1 is None:
            ny1 = -1
        (x1, w1) = (x0, ww)
        (y1, h1) = (y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h)
        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)

def make_axes_locatable(axes):
    divider = AxesDivider(axes)
    locator = divider.new_locator(nx=0, ny=0)
    axes.set_axes_locator(locator)
    return divider

def make_axes_area_auto_adjustable(ax, use_axes=None, pad=0.1, adjust_dirs=None):
    if adjust_dirs is None:
        adjust_dirs = ['left', 'right', 'bottom', 'top']
    divider = make_axes_locatable(ax)
    if use_axes is None:
        use_axes = ax
    divider.add_auto_adjustable_area(use_axes=use_axes, pad=pad, adjust_dirs=adjust_dirs)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/axes_grid.py
from numbers import Number
import functools
from types import MethodType
import numpy as np
from matplotlib import _api, cbook
from matplotlib.gridspec import SubplotSpec
from .axes_divider import Size, SubplotDivider, Divider
from .mpl_axes import Axes, SimpleAxisArtist

class CbarAxesBase:

    def __init__(self, *args, orientation, **kwargs):
        self.orientation = orientation
        super().__init__(*args, **kwargs)

    def colorbar(self, mappable, **kwargs):
        return self.get_figure(root=False).colorbar(mappable, cax=self, location=self.orientation, **kwargs)

    @_api.deprecated('3.8', alternative='ax.tick_params and colorbar.set_label')
    def toggle_label(self, b):
        axis = self.axis[self.orientation]
        axis.toggle(ticklabels=b, label=b)
_cbaraxes_class_factory = cbook._make_class_factory(CbarAxesBase, 'Cbar{}')

class Grid:
    _defaultAxesClass = Axes

    def __init__(self, fig, rect, nrows_ncols, ngrids=None, direction='row', axes_pad=0.02, *, share_all=False, share_x=True, share_y=True, label_mode='L', axes_class=None, aspect=False):
        (self._nrows, self._ncols) = nrows_ncols
        if ngrids is None:
            ngrids = self._nrows * self._ncols
        elif not 0 < ngrids <= self._nrows * self._ncols:
            raise ValueError('ngrids must be positive and not larger than nrows*ncols')
        self.ngrids = ngrids
        (self._horiz_pad_size, self._vert_pad_size) = map(Size.Fixed, np.broadcast_to(axes_pad, 2))
        _api.check_in_list(['column', 'row'], direction=direction)
        self._direction = direction
        if axes_class is None:
            axes_class = self._defaultAxesClass
        elif isinstance(axes_class, (list, tuple)):
            (cls, kwargs) = axes_class
            axes_class = functools.partial(cls, **kwargs)
        kw = dict(horizontal=[], vertical=[], aspect=aspect)
        if isinstance(rect, (Number, SubplotSpec)):
            self._divider = SubplotDivider(fig, rect, **kw)
        elif len(rect) == 3:
            self._divider = SubplotDivider(fig, *rect, **kw)
        elif len(rect) == 4:
            self._divider = Divider(fig, rect, **kw)
        else:
            raise TypeError('Incorrect rect format')
        rect = self._divider.get_position()
        axes_array = np.full((self._nrows, self._ncols), None, dtype=object)
        for i in range(self.ngrids):
            (col, row) = self._get_col_row(i)
            if share_all:
                sharex = sharey = axes_array[0, 0]
            else:
                sharex = axes_array[0, col] if share_x else None
                sharey = axes_array[row, 0] if share_y else None
            axes_array[row, col] = axes_class(fig, rect, sharex=sharex, sharey=sharey)
        self.axes_all = axes_array.ravel(order='C' if self._direction == 'row' else 'F').tolist()
        self.axes_column = axes_array.T.tolist()
        self.axes_row = axes_array.tolist()
        self.axes_llc = self.axes_column[0][-1]
        self._init_locators()
        for ax in self.axes_all:
            fig.add_axes(ax)
        self.set_label_mode(label_mode)

    def _init_locators(self):
        self._divider.set_horizontal([Size.Scaled(1), self._horiz_pad_size] * (self._ncols - 1) + [Size.Scaled(1)])
        self._divider.set_vertical([Size.Scaled(1), self._vert_pad_size] * (self._nrows - 1) + [Size.Scaled(1)])
        for i in range(self.ngrids):
            (col, row) = self._get_col_row(i)
            self.axes_all[i].set_axes_locator(self._divider.new_locator(nx=2 * col, ny=2 * (self._nrows - 1 - row)))

    def _get_col_row(self, n):
        if self._direction == 'column':
            (col, row) = divmod(n, self._nrows)
        else:
            (row, col) = divmod(n, self._ncols)
        return (col, row)

    def __len__(self):
        return len(self.axes_all)

    def __getitem__(self, i):
        return self.axes_all[i]

    def get_geometry(self):
        return (self._nrows, self._ncols)

    def set_axes_pad(self, axes_pad):
        self._horiz_pad_size.fixed_size = axes_pad[0]
        self._vert_pad_size.fixed_size = axes_pad[1]

    def get_axes_pad(self):
        return (self._horiz_pad_size.fixed_size, self._vert_pad_size.fixed_size)

    def set_aspect(self, aspect):
        self._divider.set_aspect(aspect)

    def get_aspect(self):
        return self._divider.get_aspect()

    def set_label_mode(self, mode):
        _api.check_in_list(['all', 'L', '1', 'keep'], mode=mode)
        (is_last_row, is_first_col) = np.mgrid[:self._nrows, :self._ncols] == [[[self._nrows - 1]], [[0]]]
        if mode == 'all':
            bottom = left = np.full((self._nrows, self._ncols), True)
        elif mode == 'L':
            bottom = is_last_row
            left = is_first_col
        elif mode == '1':
            bottom = left = is_last_row & is_first_col
        else:
            return
        for i in range(self._nrows):
            for j in range(self._ncols):
                ax = self.axes_row[i][j]
                if isinstance(ax.axis, MethodType):
                    bottom_axis = SimpleAxisArtist(ax.xaxis, 1, ax.spines['bottom'])
                    left_axis = SimpleAxisArtist(ax.yaxis, 1, ax.spines['left'])
                else:
                    bottom_axis = ax.axis['bottom']
                    left_axis = ax.axis['left']
                bottom_axis.toggle(ticklabels=bottom[i, j], label=bottom[i, j])
                left_axis.toggle(ticklabels=left[i, j], label=left[i, j])

    def get_divider(self):
        return self._divider

    def set_axes_locator(self, locator):
        self._divider.set_locator(locator)

    def get_axes_locator(self):
        return self._divider.get_locator()

class ImageGrid(Grid):

    def __init__(self, fig, rect, nrows_ncols, ngrids=None, direction='row', axes_pad=0.02, *, share_all=False, aspect=True, label_mode='L', cbar_mode=None, cbar_location='right', cbar_pad=None, cbar_size='5%', cbar_set_cax=True, axes_class=None):
        _api.check_in_list(['each', 'single', 'edge', None], cbar_mode=cbar_mode)
        _api.check_in_list(['left', 'right', 'bottom', 'top'], cbar_location=cbar_location)
        self._colorbar_mode = cbar_mode
        self._colorbar_location = cbar_location
        self._colorbar_pad = cbar_pad
        self._colorbar_size = cbar_size
        super().__init__(fig, rect, nrows_ncols, ngrids, direction=direction, axes_pad=axes_pad, share_all=share_all, share_x=True, share_y=True, aspect=aspect, label_mode=label_mode, axes_class=axes_class)
        for ax in self.cbar_axes:
            fig.add_axes(ax)
        if cbar_set_cax:
            if self._colorbar_mode == 'single':
                for ax in self.axes_all:
                    ax.cax = self.cbar_axes[0]
            elif self._colorbar_mode == 'edge':
                for (index, ax) in enumerate(self.axes_all):
                    (col, row) = self._get_col_row(index)
                    if self._colorbar_location in ('left', 'right'):
                        ax.cax = self.cbar_axes[row]
                    else:
                        ax.cax = self.cbar_axes[col]
            else:
                for (ax, cax) in zip(self.axes_all, self.cbar_axes):
                    ax.cax = cax

    def _init_locators(self):
        if self._colorbar_pad is None:
            if self._colorbar_location in ('left', 'right'):
                self._colorbar_pad = self._horiz_pad_size.fixed_size
            else:
                self._colorbar_pad = self._vert_pad_size.fixed_size
        self.cbar_axes = [_cbaraxes_class_factory(self._defaultAxesClass)(self.axes_all[0].get_figure(root=False), self._divider.get_position(), orientation=self._colorbar_location) for _ in range(self.ngrids)]
        cb_mode = self._colorbar_mode
        cb_location = self._colorbar_location
        h = []
        v = []
        h_ax_pos = []
        h_cb_pos = []
        if cb_mode == 'single' and cb_location in ('left', 'bottom'):
            if cb_location == 'left':
                sz = self._nrows * Size.AxesX(self.axes_llc)
                h.append(Size.from_any(self._colorbar_size, sz))
                h.append(Size.from_any(self._colorbar_pad, sz))
                locator = self._divider.new_locator(nx=0, ny=0, ny1=-1)
            elif cb_location == 'bottom':
                sz = self._ncols * Size.AxesY(self.axes_llc)
                v.append(Size.from_any(self._colorbar_size, sz))
                v.append(Size.from_any(self._colorbar_pad, sz))
                locator = self._divider.new_locator(nx=0, nx1=-1, ny=0)
            for i in range(self.ngrids):
                self.cbar_axes[i].set_visible(False)
            self.cbar_axes[0].set_axes_locator(locator)
            self.cbar_axes[0].set_visible(True)
        for (col, ax) in enumerate(self.axes_row[0]):
            if col != 0:
                h.append(self._horiz_pad_size)
            if ax:
                sz = Size.AxesX(ax, aspect='axes', ref_ax=self.axes_all[0])
            else:
                sz = Size.AxesX(self.axes_all[0], aspect='axes', ref_ax=self.axes_all[0])
            if cb_location == 'left' and (cb_mode == 'each' or (cb_mode == 'edge' and col == 0)):
                h_cb_pos.append(len(h))
                h.append(Size.from_any(self._colorbar_size, sz))
                h.append(Size.from_any(self._colorbar_pad, sz))
            h_ax_pos.append(len(h))
            h.append(sz)
            if cb_location == 'right' and (cb_mode == 'each' or (cb_mode == 'edge' and col == self._ncols - 1)):
                h.append(Size.from_any(self._colorbar_pad, sz))
                h_cb_pos.append(len(h))
                h.append(Size.from_any(self._colorbar_size, sz))
        v_ax_pos = []
        v_cb_pos = []
        for (row, ax) in enumerate(self.axes_column[0][::-1]):
            if row != 0:
                v.append(self._vert_pad_size)
            if ax:
                sz = Size.AxesY(ax, aspect='axes', ref_ax=self.axes_all[0])
            else:
                sz = Size.AxesY(self.axes_all[0], aspect='axes', ref_ax=self.axes_all[0])
            if cb_location == 'bottom' and (cb_mode == 'each' or (cb_mode == 'edge' and row == 0)):
                v_cb_pos.append(len(v))
                v.append(Size.from_any(self._colorbar_size, sz))
                v.append(Size.from_any(self._colorbar_pad, sz))
            v_ax_pos.append(len(v))
            v.append(sz)
            if cb_location == 'top' and (cb_mode == 'each' or (cb_mode == 'edge' and row == self._nrows - 1)):
                v.append(Size.from_any(self._colorbar_pad, sz))
                v_cb_pos.append(len(v))
                v.append(Size.from_any(self._colorbar_size, sz))
        for i in range(self.ngrids):
            (col, row) = self._get_col_row(i)
            locator = self._divider.new_locator(nx=h_ax_pos[col], ny=v_ax_pos[self._nrows - 1 - row])
            self.axes_all[i].set_axes_locator(locator)
            if cb_mode == 'each':
                if cb_location in ('right', 'left'):
                    locator = self._divider.new_locator(nx=h_cb_pos[col], ny=v_ax_pos[self._nrows - 1 - row])
                elif cb_location in ('top', 'bottom'):
                    locator = self._divider.new_locator(nx=h_ax_pos[col], ny=v_cb_pos[self._nrows - 1 - row])
                self.cbar_axes[i].set_axes_locator(locator)
            elif cb_mode == 'edge':
                if cb_location == 'left' and col == 0 or (cb_location == 'right' and col == self._ncols - 1):
                    locator = self._divider.new_locator(nx=h_cb_pos[0], ny=v_ax_pos[self._nrows - 1 - row])
                    self.cbar_axes[row].set_axes_locator(locator)
                elif cb_location == 'bottom' and row == self._nrows - 1 or (cb_location == 'top' and row == 0):
                    locator = self._divider.new_locator(nx=h_ax_pos[col], ny=v_cb_pos[0])
                    self.cbar_axes[col].set_axes_locator(locator)
        if cb_mode == 'single':
            if cb_location == 'right':
                sz = self._nrows * Size.AxesX(self.axes_llc)
                h.append(Size.from_any(self._colorbar_pad, sz))
                h.append(Size.from_any(self._colorbar_size, sz))
                locator = self._divider.new_locator(nx=-2, ny=0, ny1=-1)
            elif cb_location == 'top':
                sz = self._ncols * Size.AxesY(self.axes_llc)
                v.append(Size.from_any(self._colorbar_pad, sz))
                v.append(Size.from_any(self._colorbar_size, sz))
                locator = self._divider.new_locator(nx=0, nx1=-1, ny=-2)
            if cb_location in ('right', 'top'):
                for i in range(self.ngrids):
                    self.cbar_axes[i].set_visible(False)
                self.cbar_axes[0].set_axes_locator(locator)
                self.cbar_axes[0].set_visible(True)
        elif cb_mode == 'each':
            for i in range(self.ngrids):
                self.cbar_axes[i].set_visible(True)
        elif cb_mode == 'edge':
            if cb_location in ('right', 'left'):
                count = self._nrows
            else:
                count = self._ncols
            for i in range(count):
                self.cbar_axes[i].set_visible(True)
            for j in range(i + 1, self.ngrids):
                self.cbar_axes[j].set_visible(False)
        else:
            for i in range(self.ngrids):
                self.cbar_axes[i].set_visible(False)
                self.cbar_axes[i].set_position([1.0, 1.0, 0.001, 0.001], which='active')
        self._divider.set_horizontal(h)
        self._divider.set_vertical(v)
AxesGrid = ImageGrid

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/axes_rgb.py
from types import MethodType
import numpy as np
from .axes_divider import make_axes_locatable, Size
from .mpl_axes import Axes, SimpleAxisArtist

def make_rgb_axes(ax, pad=0.01, axes_class=None, **kwargs):
    divider = make_axes_locatable(ax)
    pad_size = pad * Size.AxesY(ax)
    xsize = (1 - 2 * pad) / 3 * Size.AxesX(ax)
    ysize = (1 - 2 * pad) / 3 * Size.AxesY(ax)
    divider.set_horizontal([Size.AxesX(ax), pad_size, xsize])
    divider.set_vertical([ysize, pad_size, ysize, pad_size, ysize])
    ax.set_axes_locator(divider.new_locator(0, 0, ny1=-1))
    ax_rgb = []
    if axes_class is None:
        axes_class = type(ax)
    for ny in [4, 2, 0]:
        ax1 = axes_class(ax.get_figure(), ax.get_position(original=True), sharex=ax, sharey=ax, **kwargs)
        locator = divider.new_locator(nx=2, ny=ny)
        ax1.set_axes_locator(locator)
        for t in ax1.yaxis.get_ticklabels() + ax1.xaxis.get_ticklabels():
            t.set_visible(False)
        try:
            for axis in ax1.axis.values():
                axis.major_ticklabels.set_visible(False)
        except AttributeError:
            pass
        ax_rgb.append(ax1)
    fig = ax.get_figure()
    for ax1 in ax_rgb:
        fig.add_axes(ax1)
    return ax_rgb

class RGBAxes:
    _defaultAxesClass = Axes

    def __init__(self, *args, pad=0, **kwargs):
        axes_class = kwargs.pop('axes_class', self._defaultAxesClass)
        self.RGB = ax = axes_class(*args, **kwargs)
        ax.get_figure().add_axes(ax)
        (self.R, self.G, self.B) = make_rgb_axes(ax, pad=pad, axes_class=axes_class, **kwargs)
        for ax1 in [self.RGB, self.R, self.G, self.B]:
            if isinstance(ax1.axis, MethodType):
                ad = Axes.AxisDict(self)
                ad.update(bottom=SimpleAxisArtist(ax1.xaxis, 1, ax1.spines['bottom']), top=SimpleAxisArtist(ax1.xaxis, 2, ax1.spines['top']), left=SimpleAxisArtist(ax1.yaxis, 1, ax1.spines['left']), right=SimpleAxisArtist(ax1.yaxis, 2, ax1.spines['right']))
            else:
                ad = ax1.axis
            ad[:].line.set_color('w')
            ad[:].major_ticks.set_markeredgecolor('w')

    def imshow_rgb(self, r, g, b, **kwargs):
        if not r.shape == g.shape == b.shape:
            raise ValueError(f'Input shapes ({r.shape}, {g.shape}, {b.shape}) do not match')
        RGB = np.dstack([r, g, b])
        R = np.zeros_like(RGB)
        R[:, :, 0] = r
        G = np.zeros_like(RGB)
        G[:, :, 1] = g
        B = np.zeros_like(RGB)
        B[:, :, 2] = b
        im_rgb = self.RGB.imshow(RGB, **kwargs)
        im_r = self.R.imshow(R, **kwargs)
        im_g = self.G.imshow(G, **kwargs)
        im_b = self.B.imshow(B, **kwargs)
        return (im_rgb, im_r, im_g, im_b)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/axes_size.py
""""""
from numbers import Real
from matplotlib import _api
from matplotlib.axes import Axes

class _Base:

    def __rmul__(self, other):
        return self * other

    def __mul__(self, other):
        if not isinstance(other, Real):
            return NotImplemented
        return Fraction(other, self)

    def __div__(self, other):
        return 1 / other * self

    def __add__(self, other):
        if isinstance(other, _Base):
            return Add(self, other)
        else:
            return Add(self, Fixed(other))

    def __neg__(self):
        return -1 * self

    def __radd__(self, other):
        return Add(self, Fixed(other))

    def __sub__(self, other):
        return self + -other

    def get_size(self, renderer):
        raise NotImplementedError('Subclasses must implement')

class Add(_Base):

    def __init__(self, a, b):
        self._a = a
        self._b = b

    def get_size(self, renderer):
        (a_rel_size, a_abs_size) = self._a.get_size(renderer)
        (b_rel_size, b_abs_size) = self._b.get_size(renderer)
        return (a_rel_size + b_rel_size, a_abs_size + b_abs_size)

class Fixed(_Base):

    def __init__(self, fixed_size):
        _api.check_isinstance(Real, fixed_size=fixed_size)
        self.fixed_size = fixed_size

    def get_size(self, renderer):
        rel_size = 0.0
        abs_size = self.fixed_size
        return (rel_size, abs_size)

class Scaled(_Base):

    def __init__(self, scalable_size):
        self._scalable_size = scalable_size

    def get_size(self, renderer):
        rel_size = self._scalable_size
        abs_size = 0.0
        return (rel_size, abs_size)
Scalable = Scaled

def _get_axes_aspect(ax):
    aspect = ax.get_aspect()
    if aspect == 'auto':
        aspect = 1.0
    return aspect

class AxesX(_Base):

    def __init__(self, axes, aspect=1.0, ref_ax=None):
        self._axes = axes
        self._aspect = aspect
        if aspect == 'axes' and ref_ax is None:
            raise ValueError("ref_ax must be set when aspect='axes'")
        self._ref_ax = ref_ax

    def get_size(self, renderer):
        (l1, l2) = self._axes.get_xlim()
        if self._aspect == 'axes':
            ref_aspect = _get_axes_aspect(self._ref_ax)
            aspect = ref_aspect / _get_axes_aspect(self._axes)
        else:
            aspect = self._aspect
        rel_size = abs(l2 - l1) * aspect
        abs_size = 0.0
        return (rel_size, abs_size)

class AxesY(_Base):

    def __init__(self, axes, aspect=1.0, ref_ax=None):
        self._axes = axes
        self._aspect = aspect
        if aspect == 'axes' and ref_ax is None:
            raise ValueError("ref_ax must be set when aspect='axes'")
        self._ref_ax = ref_ax

    def get_size(self, renderer):
        (l1, l2) = self._axes.get_ylim()
        if self._aspect == 'axes':
            ref_aspect = _get_axes_aspect(self._ref_ax)
            aspect = _get_axes_aspect(self._axes)
        else:
            aspect = self._aspect
        rel_size = abs(l2 - l1) * aspect
        abs_size = 0.0
        return (rel_size, abs_size)

class MaxExtent(_Base):

    def __init__(self, artist_list, w_or_h):
        self._artist_list = artist_list
        _api.check_in_list(['width', 'height'], w_or_h=w_or_h)
        self._w_or_h = w_or_h

    def add_artist(self, a):
        self._artist_list.append(a)

    def get_size(self, renderer):
        rel_size = 0.0
        extent_list = [getattr(a.get_window_extent(renderer), self._w_or_h) / a.figure.dpi for a in self._artist_list]
        abs_size = max(extent_list, default=0)
        return (rel_size, abs_size)

class MaxWidth(MaxExtent):

    def __init__(self, artist_list):
        super().__init__(artist_list, 'width')

class MaxHeight(MaxExtent):

    def __init__(self, artist_list):
        super().__init__(artist_list, 'height')

class Fraction(_Base):

    def __init__(self, fraction, ref_size):
        _api.check_isinstance(Real, fraction=fraction)
        self._fraction_ref = ref_size
        self._fraction = fraction

    def get_size(self, renderer):
        if self._fraction_ref is None:
            return (self._fraction, 0.0)
        else:
            (r, a) = self._fraction_ref.get_size(renderer)
            rel_size = r * self._fraction
            abs_size = a * self._fraction
            return (rel_size, abs_size)

def from_any(size, fraction_ref=None):
    if isinstance(size, Real):
        return Fixed(size)
    elif isinstance(size, str):
        if size[-1] == '%':
            return Fraction(float(size[:-1]) / 100, fraction_ref)
    raise ValueError('Unknown format')

class _AxesDecorationsSize(_Base):
    _get_size_map = {'left': lambda tight_bb, axes_bb: axes_bb.xmin - tight_bb.xmin, 'right': lambda tight_bb, axes_bb: tight_bb.xmax - axes_bb.xmax, 'bottom': lambda tight_bb, axes_bb: axes_bb.ymin - tight_bb.ymin, 'top': lambda tight_bb, axes_bb: tight_bb.ymax - axes_bb.ymax}

    def __init__(self, ax, direction):
        _api.check_in_list(self._get_size_map, direction=direction)
        self._direction = direction
        self._ax_list = [ax] if isinstance(ax, Axes) else ax

    def get_size(self, renderer):
        sz = max([self._get_size_map[self._direction](ax.get_tightbbox(renderer, call_axes_locator=False), ax.bbox) for ax in self._ax_list])
        dpi = renderer.points_to_pixels(72)
        abs_size = sz / dpi
        rel_size = 0
        return (rel_size, abs_size)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/inset_locator.py
""""""
from matplotlib import _api, _docstring
from matplotlib.offsetbox import AnchoredOffsetbox
from matplotlib.patches import Patch, Rectangle
from matplotlib.path import Path
from matplotlib.transforms import Bbox, BboxTransformTo
from matplotlib.transforms import IdentityTransform, TransformedBbox
from . import axes_size as Size
from .parasite_axes import HostAxes

@_api.deprecated('3.8', alternative='Axes.inset_axes')
class InsetPosition:

    @_docstring.dedent_interpd
    def __init__(self, parent, lbwh):
        self.parent = parent
        self.lbwh = lbwh

    def __call__(self, ax, renderer):
        bbox_parent = self.parent.get_position(original=False)
        trans = BboxTransformTo(bbox_parent)
        bbox_inset = Bbox.from_bounds(*self.lbwh)
        bb = TransformedBbox(bbox_inset, trans)
        return bb

class AnchoredLocatorBase(AnchoredOffsetbox):

    def __init__(self, bbox_to_anchor, offsetbox, loc, borderpad=0.5, bbox_transform=None):
        super().__init__(loc, pad=0.0, child=None, borderpad=borderpad, bbox_to_anchor=bbox_to_anchor, bbox_transform=bbox_transform)

    def draw(self, renderer):
        raise RuntimeError('No draw method should be called')

    def __call__(self, ax, renderer):
        fig = ax.get_figure(root=False)
        if renderer is None:
            renderer = fig._get_renderer()
        self.axes = ax
        bbox = self.get_window_extent(renderer)
        (px, py) = self.get_offset(bbox.width, bbox.height, 0, 0, renderer)
        bbox_canvas = Bbox.from_bounds(px, py, bbox.width, bbox.height)
        tr = fig.transSubfigure.inverted()
        return TransformedBbox(bbox_canvas, tr)

class AnchoredSizeLocator(AnchoredLocatorBase):

    def __init__(self, bbox_to_anchor, x_size, y_size, loc, borderpad=0.5, bbox_transform=None):
        super().__init__(bbox_to_anchor, None, loc, borderpad=borderpad, bbox_transform=bbox_transform)
        self.x_size = Size.from_any(x_size)
        self.y_size = Size.from_any(y_size)

    def get_bbox(self, renderer):
        bbox = self.get_bbox_to_anchor()
        dpi = renderer.points_to_pixels(72.0)
        (r, a) = self.x_size.get_size(renderer)
        width = bbox.width * r + a * dpi
        (r, a) = self.y_size.get_size(renderer)
        height = bbox.height * r + a * dpi
        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
        pad = self.pad * fontsize
        return Bbox.from_bounds(0, 0, width, height).padded(pad)

class AnchoredZoomLocator(AnchoredLocatorBase):

    def __init__(self, parent_axes, zoom, loc, borderpad=0.5, bbox_to_anchor=None, bbox_transform=None):
        self.parent_axes = parent_axes
        self.zoom = zoom
        if bbox_to_anchor is None:
            bbox_to_anchor = parent_axes.bbox
        super().__init__(bbox_to_anchor, None, loc, borderpad=borderpad, bbox_transform=bbox_transform)

    def get_bbox(self, renderer):
        bb = self.parent_axes.transData.transform_bbox(self.axes.viewLim)
        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
        pad = self.pad * fontsize
        return Bbox.from_bounds(0, 0, abs(bb.width * self.zoom), abs(bb.height * self.zoom)).padded(pad)

class BboxPatch(Patch):

    @_docstring.dedent_interpd
    def __init__(self, bbox, **kwargs):
        if 'transform' in kwargs:
            raise ValueError('transform should not be set')
        kwargs['transform'] = IdentityTransform()
        super().__init__(**kwargs)
        self.bbox = bbox

    def get_path(self):
        (x0, y0, x1, y1) = self.bbox.extents
        return Path._create_closed([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])

class BboxConnector(Patch):

    @staticmethod
    def get_bbox_edge_pos(bbox, loc):
        (x0, y0, x1, y1) = bbox.extents
        if loc == 1:
            return (x1, y1)
        elif loc == 2:
            return (x0, y1)
        elif loc == 3:
            return (x0, y0)
        elif loc == 4:
            return (x1, y0)

    @staticmethod
    def connect_bbox(bbox1, bbox2, loc1, loc2=None):
        if isinstance(bbox1, Rectangle):
            bbox1 = TransformedBbox(Bbox.unit(), bbox1.get_transform())
        if isinstance(bbox2, Rectangle):
            bbox2 = TransformedBbox(Bbox.unit(), bbox2.get_transform())
        if loc2 is None:
            loc2 = loc1
        (x1, y1) = BboxConnector.get_bbox_edge_pos(bbox1, loc1)
        (x2, y2) = BboxConnector.get_bbox_edge_pos(bbox2, loc2)
        return Path([[x1, y1], [x2, y2]])

    @_docstring.dedent_interpd
    def __init__(self, bbox1, bbox2, loc1, loc2=None, **kwargs):
        if 'transform' in kwargs:
            raise ValueError('transform should not be set')
        kwargs['transform'] = IdentityTransform()
        kwargs.setdefault('fill', bool({'fc', 'facecolor', 'color'}.intersection(kwargs)))
        super().__init__(**kwargs)
        self.bbox1 = bbox1
        self.bbox2 = bbox2
        self.loc1 = loc1
        self.loc2 = loc2

    def get_path(self):
        return self.connect_bbox(self.bbox1, self.bbox2, self.loc1, self.loc2)

class BboxConnectorPatch(BboxConnector):

    @_docstring.dedent_interpd
    def __init__(self, bbox1, bbox2, loc1a, loc2a, loc1b, loc2b, **kwargs):
        if 'transform' in kwargs:
            raise ValueError('transform should not be set')
        super().__init__(bbox1, bbox2, loc1a, loc2a, **kwargs)
        self.loc1b = loc1b
        self.loc2b = loc2b

    def get_path(self):
        path1 = self.connect_bbox(self.bbox1, self.bbox2, self.loc1, self.loc2)
        path2 = self.connect_bbox(self.bbox2, self.bbox1, self.loc2b, self.loc1b)
        path_merged = [*path1.vertices, *path2.vertices, path1.vertices[0]]
        return Path(path_merged)

def _add_inset_axes(parent_axes, axes_class, axes_kwargs, axes_locator):
    if axes_class is None:
        axes_class = HostAxes
    if axes_kwargs is None:
        axes_kwargs = {}
    fig = parent_axes.get_figure(root=False)
    inset_axes = axes_class(fig, parent_axes.get_position(), **{'navigate': False, **axes_kwargs, 'axes_locator': axes_locator})
    return fig.add_axes(inset_axes)

@_docstring.dedent_interpd
def inset_axes(parent_axes, width, height, loc='upper right', bbox_to_anchor=None, bbox_transform=None, axes_class=None, axes_kwargs=None, borderpad=0.5):
    if bbox_transform in [parent_axes.transAxes, parent_axes.get_figure(root=False).transFigure] and bbox_to_anchor is None:
        _api.warn_external('Using the axes or figure transform requires a bounding box in the respective coordinates. Using bbox_to_anchor=(0, 0, 1, 1) now.')
        bbox_to_anchor = (0, 0, 1, 1)
    if bbox_to_anchor is None:
        bbox_to_anchor = parent_axes.bbox
    if isinstance(bbox_to_anchor, tuple) and (isinstance(width, str) or isinstance(height, str)):
        if len(bbox_to_anchor) != 4:
            raise ValueError('Using relative units for width or height requires to provide a 4-tuple or a `Bbox` instance to `bbox_to_anchor.')
    return _add_inset_axes(parent_axes, axes_class, axes_kwargs, AnchoredSizeLocator(bbox_to_anchor, width, height, loc=loc, bbox_transform=bbox_transform, borderpad=borderpad))

@_docstring.dedent_interpd
def zoomed_inset_axes(parent_axes, zoom, loc='upper right', bbox_to_anchor=None, bbox_transform=None, axes_class=None, axes_kwargs=None, borderpad=0.5):
    return _add_inset_axes(parent_axes, axes_class, axes_kwargs, AnchoredZoomLocator(parent_axes, zoom=zoom, loc=loc, bbox_to_anchor=bbox_to_anchor, bbox_transform=bbox_transform, borderpad=borderpad))

class _TransformedBboxWithCallback(TransformedBbox):

    def __init__(self, *args, callback, **kwargs):
        super().__init__(*args, **kwargs)
        self._callback = callback

    def get_points(self):
        self._callback()
        return super().get_points()

@_docstring.dedent_interpd
def mark_inset(parent_axes, inset_axes, loc1, loc2, **kwargs):
    rect = _TransformedBboxWithCallback(inset_axes.viewLim, parent_axes.transData, callback=parent_axes._unstale_viewLim)
    kwargs.setdefault('fill', bool({'fc', 'facecolor', 'color'}.intersection(kwargs)))
    pp = BboxPatch(rect, **kwargs)
    parent_axes.add_patch(pp)
    p1 = BboxConnector(inset_axes.bbox, rect, loc1=loc1, **kwargs)
    inset_axes.add_patch(p1)
    p1.set_clip_on(False)
    p2 = BboxConnector(inset_axes.bbox, rect, loc1=loc2, **kwargs)
    inset_axes.add_patch(p2)
    p2.set_clip_on(False)
    return (pp, p1, p2)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/mpl_axes.py
import matplotlib.axes as maxes
from matplotlib.artist import Artist
from matplotlib.axis import XAxis, YAxis

class SimpleChainedObjects:

    def __init__(self, objects):
        self._objects = objects

    def __getattr__(self, k):
        _a = SimpleChainedObjects([getattr(a, k) for a in self._objects])
        return _a

    def __call__(self, *args, **kwargs):
        for m in self._objects:
            m(*args, **kwargs)

class Axes(maxes.Axes):

    class AxisDict(dict):

        def __init__(self, axes):
            self.axes = axes
            super().__init__()

        def __getitem__(self, k):
            if isinstance(k, tuple):
                r = SimpleChainedObjects([super(Axes.AxisDict, self).__getitem__(k1) for k1 in k])
                return r
            elif isinstance(k, slice):
                if k.start is None and k.stop is None and (k.step is None):
                    return SimpleChainedObjects(list(self.values()))
                else:
                    raise ValueError('Unsupported slice')
            else:
                return dict.__getitem__(self, k)

        def __call__(self, *v, **kwargs):
            return maxes.Axes.axis(self.axes, *v, **kwargs)

    @property
    def axis(self):
        return self._axislines

    def clear(self):
        super().clear()
        self._axislines = self.AxisDict(self)
        self._axislines.update(bottom=SimpleAxisArtist(self.xaxis, 1, self.spines['bottom']), top=SimpleAxisArtist(self.xaxis, 2, self.spines['top']), left=SimpleAxisArtist(self.yaxis, 1, self.spines['left']), right=SimpleAxisArtist(self.yaxis, 2, self.spines['right']))

class SimpleAxisArtist(Artist):

    def __init__(self, axis, axisnum, spine):
        self._axis = axis
        self._axisnum = axisnum
        self.line = spine
        if isinstance(axis, XAxis):
            self._axis_direction = ['bottom', 'top'][axisnum - 1]
        elif isinstance(axis, YAxis):
            self._axis_direction = ['left', 'right'][axisnum - 1]
        else:
            raise ValueError(f'axis must be instance of XAxis or YAxis, but got {axis}')
        super().__init__()

    @property
    def major_ticks(self):
        tickline = 'tick%dline' % self._axisnum
        return SimpleChainedObjects([getattr(tick, tickline) for tick in self._axis.get_major_ticks()])

    @property
    def major_ticklabels(self):
        label = 'label%d' % self._axisnum
        return SimpleChainedObjects([getattr(tick, label) for tick in self._axis.get_major_ticks()])

    @property
    def label(self):
        return self._axis.label

    def set_visible(self, b):
        self.toggle(all=b)
        self.line.set_visible(b)
        self._axis.set_visible(True)
        super().set_visible(b)

    def set_label(self, txt):
        self._axis.set_label_text(txt)

    def toggle(self, all=None, ticks=None, ticklabels=None, label=None):
        if all:
            (_ticks, _ticklabels, _label) = (True, True, True)
        elif all is not None:
            (_ticks, _ticklabels, _label) = (False, False, False)
        else:
            (_ticks, _ticklabels, _label) = (None, None, None)
        if ticks is not None:
            _ticks = ticks
        if ticklabels is not None:
            _ticklabels = ticklabels
        if label is not None:
            _label = label
        if _ticks is not None:
            tickparam = {f'tick{self._axisnum}On': _ticks}
            self._axis.set_tick_params(**tickparam)
        if _ticklabels is not None:
            tickparam = {f'label{self._axisnum}On': _ticklabels}
            self._axis.set_tick_params(**tickparam)
        if _label is not None:
            pos = self._axis.get_label_position()
            if pos == self._axis_direction and (not _label):
                self._axis.label.set_visible(False)
            elif _label:
                self._axis.label.set_visible(True)
                self._axis.set_label_position(self._axis_direction)

# File: matplotlib-main/lib/mpl_toolkits/axes_grid1/parasite_axes.py
from matplotlib import _api, cbook
import matplotlib.artist as martist
import matplotlib.transforms as mtransforms
from matplotlib.transforms import Bbox
from .mpl_axes import Axes

class ParasiteAxesBase:

    def __init__(self, parent_axes, aux_transform=None, *, viewlim_mode=None, **kwargs):
        self._parent_axes = parent_axes
        self.transAux = aux_transform
        self.set_viewlim_mode(viewlim_mode)
        kwargs['frameon'] = False
        super().__init__(parent_axes.get_figure(root=False), parent_axes._position, **kwargs)

    def clear(self):
        super().clear()
        martist.setp(self.get_children(), visible=False)
        self._get_lines = self._parent_axes._get_lines
        self._parent_axes.callbacks._connect_picklable('xlim_changed', self._sync_lims)
        self._parent_axes.callbacks._connect_picklable('ylim_changed', self._sync_lims)

    def pick(self, mouseevent):
        super().pick(mouseevent)
        for a in self.get_children():
            if hasattr(mouseevent.inaxes, 'parasites') and self in mouseevent.inaxes.parasites:
                a.pick(mouseevent)

    def _set_lim_and_transforms(self):
        if self.transAux is not None:
            self.transAxes = self._parent_axes.transAxes
            self.transData = self.transAux + self._parent_axes.transData
            self._xaxis_transform = mtransforms.blended_transform_factory(self.transData, self.transAxes)
            self._yaxis_transform = mtransforms.blended_transform_factory(self.transAxes, self.transData)
        else:
            super()._set_lim_and_transforms()

    def set_viewlim_mode(self, mode):
        _api.check_in_list([None, 'equal', 'transform'], mode=mode)
        self._viewlim_mode = mode

    def get_viewlim_mode(self):
        return self._viewlim_mode

    def _sync_lims(self, parent):
        viewlim = parent.viewLim.frozen()
        mode = self.get_viewlim_mode()
        if mode is None:
            pass
        elif mode == 'equal':
            self.viewLim.set(viewlim)
        elif mode == 'transform':
            self.viewLim.set(viewlim.transformed(self.transAux.inverted()))
        else:
            _api.check_in_list([None, 'equal', 'transform'], mode=mode)
parasite_axes_class_factory = cbook._make_class_factory(ParasiteAxesBase, '{}Parasite')
ParasiteAxes = parasite_axes_class_factory(Axes)

class HostAxesBase:

    def __init__(self, *args, **kwargs):
        self.parasites = []
        super().__init__(*args, **kwargs)

    def get_aux_axes(self, tr=None, viewlim_mode='equal', axes_class=None, **kwargs):
        if axes_class is None:
            axes_class = self._base_axes_class
        parasite_axes_class = parasite_axes_class_factory(axes_class)
        ax2 = parasite_axes_class(self, tr, viewlim_mode=viewlim_mode, **kwargs)
        self.parasites.append(ax2)
        ax2._remove_method = self.parasites.remove
        return ax2

    def draw(self, renderer):
        orig_children_len = len(self._children)
        locator = self.get_axes_locator()
        if locator:
            pos = locator(self, renderer)
            self.set_position(pos, which='active')
            self.apply_aspect(pos)
        else:
            self.apply_aspect()
        rect = self.get_position()
        for ax in self.parasites:
            ax.apply_aspect(rect)
            self._children.extend(ax.get_children())
        super().draw(renderer)
        del self._children[orig_children_len:]

    def clear(self):
        super().clear()
        for ax in self.parasites:
            ax.clear()

    def pick(self, mouseevent):
        super().pick(mouseevent)
        for a in self.parasites:
            a.pick(mouseevent)

    def twinx(self, axes_class=None):
        ax = self._add_twin_axes(axes_class, sharex=self)
        self.axis['right'].set_visible(False)
        ax.axis['right'].set_visible(True)
        ax.axis['left', 'top', 'bottom'].set_visible(False)
        return ax

    def twiny(self, axes_class=None):
        ax = self._add_twin_axes(axes_class, sharey=self)
        self.axis['top'].set_visible(False)
        ax.axis['top'].set_visible(True)
        ax.axis['left', 'right', 'bottom'].set_visible(False)
        return ax

    def twin(self, aux_trans=None, axes_class=None):
        if aux_trans is None:
            aux_trans = mtransforms.IdentityTransform()
        ax = self._add_twin_axes(axes_class, aux_transform=aux_trans, viewlim_mode='transform')
        self.axis['top', 'right'].set_visible(False)
        ax.axis['top', 'right'].set_visible(True)
        ax.axis['left', 'bottom'].set_visible(False)
        return ax

    def _add_twin_axes(self, axes_class, **kwargs):
        if axes_class is None:
            axes_class = self._base_axes_class
        ax = parasite_axes_class_factory(axes_class)(self, **kwargs)
        self.parasites.append(ax)
        ax._remove_method = self._remove_any_twin
        return ax

    def _remove_any_twin(self, ax):
        self.parasites.remove(ax)
        restore = ['top', 'right']
        if ax._sharex:
            restore.remove('top')
        if ax._sharey:
            restore.remove('right')
        self.axis[tuple(restore)].set_visible(True)
        self.axis[tuple(restore)].toggle(ticklabels=False, label=False)

    def get_tightbbox(self, renderer=None, *, call_axes_locator=True, bbox_extra_artists=None):
        bbs = [*[ax.get_tightbbox(renderer, call_axes_locator=call_axes_locator) for ax in self.parasites], super().get_tightbbox(renderer, call_axes_locator=call_axes_locator, bbox_extra_artists=bbox_extra_artists)]
        return Bbox.union([b for b in bbs if b.width != 0 or b.height != 0])
host_axes_class_factory = host_subplot_class_factory = cbook._make_class_factory(HostAxesBase, '{}HostAxes', '_base_axes_class')
HostAxes = SubplotHost = host_axes_class_factory(Axes)

def host_axes(*args, axes_class=Axes, figure=None, **kwargs):
    import matplotlib.pyplot as plt
    host_axes_class = host_axes_class_factory(axes_class)
    if figure is None:
        figure = plt.gcf()
    ax = host_axes_class(figure, *args, **kwargs)
    figure.add_axes(ax)
    return ax
host_subplot = host_axes

# File: matplotlib-main/lib/mpl_toolkits/axisartist/__init__.py
from .axislines import Axes
from .axislines import AxesZero, AxisArtistHelper, AxisArtistHelperRectlinear, GridHelperBase, GridHelperRectlinear, Subplot, SubplotZero
from .axis_artist import AxisArtist, GridlinesCollection
from .grid_helper_curvelinear import GridHelperCurveLinear
from .floating_axes import FloatingAxes, FloatingSubplot
from mpl_toolkits.axes_grid1.parasite_axes import host_axes_class_factory, parasite_axes_class_factory
ParasiteAxes = parasite_axes_class_factory(Axes)
HostAxes = host_axes_class_factory(Axes)
SubplotHost = HostAxes

# File: matplotlib-main/lib/mpl_toolkits/axisartist/angle_helper.py
import numpy as np
import math
from mpl_toolkits.axisartist.grid_finder import ExtremeFinderSimple

def select_step_degree(dv):
    degree_limits_ = [1.5, 3, 7, 13, 20, 40, 70, 120, 270, 520]
    degree_steps_ = [1, 2, 5, 10, 15, 30, 45, 90, 180, 360]
    degree_factors = [1.0] * len(degree_steps_)
    minsec_limits_ = [1.5, 2.5, 3.5, 8, 11, 18, 25, 45]
    minsec_steps_ = [1, 2, 3, 5, 10, 15, 20, 30]
    minute_limits_ = np.array(minsec_limits_) / 60
    minute_factors = [60.0] * len(minute_limits_)
    second_limits_ = np.array(minsec_limits_) / 3600
    second_factors = [3600.0] * len(second_limits_)
    degree_limits = [*second_limits_, *minute_limits_, *degree_limits_]
    degree_steps = [*minsec_steps_, *minsec_steps_, *degree_steps_]
    degree_factors = [*second_factors, *minute_factors, *degree_factors]
    n = np.searchsorted(degree_limits, dv)
    step = degree_steps[n]
    factor = degree_factors[n]
    return (step, factor)

def select_step_hour(dv):
    hour_limits_ = [1.5, 2.5, 3.5, 5, 7, 10, 15, 21, 36]
    hour_steps_ = [1, 2, 3, 4, 6, 8, 12, 18, 24]
    hour_factors = [1.0] * len(hour_steps_)
    minsec_limits_ = [1.5, 2.5, 3.5, 4.5, 5.5, 8, 11, 14, 18, 25, 45]
    minsec_steps_ = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30]
    minute_limits_ = np.array(minsec_limits_) / 60
    minute_factors = [60.0] * len(minute_limits_)
    second_limits_ = np.array(minsec_limits_) / 3600
    second_factors = [3600.0] * len(second_limits_)
    hour_limits = [*second_limits_, *minute_limits_, *hour_limits_]
    hour_steps = [*minsec_steps_, *minsec_steps_, *hour_steps_]
    hour_factors = [*second_factors, *minute_factors, *hour_factors]
    n = np.searchsorted(hour_limits, dv)
    step = hour_steps[n]
    factor = hour_factors[n]
    return (step, factor)

def select_step_sub(dv):
    tmp = 10.0 ** (int(math.log10(dv)) - 1.0)
    factor = 1.0 / tmp
    if 1.5 * tmp >= dv:
        step = 1
    elif 3.0 * tmp >= dv:
        step = 2
    elif 7.0 * tmp >= dv:
        step = 5
    else:
        step = 1
        factor = 0.1 * factor
    return (step, factor)

def select_step(v1, v2, nv, hour=False, include_last=True, threshold_factor=3600.0):
    if v1 > v2:
        (v1, v2) = (v2, v1)
    dv = (v2 - v1) / nv
    if hour:
        _select_step = select_step_hour
        cycle = 24.0
    else:
        _select_step = select_step_degree
        cycle = 360.0
    if dv > 1 / threshold_factor:
        (step, factor) = _select_step(dv)
    else:
        (step, factor) = select_step_sub(dv * threshold_factor)
        factor = factor * threshold_factor
    levs = np.arange(np.floor(v1 * factor / step), np.ceil(v2 * factor / step) + 0.5, dtype=int) * step
    n = len(levs)
    if factor == 1.0 and levs[-1] >= levs[0] + cycle:
        nv = int(cycle / step)
        if include_last:
            levs = levs[0] + np.arange(0, nv + 1, 1) * step
        else:
            levs = levs[0] + np.arange(0, nv, 1) * step
        n = len(levs)
    return (np.array(levs), n, factor)

def select_step24(v1, v2, nv, include_last=True, threshold_factor=3600):
    (v1, v2) = (v1 / 15, v2 / 15)
    (levs, n, factor) = select_step(v1, v2, nv, hour=True, include_last=include_last, threshold_factor=threshold_factor)
    return (levs * 15, n, factor)

def select_step360(v1, v2, nv, include_last=True, threshold_factor=3600):
    return select_step(v1, v2, nv, hour=False, include_last=include_last, threshold_factor=threshold_factor)

class LocatorBase:

    def __init__(self, nbins, include_last=True):
        self.nbins = nbins
        self._include_last = include_last

    def set_params(self, nbins=None):
        if nbins is not None:
            self.nbins = int(nbins)

class LocatorHMS(LocatorBase):

    def __call__(self, v1, v2):
        return select_step24(v1, v2, self.nbins, self._include_last)

class LocatorHM(LocatorBase):

    def __call__(self, v1, v2):
        return select_step24(v1, v2, self.nbins, self._include_last, threshold_factor=60)

class LocatorH(LocatorBase):

    def __call__(self, v1, v2):
        return select_step24(v1, v2, self.nbins, self._include_last, threshold_factor=1)

class LocatorDMS(LocatorBase):

    def __call__(self, v1, v2):
        return select_step360(v1, v2, self.nbins, self._include_last)

class LocatorDM(LocatorBase):

    def __call__(self, v1, v2):
        return select_step360(v1, v2, self.nbins, self._include_last, threshold_factor=60)

class LocatorD(LocatorBase):

    def __call__(self, v1, v2):
        return select_step360(v1, v2, self.nbins, self._include_last, threshold_factor=1)

class FormatterDMS:
    deg_mark = '^{\\circ}'
    min_mark = '^{\\prime}'
    sec_mark = '^{\\prime\\prime}'
    fmt_d = '$%d' + deg_mark + '$'
    fmt_ds = '$%d.%s' + deg_mark + '$'
    fmt_d_m = '$%s%d' + deg_mark + '\\,%02d' + min_mark + '$'
    fmt_d_ms = '$%s%d' + deg_mark + '\\,%02d.%s' + min_mark + '$'
    fmt_d_m_partial = '$%s%d' + deg_mark + '\\,%02d' + min_mark + '\\,'
    fmt_s_partial = '%02d' + sec_mark + '$'
    fmt_ss_partial = '%02d.%s' + sec_mark + '$'

    def _get_number_fraction(self, factor):
        number_fraction = None
        for threshold in [1, 60, 3600]:
            if factor <= threshold:
                break
            d = factor // threshold
            int_log_d = int(np.floor(np.log10(d)))
            if 10 ** int_log_d == d and d != 1:
                number_fraction = int_log_d
                factor = factor // 10 ** int_log_d
                return (factor, number_fraction)
        return (factor, number_fraction)

    def __call__(self, direction, factor, values):
        if len(values) == 0:
            return []
        ss = np.sign(values)
        signs = ['-' if v < 0 else '' for v in values]
        (factor, number_fraction) = self._get_number_fraction(factor)
        values = np.abs(values)
        if number_fraction is not None:
            (values, frac_part) = divmod(values, 10 ** number_fraction)
            frac_fmt = '%%0%dd' % (number_fraction,)
            frac_str = [frac_fmt % (f1,) for f1 in frac_part]
        if factor == 1:
            if number_fraction is None:
                return [self.fmt_d % (s * int(v),) for (s, v) in zip(ss, values)]
            else:
                return [self.fmt_ds % (s * int(v), f1) for (s, v, f1) in zip(ss, values, frac_str)]
        elif factor == 60:
            (deg_part, min_part) = divmod(values, 60)
            if number_fraction is None:
                return [self.fmt_d_m % (s1, d1, m1) for (s1, d1, m1) in zip(signs, deg_part, min_part)]
            else:
                return [self.fmt_d_ms % (s, d1, m1, f1) for (s, d1, m1, f1) in zip(signs, deg_part, min_part, frac_str)]
        elif factor == 3600:
            if ss[-1] == -1:
                inverse_order = True
                values = values[::-1]
                signs = signs[::-1]
            else:
                inverse_order = False
            l_hm_old = ''
            r = []
            (deg_part, min_part_) = divmod(values, 3600)
            (min_part, sec_part) = divmod(min_part_, 60)
            if number_fraction is None:
                sec_str = [self.fmt_s_partial % (s1,) for s1 in sec_part]
            else:
                sec_str = [self.fmt_ss_partial % (s1, f1) for (s1, f1) in zip(sec_part, frac_str)]
            for (s, d1, m1, s1) in zip(signs, deg_part, min_part, sec_str):
                l_hm = self.fmt_d_m_partial % (s, d1, m1)
                if l_hm != l_hm_old:
                    l_hm_old = l_hm
                    l = l_hm + s1
                else:
                    l = '$' + s + s1
                r.append(l)
            if inverse_order:
                return r[::-1]
            else:
                return r
        else:
            return ['$%s^{\\circ}$' % v for v in ss * values]

class FormatterHMS(FormatterDMS):
    deg_mark = '^\\mathrm{h}'
    min_mark = '^\\mathrm{m}'
    sec_mark = '^\\mathrm{s}'
    fmt_d = '$%d' + deg_mark + '$'
    fmt_ds = '$%d.%s' + deg_mark + '$'
    fmt_d_m = '$%s%d' + deg_mark + '\\,%02d' + min_mark + '$'
    fmt_d_ms = '$%s%d' + deg_mark + '\\,%02d.%s' + min_mark + '$'
    fmt_d_m_partial = '$%s%d' + deg_mark + '\\,%02d' + min_mark + '\\,'
    fmt_s_partial = '%02d' + sec_mark + '$'
    fmt_ss_partial = '%02d.%s' + sec_mark + '$'

    def __call__(self, direction, factor, values):
        return super().__call__(direction, factor, np.asarray(values) / 15)

class ExtremeFinderCycle(ExtremeFinderSimple):

    def __init__(self, nx, ny, lon_cycle=360.0, lat_cycle=None, lon_minmax=None, lat_minmax=(-90, 90)):
        (self.nx, self.ny) = (nx, ny)
        (self.lon_cycle, self.lat_cycle) = (lon_cycle, lat_cycle)
        self.lon_minmax = lon_minmax
        self.lat_minmax = lat_minmax

    def __call__(self, transform_xy, x1, y1, x2, y2):
        (x, y) = np.meshgrid(np.linspace(x1, x2, self.nx), np.linspace(y1, y2, self.ny))
        (lon, lat) = transform_xy(np.ravel(x), np.ravel(y))
        with np.errstate(invalid='ignore'):
            if self.lon_cycle is not None:
                lon0 = np.nanmin(lon)
                lon -= 360.0 * (lon - lon0 > 180.0)
            if self.lat_cycle is not None:
                lat0 = np.nanmin(lat)
                lat -= 360.0 * (lat - lat0 > 180.0)
        (lon_min, lon_max) = (np.nanmin(lon), np.nanmax(lon))
        (lat_min, lat_max) = (np.nanmin(lat), np.nanmax(lat))
        (lon_min, lon_max, lat_min, lat_max) = self._add_pad(lon_min, lon_max, lat_min, lat_max)
        if self.lon_cycle:
            lon_max = min(lon_max, lon_min + self.lon_cycle)
        if self.lat_cycle:
            lat_max = min(lat_max, lat_min + self.lat_cycle)
        if self.lon_minmax is not None:
            min0 = self.lon_minmax[0]
            lon_min = max(min0, lon_min)
            max0 = self.lon_minmax[1]
            lon_max = min(max0, lon_max)
        if self.lat_minmax is not None:
            min0 = self.lat_minmax[0]
            lat_min = max(min0, lat_min)
            max0 = self.lat_minmax[1]
            lat_max = min(max0, lat_max)
        return (lon_min, lon_max, lat_min, lat_max)

# File: matplotlib-main/lib/mpl_toolkits/axisartist/axes_grid.py
from matplotlib import _api
import mpl_toolkits.axes_grid1.axes_grid as axes_grid_orig
from .axislines import Axes
_api.warn_deprecated('3.8', name=__name__, obj_type='module', alternative='axes_grid1.axes_grid')

@_api.deprecated('3.8', alternative='axes_grid1.axes_grid.Grid(..., axes_class=axislines.Axes')
class Grid(axes_grid_orig.Grid):
    _defaultAxesClass = Axes

@_api.deprecated('3.8', alternative='axes_grid1.axes_grid.ImageGrid(..., axes_class=axislines.Axes')
class ImageGrid(axes_grid_orig.ImageGrid):
    _defaultAxesClass = Axes
AxesGrid = ImageGrid

# File: matplotlib-main/lib/mpl_toolkits/axisartist/axes_rgb.py
from matplotlib import _api
from mpl_toolkits.axes_grid1.axes_rgb import make_rgb_axes, RGBAxes as _RGBAxes
from .axislines import Axes
_api.warn_deprecated('3.8', name=__name__, obj_type='module', alternative='axes_grid1.axes_rgb')

@_api.deprecated('3.8', alternative='axes_grid1.axes_rgb.RGBAxes(..., axes_class=axislines.Axes')
class RGBAxes(_RGBAxes):
    _defaultAxesClass = Axes

# File: matplotlib-main/lib/mpl_toolkits/axisartist/axis_artist.py
""""""
from operator import methodcaller
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
import matplotlib.artist as martist
import matplotlib.colors as mcolors
import matplotlib.text as mtext
from matplotlib.collections import LineCollection
from matplotlib.lines import Line2D
from matplotlib.patches import PathPatch
from matplotlib.path import Path
from matplotlib.transforms import Affine2D, Bbox, IdentityTransform, ScaledTranslation
from .axisline_style import AxislineStyle

class AttributeCopier:

    def get_ref_artist(self):
        raise RuntimeError('get_ref_artist must overridden')

    def get_attribute_from_ref_artist(self, attr_name):
        getter = methodcaller('get_' + attr_name)
        prop = getter(super())
        return getter(self.get_ref_artist()) if prop == 'auto' else prop

class Ticks(AttributeCopier, Line2D):

    def __init__(self, ticksize, tick_out=False, *, axis=None, **kwargs):
        self._ticksize = ticksize
        self.locs_angles_labels = []
        self.set_tick_out(tick_out)
        self._axis = axis
        if self._axis is not None:
            if 'color' not in kwargs:
                kwargs['color'] = 'auto'
            if 'mew' not in kwargs and 'markeredgewidth' not in kwargs:
                kwargs['markeredgewidth'] = 'auto'
        Line2D.__init__(self, [0.0], [0.0], **kwargs)
        self.set_snap(True)

    def get_ref_artist(self):
        return self._axis.majorTicks[0].tick1line

    def set_color(self, color):
        if not cbook._str_equal(color, 'auto'):
            mcolors._check_color_like(color=color)
        self._color = color
        self.stale = True

    def get_color(self):
        return self.get_attribute_from_ref_artist('color')

    def get_markeredgecolor(self):
        return self.get_attribute_from_ref_artist('markeredgecolor')

    def get_markeredgewidth(self):
        return self.get_attribute_from_ref_artist('markeredgewidth')

    def set_tick_out(self, b):
        self._tick_out = b

    def get_tick_out(self):
        return self._tick_out

    def set_ticksize(self, ticksize):
        self._ticksize = ticksize

    def get_ticksize(self):
        return self._ticksize

    def set_locs_angles(self, locs_angles):
        self.locs_angles = locs_angles
    _tickvert_path = Path([[0.0, 0.0], [1.0, 0.0]])

    def draw(self, renderer):
        if not self.get_visible():
            return
        gc = renderer.new_gc()
        gc.set_foreground(self.get_markeredgecolor())
        gc.set_linewidth(self.get_markeredgewidth())
        gc.set_alpha(self._alpha)
        path_trans = self.get_transform()
        marker_transform = Affine2D().scale(renderer.points_to_pixels(self._ticksize))
        if self.get_tick_out():
            marker_transform.rotate_deg(180)
        for (loc, angle) in self.locs_angles:
            locs = path_trans.transform_non_affine(np.array([loc]))
            if self.axes and (not self.axes.viewLim.contains(*locs[0])):
                continue
            renderer.draw_markers(gc, self._tickvert_path, marker_transform + Affine2D().rotate_deg(angle), Path(locs), path_trans.get_affine())
        gc.restore()

class LabelBase(mtext.Text):

    def __init__(self, *args, **kwargs):
        self.locs_angles_labels = []
        self._ref_angle = 0
        self._offset_radius = 0.0
        super().__init__(*args, **kwargs)
        self.set_rotation_mode('anchor')
        self._text_follow_ref_angle = True

    @property
    def _text_ref_angle(self):
        if self._text_follow_ref_angle:
            return self._ref_angle + 90
        else:
            return 0

    @property
    def _offset_ref_angle(self):
        return self._ref_angle
    _get_opposite_direction = {'left': 'right', 'right': 'left', 'top': 'bottom', 'bottom': 'top'}.__getitem__

    def draw(self, renderer):
        if not self.get_visible():
            return
        tr = self.get_transform()
        angle_orig = self.get_rotation()
        theta = np.deg2rad(self._offset_ref_angle)
        dd = self._offset_radius
        (dx, dy) = (dd * np.cos(theta), dd * np.sin(theta))
        self.set_transform(tr + Affine2D().translate(dx, dy))
        self.set_rotation(self._text_ref_angle + angle_orig)
        super().draw(renderer)
        self.set_transform(tr)
        self.set_rotation(angle_orig)

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        tr = self.get_transform()
        angle_orig = self.get_rotation()
        theta = np.deg2rad(self._offset_ref_angle)
        dd = self._offset_radius
        (dx, dy) = (dd * np.cos(theta), dd * np.sin(theta))
        self.set_transform(tr + Affine2D().translate(dx, dy))
        self.set_rotation(self._text_ref_angle + angle_orig)
        bbox = super().get_window_extent(renderer).frozen()
        self.set_transform(tr)
        self.set_rotation(angle_orig)
        return bbox

class AxisLabel(AttributeCopier, LabelBase):

    def __init__(self, *args, axis_direction='bottom', axis=None, **kwargs):
        self._axis = axis
        self._pad = 5
        self._external_pad = 0
        LabelBase.__init__(self, *args, **kwargs)
        self.set_axis_direction(axis_direction)

    def set_pad(self, pad):
        self._pad = pad

    def get_pad(self):
        return self._pad

    def get_ref_artist(self):
        return self._axis.get_label()

    def get_text(self):
        t = super().get_text()
        if t == '__from_axes__':
            return self._axis.get_label().get_text()
        return self._text
    _default_alignments = dict(left=('bottom', 'center'), right=('top', 'center'), bottom=('top', 'center'), top=('bottom', 'center'))

    def set_default_alignment(self, d):
        (va, ha) = _api.check_getitem(self._default_alignments, d=d)
        self.set_va(va)
        self.set_ha(ha)
    _default_angles = dict(left=180, right=0, bottom=0, top=180)

    def set_default_angle(self, d):
        self.set_rotation(_api.check_getitem(self._default_angles, d=d))

    def set_axis_direction(self, d):
        self.set_default_alignment(d)
        self.set_default_angle(d)

    def get_color(self):
        return self.get_attribute_from_ref_artist('color')

    def draw(self, renderer):
        if not self.get_visible():
            return
        self._offset_radius = self._external_pad + renderer.points_to_pixels(self.get_pad())
        super().draw(renderer)

    def get_window_extent(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        if not self.get_visible():
            return
        r = self._external_pad + renderer.points_to_pixels(self.get_pad())
        self._offset_radius = r
        bb = super().get_window_extent(renderer)
        return bb

class TickLabels(AxisLabel):

    def __init__(self, *, axis_direction='bottom', **kwargs):
        super().__init__(**kwargs)
        self.set_axis_direction(axis_direction)
        self._axislabel_pad = 0

    def get_ref_artist(self):
        return self._axis.get_ticklabels()[0]

    def set_axis_direction(self, label_direction):
        self.set_default_alignment(label_direction)
        self.set_default_angle(label_direction)
        self._axis_direction = label_direction

    def invert_axis_direction(self):
        label_direction = self._get_opposite_direction(self._axis_direction)
        self.set_axis_direction(label_direction)

    def _get_ticklabels_offsets(self, renderer, label_direction):
        whd_list = self.get_texts_widths_heights_descents(renderer)
        if not whd_list:
            return (0, 0)
        r = 0
        (va, ha) = (self.get_va(), self.get_ha())
        if label_direction == 'left':
            pad = max((w for (w, h, d) in whd_list))
            if ha == 'left':
                r = pad
            elif ha == 'center':
                r = 0.5 * pad
        elif label_direction == 'right':
            pad = max((w for (w, h, d) in whd_list))
            if ha == 'right':
                r = pad
            elif ha == 'center':
                r = 0.5 * pad
        elif label_direction == 'bottom':
            pad = max((h for (w, h, d) in whd_list))
            if va == 'bottom':
                r = pad
            elif va == 'center':
                r = 0.5 * pad
            elif va == 'baseline':
                max_ascent = max((h - d for (w, h, d) in whd_list))
                max_descent = max((d for (w, h, d) in whd_list))
                r = max_ascent
                pad = max_ascent + max_descent
        elif label_direction == 'top':
            pad = max((h for (w, h, d) in whd_list))
            if va == 'top':
                r = pad
            elif va == 'center':
                r = 0.5 * pad
            elif va == 'baseline':
                max_ascent = max((h - d for (w, h, d) in whd_list))
                max_descent = max((d for (w, h, d) in whd_list))
                r = max_descent
                pad = max_ascent + max_descent
        return (r, pad)
    _default_alignments = dict(left=('center', 'right'), right=('center', 'left'), bottom=('baseline', 'center'), top=('baseline', 'center'))
    _default_angles = dict(left=90, right=-90, bottom=0, top=180)

    def draw(self, renderer):
        if not self.get_visible():
            self._axislabel_pad = self._external_pad
            return
        (r, total_width) = self._get_ticklabels_offsets(renderer, self._axis_direction)
        pad = self._external_pad + renderer.points_to_pixels(self.get_pad())
        self._offset_radius = r + pad
        for ((x, y), a, l) in self._locs_angles_labels:
            if not l.strip():
                continue
            self._ref_angle = a
            self.set_x(x)
            self.set_y(y)
            self.set_text(l)
            LabelBase.draw(self, renderer)
        self._axislabel_pad = total_width + pad

    def set_locs_angles_labels(self, locs_angles_labels):
        self._locs_angles_labels = locs_angles_labels

    def get_window_extents(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        if not self.get_visible():
            self._axislabel_pad = self._external_pad
            return []
        bboxes = []
        (r, total_width) = self._get_ticklabels_offsets(renderer, self._axis_direction)
        pad = self._external_pad + renderer.points_to_pixels(self.get_pad())
        self._offset_radius = r + pad
        for ((x, y), a, l) in self._locs_angles_labels:
            self._ref_angle = a
            self.set_x(x)
            self.set_y(y)
            self.set_text(l)
            bb = LabelBase.get_window_extent(self, renderer)
            bboxes.append(bb)
        self._axislabel_pad = total_width + pad
        return bboxes

    def get_texts_widths_heights_descents(self, renderer):
        whd_list = []
        for (_loc, _angle, label) in self._locs_angles_labels:
            if not label.strip():
                continue
            (clean_line, ismath) = self._preprocess_math(label)
            whd = renderer.get_text_width_height_descent(clean_line, self._fontproperties, ismath=ismath)
            whd_list.append(whd)
        return whd_list

class GridlinesCollection(LineCollection):

    def __init__(self, *args, which='major', axis='both', **kwargs):
        self._which = which
        self._axis = axis
        super().__init__(*args, **kwargs)
        self.set_grid_helper(None)

    def set_which(self, which):
        self._which = which

    def set_axis(self, axis):
        self._axis = axis

    def set_grid_helper(self, grid_helper):
        self._grid_helper = grid_helper

    def draw(self, renderer):
        if self._grid_helper is not None:
            self._grid_helper.update_lim(self.axes)
            gl = self._grid_helper.get_gridlines(self._which, self._axis)
            self.set_segments([np.transpose(l) for l in gl])
        super().draw(renderer)

class AxisArtist(martist.Artist):
    zorder = 2.5

    @property
    def LABELPAD(self):
        return self.label.get_pad()

    @LABELPAD.setter
    def LABELPAD(self, v):
        self.label.set_pad(v)

    def __init__(self, axes, helper, offset=None, axis_direction='bottom', **kwargs):
        super().__init__(**kwargs)
        self.axes = axes
        self._axis_artist_helper = helper
        if offset is None:
            offset = (0, 0)
        self.offset_transform = ScaledTranslation(*offset, Affine2D().scale(1 / 72) + self.axes.get_figure(root=False).dpi_scale_trans)
        if axis_direction in ['left', 'right']:
            self.axis = axes.yaxis
        else:
            self.axis = axes.xaxis
        self._axisline_style = None
        self._axis_direction = axis_direction
        self._init_line()
        self._init_ticks(**kwargs)
        self._init_offsetText(axis_direction)
        self._init_label()
        self._ticklabel_add_angle = 0.0
        self._axislabel_add_angle = 0.0
        self.set_axis_direction(axis_direction)

    def set_axis_direction(self, axis_direction):
        self.major_ticklabels.set_axis_direction(axis_direction)
        self.label.set_axis_direction(axis_direction)
        self._axis_direction = axis_direction
        if axis_direction in ['left', 'top']:
            self.set_ticklabel_direction('-')
            self.set_axislabel_direction('-')
        else:
            self.set_ticklabel_direction('+')
            self.set_axislabel_direction('+')

    def set_ticklabel_direction(self, tick_direction):
        self._ticklabel_add_angle = _api.check_getitem({'+': 0, '-': 180}, tick_direction=tick_direction)

    def invert_ticklabel_direction(self):
        self._ticklabel_add_angle = (self._ticklabel_add_angle + 180) % 360
        self.major_ticklabels.invert_axis_direction()
        self.minor_ticklabels.invert_axis_direction()

    def set_axislabel_direction(self, label_direction):
        self._axislabel_add_angle = _api.check_getitem({'+': 0, '-': 180}, label_direction=label_direction)

    def get_transform(self):
        return self.axes.transAxes + self.offset_transform

    def get_helper(self):
        return self._axis_artist_helper

    def set_axisline_style(self, axisline_style=None, **kwargs):
        if axisline_style is None:
            return AxislineStyle.pprint_styles()
        if isinstance(axisline_style, AxislineStyle._Base):
            self._axisline_style = axisline_style
        else:
            self._axisline_style = AxislineStyle(axisline_style, **kwargs)
        self._init_line()

    def get_axisline_style(self):
        return self._axisline_style

    def _init_line(self):
        tran = self._axis_artist_helper.get_line_transform(self.axes) + self.offset_transform
        axisline_style = self.get_axisline_style()
        if axisline_style is None:
            self.line = PathPatch(self._axis_artist_helper.get_line(self.axes), color=mpl.rcParams['axes.edgecolor'], fill=False, linewidth=mpl.rcParams['axes.linewidth'], capstyle=mpl.rcParams['lines.solid_capstyle'], joinstyle=mpl.rcParams['lines.solid_joinstyle'], transform=tran)
        else:
            self.line = axisline_style(self, transform=tran)

    def _draw_line(self, renderer):
        self.line.set_path(self._axis_artist_helper.get_line(self.axes))
        if self.get_axisline_style() is not None:
            self.line.set_line_mutation_scale(self.major_ticklabels.get_size())
        self.line.draw(renderer)

    def _init_ticks(self, **kwargs):
        axis_name = self.axis.axis_name
        trans = self._axis_artist_helper.get_tick_transform(self.axes) + self.offset_transform
        self.major_ticks = Ticks(kwargs.get('major_tick_size', mpl.rcParams[f'{axis_name}tick.major.size']), axis=self.axis, transform=trans)
        self.minor_ticks = Ticks(kwargs.get('minor_tick_size', mpl.rcParams[f'{axis_name}tick.minor.size']), axis=self.axis, transform=trans)
        size = mpl.rcParams[f'{axis_name}tick.labelsize']
        self.major_ticklabels = TickLabels(axis=self.axis, axis_direction=self._axis_direction, figure=self.axes.get_figure(root=False), transform=trans, fontsize=size, pad=kwargs.get('major_tick_pad', mpl.rcParams[f'{axis_name}tick.major.pad']))
        self.minor_ticklabels = TickLabels(axis=self.axis, axis_direction=self._axis_direction, figure=self.axes.get_figure(root=False), transform=trans, fontsize=size, pad=kwargs.get('minor_tick_pad', mpl.rcParams[f'{axis_name}tick.minor.pad']))

    def _get_tick_info(self, tick_iter):
        ticks_loc_angle = []
        ticklabels_loc_angle_label = []
        ticklabel_add_angle = self._ticklabel_add_angle
        for (loc, angle_normal, angle_tangent, label) in tick_iter:
            angle_label = angle_tangent - 90 + ticklabel_add_angle
            angle_tick = angle_normal if 90 <= (angle_label - angle_normal) % 360 <= 270 else angle_normal + 180
            ticks_loc_angle.append([loc, angle_tick])
            ticklabels_loc_angle_label.append([loc, angle_label, label])
        return (ticks_loc_angle, ticklabels_loc_angle_label)

    def _update_ticks(self, renderer=None):
        if renderer is None:
            renderer = self.get_figure(root=True)._get_renderer()
        dpi_cor = renderer.points_to_pixels(1.0)
        if self.major_ticks.get_visible() and self.major_ticks.get_tick_out():
            ticklabel_pad = self.major_ticks._ticksize * dpi_cor
            self.major_ticklabels._external_pad = ticklabel_pad
            self.minor_ticklabels._external_pad = ticklabel_pad
        else:
            self.major_ticklabels._external_pad = 0
            self.minor_ticklabels._external_pad = 0
        (majortick_iter, minortick_iter) = self._axis_artist_helper.get_tick_iterators(self.axes)
        (tick_loc_angle, ticklabel_loc_angle_label) = self._get_tick_info(majortick_iter)
        self.major_ticks.set_locs_angles(tick_loc_angle)
        self.major_ticklabels.set_locs_angles_labels(ticklabel_loc_angle_label)
        (tick_loc_angle, ticklabel_loc_angle_label) = self._get_tick_info(minortick_iter)
        self.minor_ticks.set_locs_angles(tick_loc_angle)
        self.minor_ticklabels.set_locs_angles_labels(ticklabel_loc_angle_label)

    def _draw_ticks(self, renderer):
        self._update_ticks(renderer)
        self.major_ticks.draw(renderer)
        self.major_ticklabels.draw(renderer)
        self.minor_ticks.draw(renderer)
        self.minor_ticklabels.draw(renderer)
        if self.major_ticklabels.get_visible() or self.minor_ticklabels.get_visible():
            self._draw_offsetText(renderer)
    _offsetText_pos = dict(left=(0, 1, 'bottom', 'right'), right=(1, 1, 'bottom', 'left'), bottom=(1, 0, 'top', 'right'), top=(1, 1, 'bottom', 'right'))

    def _init_offsetText(self, direction):
        (x, y, va, ha) = self._offsetText_pos[direction]
        self.offsetText = mtext.Annotation('', xy=(x, y), xycoords='axes fraction', xytext=(0, 0), textcoords='offset points', color=mpl.rcParams['xtick.color'], horizontalalignment=ha, verticalalignment=va)
        self.offsetText.set_transform(IdentityTransform())
        self.axes._set_artist_props(self.offsetText)

    def _update_offsetText(self):
        self.offsetText.set_text(self.axis.major.formatter.get_offset())
        self.offsetText.set_size(self.major_ticklabels.get_size())
        offset = self.major_ticklabels.get_pad() + self.major_ticklabels.get_size() + 2
        self.offsetText.xyann = (0, offset)

    def _draw_offsetText(self, renderer):
        self._update_offsetText()
        self.offsetText.draw(renderer)

    def _init_label(self, **kwargs):
        tr = self._axis_artist_helper.get_axislabel_transform(self.axes) + self.offset_transform
        self.label = AxisLabel(0, 0, '__from_axes__', color='auto', fontsize=kwargs.get('labelsize', mpl.rcParams['axes.labelsize']), fontweight=mpl.rcParams['axes.labelweight'], axis=self.axis, transform=tr, axis_direction=self._axis_direction)
        self.label.set_figure(self.axes.get_figure(root=False))
        labelpad = kwargs.get('labelpad', 5)
        self.label.set_pad(labelpad)

    def _update_label(self, renderer):
        if not self.label.get_visible():
            return
        if self._ticklabel_add_angle != self._axislabel_add_angle:
            if self.major_ticks.get_visible() and (not self.major_ticks.get_tick_out()) or (self.minor_ticks.get_visible() and (not self.major_ticks.get_tick_out())):
                axislabel_pad = self.major_ticks._ticksize
            else:
                axislabel_pad = 0
        else:
            axislabel_pad = max(self.major_ticklabels._axislabel_pad, self.minor_ticklabels._axislabel_pad)
        self.label._external_pad = axislabel_pad
        (xy, angle_tangent) = self._axis_artist_helper.get_axislabel_pos_angle(self.axes)
        if xy is None:
            return
        angle_label = angle_tangent - 90
        (x, y) = xy
        self.label._ref_angle = angle_label + self._axislabel_add_angle
        self.label.set(x=x, y=y)

    def _draw_label(self, renderer):
        self._update_label(renderer)
        self.label.draw(renderer)

    def set_label(self, s):
        self.label.set_text(s)

    def get_tightbbox(self, renderer=None):
        if not self.get_visible():
            return
        self._axis_artist_helper.update_lim(self.axes)
        self._update_ticks(renderer)
        self._update_label(renderer)
        self.line.set_path(self._axis_artist_helper.get_line(self.axes))
        if self.get_axisline_style() is not None:
            self.line.set_line_mutation_scale(self.major_ticklabels.get_size())
        bb = [*self.major_ticklabels.get_window_extents(renderer), *self.minor_ticklabels.get_window_extents(renderer), self.label.get_window_extent(renderer), self.offsetText.get_window_extent(renderer), self.line.get_window_extent(renderer)]
        bb = [b for b in bb if b and (b.width != 0 or b.height != 0)]
        if bb:
            _bbox = Bbox.union(bb)
            return _bbox
        else:
            return None

    @martist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        renderer.open_group(__name__, gid=self.get_gid())
        self._axis_artist_helper.update_lim(self.axes)
        self._draw_ticks(renderer)
        self._draw_line(renderer)
        self._draw_label(renderer)
        renderer.close_group(__name__)

    def toggle(self, all=None, ticks=None, ticklabels=None, label=None):
        if all:
            (_ticks, _ticklabels, _label) = (True, True, True)
        elif all is not None:
            (_ticks, _ticklabels, _label) = (False, False, False)
        else:
            (_ticks, _ticklabels, _label) = (None, None, None)
        if ticks is not None:
            _ticks = ticks
        if ticklabels is not None:
            _ticklabels = ticklabels
        if label is not None:
            _label = label
        if _ticks is not None:
            self.major_ticks.set_visible(_ticks)
            self.minor_ticks.set_visible(_ticks)
        if _ticklabels is not None:
            self.major_ticklabels.set_visible(_ticklabels)
            self.minor_ticklabels.set_visible(_ticklabels)
        if _label is not None:
            self.label.set_visible(_label)

# File: matplotlib-main/lib/mpl_toolkits/axisartist/axisline_style.py
""""""
import math
import numpy as np
import matplotlib as mpl
from matplotlib.patches import _Style, FancyArrowPatch
from matplotlib.path import Path
from matplotlib.transforms import IdentityTransform

class _FancyAxislineStyle:

    class SimpleArrow(FancyArrowPatch):
        _ARROW_STYLE = '->'

        def __init__(self, axis_artist, line_path, transform, line_mutation_scale):
            self._axis_artist = axis_artist
            self._line_transform = transform
            self._line_path = line_path
            self._line_mutation_scale = line_mutation_scale
            FancyArrowPatch.__init__(self, path=self._line_path, arrowstyle=self._ARROW_STYLE, patchA=None, patchB=None, shrinkA=0.0, shrinkB=0.0, mutation_scale=line_mutation_scale, mutation_aspect=None, transform=IdentityTransform())

        def set_line_mutation_scale(self, scale):
            self.set_mutation_scale(scale * self._line_mutation_scale)

        def _extend_path(self, path, mutation_size=10):
            ((x0, y0), (x1, y1)) = path.vertices[-2:]
            theta = math.atan2(y1 - y0, x1 - x0)
            x2 = x1 + math.cos(theta) * mutation_size
            y2 = y1 + math.sin(theta) * mutation_size
            if path.codes is None:
                return Path(np.concatenate([path.vertices, [[x2, y2]]]))
            else:
                return Path(np.concatenate([path.vertices, [[x2, y2]]]), np.concatenate([path.codes, [Path.LINETO]]))

        def set_path(self, path):
            self._line_path = path

        def draw(self, renderer):
            path_in_disp = self._line_transform.transform_path(self._line_path)
            mutation_size = self.get_mutation_scale()
            extended_path = self._extend_path(path_in_disp, mutation_size=mutation_size)
            self._path_original = extended_path
            FancyArrowPatch.draw(self, renderer)

        def get_window_extent(self, renderer=None):
            path_in_disp = self._line_transform.transform_path(self._line_path)
            mutation_size = self.get_mutation_scale()
            extended_path = self._extend_path(path_in_disp, mutation_size=mutation_size)
            self._path_original = extended_path
            return FancyArrowPatch.get_window_extent(self, renderer)

    class FilledArrow(SimpleArrow):
        _ARROW_STYLE = '-|>'

        def __init__(self, axis_artist, line_path, transform, line_mutation_scale, facecolor):
            super().__init__(axis_artist, line_path, transform, line_mutation_scale)
            self.set_facecolor(facecolor)

class AxislineStyle(_Style):
    _style_list = {}

    class _Base:

        def __init__(self):
            super().__init__()

        def __call__(self, axis_artist, transform):
            return self.new_line(axis_artist, transform)

    class SimpleArrow(_Base):
        ArrowAxisClass = _FancyAxislineStyle.SimpleArrow

        def __init__(self, size=1):
            self.size = size
            super().__init__()

        def new_line(self, axis_artist, transform):
            linepath = Path([(0, 0), (0, 1)])
            axisline = self.ArrowAxisClass(axis_artist, linepath, transform, line_mutation_scale=self.size)
            return axisline
    _style_list['->'] = SimpleArrow

    class FilledArrow(SimpleArrow):
        ArrowAxisClass = _FancyAxislineStyle.FilledArrow

        def __init__(self, size=1, facecolor=None):
            if facecolor is None:
                facecolor = mpl.rcParams['axes.edgecolor']
            self.size = size
            self._facecolor = facecolor
            super().__init__(size=size)

        def new_line(self, axis_artist, transform):
            linepath = Path([(0, 0), (0, 1)])
            axisline = self.ArrowAxisClass(axis_artist, linepath, transform, line_mutation_scale=self.size, facecolor=self._facecolor)
            return axisline
    _style_list['-|>'] = FilledArrow

# File: matplotlib-main/lib/mpl_toolkits/axisartist/axislines.py
""""""
import numpy as np
import matplotlib as mpl
from matplotlib import _api
import matplotlib.axes as maxes
from matplotlib.path import Path
from mpl_toolkits.axes_grid1 import mpl_axes
from .axisline_style import AxislineStyle
from .axis_artist import AxisArtist, GridlinesCollection

class _AxisArtistHelperBase:

    def __init__(self, nth_coord):
        self.nth_coord = nth_coord

    def update_lim(self, axes):
        pass

    def get_nth_coord(self):
        return self.nth_coord

    def _to_xy(self, values, const):
        if self.nth_coord == 0:
            return np.stack(np.broadcast_arrays(values, const), axis=-1)
        elif self.nth_coord == 1:
            return np.stack(np.broadcast_arrays(const, values), axis=-1)
        else:
            raise ValueError('Unexpected nth_coord')

class _FixedAxisArtistHelperBase(_AxisArtistHelperBase):

    @_api.delete_parameter('3.9', 'nth_coord')
    def __init__(self, loc, nth_coord=None):
        super().__init__(_api.check_getitem({'bottom': 0, 'top': 0, 'left': 1, 'right': 1}, loc=loc))
        self._loc = loc
        self._pos = {'bottom': 0, 'top': 1, 'left': 0, 'right': 1}[loc]
        self._path = Path(self._to_xy((0, 1), const=self._pos))

    def get_line(self, axes):
        return self._path

    def get_line_transform(self, axes):
        return axes.transAxes

    def get_axislabel_transform(self, axes):
        return axes.transAxes

    def get_axislabel_pos_angle(self, axes):
        return dict(left=((0.0, 0.5), 90), right=((1.0, 0.5), 90), bottom=((0.5, 0.0), 0), top=((0.5, 1.0), 0))[self._loc]

    def get_tick_transform(self, axes):
        return [axes.get_xaxis_transform(), axes.get_yaxis_transform()][self.nth_coord]

class _FloatingAxisArtistHelperBase(_AxisArtistHelperBase):

    def __init__(self, nth_coord, value):
        self._value = value
        super().__init__(nth_coord)

    def get_line(self, axes):
        raise RuntimeError('get_line method should be defined by the derived class')

class FixedAxisArtistHelperRectilinear(_FixedAxisArtistHelperBase):

    @_api.delete_parameter('3.9', 'nth_coord')
    def __init__(self, axes, loc, nth_coord=None):
        super().__init__(loc)
        self.axis = [axes.xaxis, axes.yaxis][self.nth_coord]

    def get_tick_iterators(self, axes):
        (angle_normal, angle_tangent) = {0: (90, 0), 1: (0, 90)}[self.nth_coord]
        major = self.axis.major
        major_locs = major.locator()
        major_labels = major.formatter.format_ticks(major_locs)
        minor = self.axis.minor
        minor_locs = minor.locator()
        minor_labels = minor.formatter.format_ticks(minor_locs)
        tick_to_axes = self.get_tick_transform(axes) - axes.transAxes

        def _f(locs, labels):
            for (loc, label) in zip(locs, labels):
                c = self._to_xy(loc, const=self._pos)
                c2 = tick_to_axes.transform(c)
                if mpl.transforms._interval_contains_close((0, 1), c2[self.nth_coord]):
                    yield (c, angle_normal, angle_tangent, label)
        return (_f(major_locs, major_labels), _f(minor_locs, minor_labels))

class FloatingAxisArtistHelperRectilinear(_FloatingAxisArtistHelperBase):

    def __init__(self, axes, nth_coord, passingthrough_point, axis_direction='bottom'):
        super().__init__(nth_coord, passingthrough_point)
        self._axis_direction = axis_direction
        self.axis = [axes.xaxis, axes.yaxis][self.nth_coord]

    def get_line(self, axes):
        fixed_coord = 1 - self.nth_coord
        data_to_axes = axes.transData - axes.transAxes
        p = data_to_axes.transform([self._value, self._value])
        return Path(self._to_xy((0, 1), const=p[fixed_coord]))

    def get_line_transform(self, axes):
        return axes.transAxes

    def get_axislabel_transform(self, axes):
        return axes.transAxes

    def get_axislabel_pos_angle(self, axes):
        angle = [0, 90][self.nth_coord]
        fixed_coord = 1 - self.nth_coord
        data_to_axes = axes.transData - axes.transAxes
        p = data_to_axes.transform([self._value, self._value])
        verts = self._to_xy(0.5, const=p[fixed_coord])
        return (verts, angle) if 0 <= verts[fixed_coord] <= 1 else (None, None)

    def get_tick_transform(self, axes):
        return axes.transData

    def get_tick_iterators(self, axes):
        (angle_normal, angle_tangent) = {0: (90, 0), 1: (0, 90)}[self.nth_coord]
        major = self.axis.major
        major_locs = major.locator()
        major_labels = major.formatter.format_ticks(major_locs)
        minor = self.axis.minor
        minor_locs = minor.locator()
        minor_labels = minor.formatter.format_ticks(minor_locs)
        data_to_axes = axes.transData - axes.transAxes

        def _f(locs, labels):
            for (loc, label) in zip(locs, labels):
                c = self._to_xy(loc, const=self._value)
                (c1, c2) = data_to_axes.transform(c)
                if 0 <= c1 <= 1 and 0 <= c2 <= 1:
                    yield (c, angle_normal, angle_tangent, label)
        return (_f(major_locs, major_labels), _f(minor_locs, minor_labels))

class AxisArtistHelper:
    Fixed = _FixedAxisArtistHelperBase
    Floating = _FloatingAxisArtistHelperBase

class AxisArtistHelperRectlinear:
    Fixed = FixedAxisArtistHelperRectilinear
    Floating = FloatingAxisArtistHelperRectilinear

class GridHelperBase:

    def __init__(self):
        self._old_limits = None
        super().__init__()

    def update_lim(self, axes):
        (x1, x2) = axes.get_xlim()
        (y1, y2) = axes.get_ylim()
        if self._old_limits != (x1, x2, y1, y2):
            self._update_grid(x1, y1, x2, y2)
            self._old_limits = (x1, x2, y1, y2)

    def _update_grid(self, x1, y1, x2, y2):

    def get_gridlines(self, which, axis):
        return []

class GridHelperRectlinear(GridHelperBase):

    def __init__(self, axes):
        super().__init__()
        self.axes = axes

    @_api.delete_parameter('3.9', 'nth_coord', addendum="'nth_coord' is now inferred from 'loc'.")
    def new_fixed_axis(self, loc, nth_coord=None, axis_direction=None, offset=None, axes=None):
        if axes is None:
            _api.warn_external("'new_fixed_axis' explicitly requires the axes keyword.")
            axes = self.axes
        if axis_direction is None:
            axis_direction = loc
        return AxisArtist(axes, FixedAxisArtistHelperRectilinear(axes, loc), offset=offset, axis_direction=axis_direction)

    def new_floating_axis(self, nth_coord, value, axis_direction='bottom', axes=None):
        if axes is None:
            _api.warn_external("'new_floating_axis' explicitly requires the axes keyword.")
            axes = self.axes
        helper = FloatingAxisArtistHelperRectilinear(axes, nth_coord, value, axis_direction)
        axisline = AxisArtist(axes, helper, axis_direction=axis_direction)
        axisline.line.set_clip_on(True)
        axisline.line.set_clip_box(axisline.axes.bbox)
        return axisline

    def get_gridlines(self, which='major', axis='both'):
        _api.check_in_list(['both', 'major', 'minor'], which=which)
        _api.check_in_list(['both', 'x', 'y'], axis=axis)
        gridlines = []
        if axis in ('both', 'x'):
            locs = []
            (y1, y2) = self.axes.get_ylim()
            if which in ('both', 'major'):
                locs.extend(self.axes.xaxis.major.locator())
            if which in ('both', 'minor'):
                locs.extend(self.axes.xaxis.minor.locator())
            gridlines.extend(([[x, x], [y1, y2]] for x in locs))
        if axis in ('both', 'y'):
            (x1, x2) = self.axes.get_xlim()
            locs = []
            if self.axes.yaxis._major_tick_kw['gridOn']:
                locs.extend(self.axes.yaxis.major.locator())
            if self.axes.yaxis._minor_tick_kw['gridOn']:
                locs.extend(self.axes.yaxis.minor.locator())
            gridlines.extend(([[x1, x2], [y, y]] for y in locs))
        return gridlines

class Axes(maxes.Axes):

    @_api.deprecated('3.8', alternative='ax.axis')
    def __call__(self, *args, **kwargs):
        return maxes.Axes.axis(self.axes, *args, **kwargs)

    def __init__(self, *args, grid_helper=None, **kwargs):
        self._axisline_on = True
        self._grid_helper = grid_helper if grid_helper else GridHelperRectlinear(self)
        super().__init__(*args, **kwargs)
        self.toggle_axisline(True)

    def toggle_axisline(self, b=None):
        if b is None:
            b = not self._axisline_on
        if b:
            self._axisline_on = True
            self.spines[:].set_visible(False)
            self.xaxis.set_visible(False)
            self.yaxis.set_visible(False)
        else:
            self._axisline_on = False
            self.spines[:].set_visible(True)
            self.xaxis.set_visible(True)
            self.yaxis.set_visible(True)

    @property
    def axis(self):
        return self._axislines

    def clear(self):
        self.gridlines = gridlines = GridlinesCollection([], colors=mpl.rcParams['grid.color'], linestyles=mpl.rcParams['grid.linestyle'], linewidths=mpl.rcParams['grid.linewidth'])
        self._set_artist_props(gridlines)
        gridlines.set_grid_helper(self.get_grid_helper())
        super().clear()
        gridlines.set_clip_path(self.axes.patch)
        self._axislines = mpl_axes.Axes.AxisDict(self)
        new_fixed_axis = self.get_grid_helper().new_fixed_axis
        self._axislines.update({loc: new_fixed_axis(loc=loc, axes=self, axis_direction=loc) for loc in ['bottom', 'top', 'left', 'right']})
        for axisline in [self._axislines['top'], self._axislines['right']]:
            axisline.label.set_visible(False)
            axisline.major_ticklabels.set_visible(False)
            axisline.minor_ticklabels.set_visible(False)

    def get_grid_helper(self):
        return self._grid_helper

    def grid(self, visible=None, which='major', axis='both', **kwargs):
        super().grid(visible, which=which, axis=axis, **kwargs)
        if not self._axisline_on:
            return
        if visible is None:
            visible = self.axes.xaxis._minor_tick_kw['gridOn'] or self.axes.xaxis._major_tick_kw['gridOn'] or self.axes.yaxis._minor_tick_kw['gridOn'] or self.axes.yaxis._major_tick_kw['gridOn']
        self.gridlines.set(which=which, axis=axis, visible=visible)
        self.gridlines.set(**kwargs)

    def get_children(self):
        if self._axisline_on:
            children = [*self._axislines.values(), self.gridlines]
        else:
            children = []
        children.extend(super().get_children())
        return children

    def new_fixed_axis(self, loc, offset=None):
        return self.get_grid_helper().new_fixed_axis(loc, offset=offset, axes=self)

    def new_floating_axis(self, nth_coord, value, axis_direction='bottom'):
        return self.get_grid_helper().new_floating_axis(nth_coord, value, axis_direction=axis_direction, axes=self)

class AxesZero(Axes):

    def clear(self):
        super().clear()
        new_floating_axis = self.get_grid_helper().new_floating_axis
        self._axislines.update(xzero=new_floating_axis(nth_coord=0, value=0.0, axis_direction='bottom', axes=self), yzero=new_floating_axis(nth_coord=1, value=0.0, axis_direction='left', axes=self))
        for k in ['xzero', 'yzero']:
            self._axislines[k].line.set_clip_path(self.patch)
            self._axislines[k].set_visible(False)
Subplot = Axes
SubplotZero = AxesZero

# File: matplotlib-main/lib/mpl_toolkits/axisartist/floating_axes.py
""""""
import functools
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook
import matplotlib.patches as mpatches
from matplotlib.path import Path
from mpl_toolkits.axes_grid1.parasite_axes import host_axes_class_factory
from . import axislines, grid_helper_curvelinear
from .axis_artist import AxisArtist
from .grid_finder import ExtremeFinderSimple

class FloatingAxisArtistHelper(grid_helper_curvelinear.FloatingAxisArtistHelper):
    pass

class FixedAxisArtistHelper(grid_helper_curvelinear.FloatingAxisArtistHelper):

    def __init__(self, grid_helper, side, nth_coord_ticks=None):
        (lon1, lon2, lat1, lat2) = grid_helper.grid_finder.extreme_finder(*[None] * 5)
        (value, nth_coord) = _api.check_getitem(dict(left=(lon1, 0), right=(lon2, 0), bottom=(lat1, 1), top=(lat2, 1)), side=side)
        super().__init__(grid_helper, nth_coord, value, axis_direction=side)
        if nth_coord_ticks is None:
            nth_coord_ticks = nth_coord
        self.nth_coord_ticks = nth_coord_ticks
        self.value = value
        self.grid_helper = grid_helper
        self._side = side

    def update_lim(self, axes):
        self.grid_helper.update_lim(axes)
        self._grid_info = self.grid_helper._grid_info

    def get_tick_iterators(self, axes):
        grid_finder = self.grid_helper.grid_finder
        (lat_levs, lat_n, lat_factor) = self._grid_info['lat_info']
        yy0 = lat_levs / lat_factor
        (lon_levs, lon_n, lon_factor) = self._grid_info['lon_info']
        xx0 = lon_levs / lon_factor
        extremes = self.grid_helper.grid_finder.extreme_finder(*[None] * 5)
        (xmin, xmax) = sorted(extremes[:2])
        (ymin, ymax) = sorted(extremes[2:])

        def trf_xy(x, y):
            trf = grid_finder.get_transform() + axes.transData
            return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T
        if self.nth_coord == 0:
            mask = (ymin <= yy0) & (yy0 <= ymax)
            ((xx1, yy1), (dxx1, dyy1), (dxx2, dyy2)) = grid_helper_curvelinear._value_and_jacobian(trf_xy, self.value, yy0[mask], (xmin, xmax), (ymin, ymax))
            labels = self._grid_info['lat_labels']
        elif self.nth_coord == 1:
            mask = (xmin <= xx0) & (xx0 <= xmax)
            ((xx1, yy1), (dxx2, dyy2), (dxx1, dyy1)) = grid_helper_curvelinear._value_and_jacobian(trf_xy, xx0[mask], self.value, (xmin, xmax), (ymin, ymax))
            labels = self._grid_info['lon_labels']
        labels = [l for (l, m) in zip(labels, mask) if m]
        angle_normal = np.arctan2(dyy1, dxx1)
        angle_tangent = np.arctan2(dyy2, dxx2)
        mm = (dyy1 == 0) & (dxx1 == 0)
        angle_normal[mm] = angle_tangent[mm] + np.pi / 2
        tick_to_axes = self.get_tick_transform(axes) - axes.transAxes
        in_01 = functools.partial(mpl.transforms._interval_contains_close, (0, 1))

        def f1():
            for (x, y, normal, tangent, lab) in zip(xx1, yy1, angle_normal, angle_tangent, labels):
                c2 = tick_to_axes.transform((x, y))
                if in_01(c2[0]) and in_01(c2[1]):
                    yield ([x, y], *np.rad2deg([normal, tangent]), lab)
        return (f1(), iter([]))

    def get_line(self, axes):
        self.update_lim(axes)
        (k, v) = dict(left=('lon_lines0', 0), right=('lon_lines0', 1), bottom=('lat_lines0', 0), top=('lat_lines0', 1))[self._side]
        (xx, yy) = self._grid_info[k][v]
        return Path(np.column_stack([xx, yy]))

class ExtremeFinderFixed(ExtremeFinderSimple):

    def __init__(self, extremes):
        self._extremes = extremes

    def __call__(self, transform_xy, x1, y1, x2, y2):
        return self._extremes

class GridHelperCurveLinear(grid_helper_curvelinear.GridHelperCurveLinear):

    def __init__(self, aux_trans, extremes, grid_locator1=None, grid_locator2=None, tick_formatter1=None, tick_formatter2=None):
        super().__init__(aux_trans, extreme_finder=ExtremeFinderFixed(extremes), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=tick_formatter2)

    @_api.deprecated('3.8')
    def get_data_boundary(self, side):
        (lon1, lon2, lat1, lat2) = self.grid_finder.extreme_finder(*[None] * 5)
        return dict(left=(lon1, 0), right=(lon2, 0), bottom=(lat1, 1), top=(lat2, 1))[side]

    def new_fixed_axis(self, loc, nth_coord=None, axis_direction=None, offset=None, axes=None):
        if axes is None:
            axes = self.axes
        if axis_direction is None:
            axis_direction = loc
        helper = FixedAxisArtistHelper(self, loc, nth_coord_ticks=nth_coord)
        axisline = AxisArtist(axes, helper, axis_direction=axis_direction)
        axisline.line.set_clip_on(True)
        axisline.line.set_clip_box(axisline.axes.bbox)
        return axisline

    def _update_grid(self, x1, y1, x2, y2):
        if self._grid_info is None:
            self._grid_info = dict()
        grid_info = self._grid_info
        grid_finder = self.grid_finder
        extremes = grid_finder.extreme_finder(grid_finder.inv_transform_xy, x1, y1, x2, y2)
        (lon_min, lon_max) = sorted(extremes[:2])
        (lat_min, lat_max) = sorted(extremes[2:])
        grid_info['extremes'] = (lon_min, lon_max, lat_min, lat_max)
        (lon_levs, lon_n, lon_factor) = grid_finder.grid_locator1(lon_min, lon_max)
        lon_levs = np.asarray(lon_levs)
        (lat_levs, lat_n, lat_factor) = grid_finder.grid_locator2(lat_min, lat_max)
        lat_levs = np.asarray(lat_levs)
        grid_info['lon_info'] = (lon_levs, lon_n, lon_factor)
        grid_info['lat_info'] = (lat_levs, lat_n, lat_factor)
        grid_info['lon_labels'] = grid_finder._format_ticks(1, 'bottom', lon_factor, lon_levs)
        grid_info['lat_labels'] = grid_finder._format_ticks(2, 'bottom', lat_factor, lat_levs)
        lon_values = lon_levs[:lon_n] / lon_factor
        lat_values = lat_levs[:lat_n] / lat_factor
        (lon_lines, lat_lines) = grid_finder._get_raw_grid_lines(lon_values[(lon_min < lon_values) & (lon_values < lon_max)], lat_values[(lat_min < lat_values) & (lat_values < lat_max)], lon_min, lon_max, lat_min, lat_max)
        grid_info['lon_lines'] = lon_lines
        grid_info['lat_lines'] = lat_lines
        (lon_lines, lat_lines) = grid_finder._get_raw_grid_lines(extremes[:2], extremes[2:], *extremes)
        grid_info['lon_lines0'] = lon_lines
        grid_info['lat_lines0'] = lat_lines

    def get_gridlines(self, which='major', axis='both'):
        grid_lines = []
        if axis in ['both', 'x']:
            grid_lines.extend(self._grid_info['lon_lines'])
        if axis in ['both', 'y']:
            grid_lines.extend(self._grid_info['lat_lines'])
        return grid_lines

class FloatingAxesBase:

    def __init__(self, *args, grid_helper, **kwargs):
        _api.check_isinstance(GridHelperCurveLinear, grid_helper=grid_helper)
        super().__init__(*args, grid_helper=grid_helper, **kwargs)
        self.set_aspect(1.0)

    def _gen_axes_patch(self):
        (x0, x1, y0, y1) = self.get_grid_helper().grid_finder.extreme_finder(*[None] * 5)
        patch = mpatches.Polygon([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])
        patch.get_path()._interpolation_steps = 100
        return patch

    def clear(self):
        super().clear()
        self.patch.set_transform(self.get_grid_helper().grid_finder.get_transform() + self.transData)
        orig_patch = super()._gen_axes_patch()
        orig_patch.set_figure(self.get_figure(root=False))
        orig_patch.set_transform(self.transAxes)
        self.patch.set_clip_path(orig_patch)
        self.gridlines.set_clip_path(orig_patch)
        self.adjust_axes_lim()

    def adjust_axes_lim(self):
        bbox = self.patch.get_path().get_extents(self.patch.get_transform() - self.transData)
        bbox = bbox.expanded(1.02, 1.02)
        self.set_xlim(bbox.xmin, bbox.xmax)
        self.set_ylim(bbox.ymin, bbox.ymax)
floatingaxes_class_factory = cbook._make_class_factory(FloatingAxesBase, 'Floating{}')
FloatingAxes = floatingaxes_class_factory(host_axes_class_factory(axislines.Axes))
FloatingSubplot = FloatingAxes

# File: matplotlib-main/lib/mpl_toolkits/axisartist/grid_finder.py
import numpy as np
from matplotlib import ticker as mticker, _api
from matplotlib.transforms import Bbox, Transform

def _find_line_box_crossings(xys, bbox):
    crossings = []
    dxys = xys[1:] - xys[:-1]
    for sl in [slice(None), slice(None, None, -1)]:
        (us, vs) = xys.T[sl]
        (dus, dvs) = dxys.T[sl]
        (umin, vmin) = bbox.min[sl]
        (umax, vmax) = bbox.max[sl]
        for (u0, inside) in [(umin, us > umin), (umax, us < umax)]:
            cross = []
            (idxs,) = (inside[:-1] ^ inside[1:]).nonzero()
            for idx in idxs:
                v = vs[idx] + (u0 - us[idx]) * dvs[idx] / dus[idx]
                if not vmin <= v <= vmax:
                    continue
                crossing = (u0, v)[sl]
                theta = np.degrees(np.arctan2(*dxys[idx][::-1]))
                cross.append((crossing, theta))
            crossings.append(cross)
    return crossings

class ExtremeFinderSimple:

    def __init__(self, nx, ny):
        self.nx = nx
        self.ny = ny

    def __call__(self, transform_xy, x1, y1, x2, y2):
        (x, y) = np.meshgrid(np.linspace(x1, x2, self.nx), np.linspace(y1, y2, self.ny))
        (xt, yt) = transform_xy(np.ravel(x), np.ravel(y))
        return self._add_pad(xt.min(), xt.max(), yt.min(), yt.max())

    def _add_pad(self, x_min, x_max, y_min, y_max):
        dx = (x_max - x_min) / self.nx
        dy = (y_max - y_min) / self.ny
        return (x_min - dx, x_max + dx, y_min - dy, y_max + dy)

class _User2DTransform(Transform):
    input_dims = output_dims = 2

    def __init__(self, forward, backward):
        super().__init__()
        self._forward = forward
        self._backward = backward

    def transform_non_affine(self, values):
        return np.transpose(self._forward(*np.transpose(values)))

    def inverted(self):
        return type(self)(self._backward, self._forward)

class GridFinder:

    def __init__(self, transform, extreme_finder=None, grid_locator1=None, grid_locator2=None, tick_formatter1=None, tick_formatter2=None):
        if extreme_finder is None:
            extreme_finder = ExtremeFinderSimple(20, 20)
        if grid_locator1 is None:
            grid_locator1 = MaxNLocator()
        if grid_locator2 is None:
            grid_locator2 = MaxNLocator()
        if tick_formatter1 is None:
            tick_formatter1 = FormatterPrettyPrint()
        if tick_formatter2 is None:
            tick_formatter2 = FormatterPrettyPrint()
        self.extreme_finder = extreme_finder
        self.grid_locator1 = grid_locator1
        self.grid_locator2 = grid_locator2
        self.tick_formatter1 = tick_formatter1
        self.tick_formatter2 = tick_formatter2
        self.set_transform(transform)

    def _format_ticks(self, idx, direction, factor, levels):
        fmt = _api.check_getitem({1: self.tick_formatter1, 2: self.tick_formatter2}, idx=idx)
        return fmt.format_ticks(levels) if isinstance(fmt, mticker.Formatter) else fmt(direction, factor, levels)

    def get_grid_info(self, x1, y1, x2, y2):
        extremes = self.extreme_finder(self.inv_transform_xy, x1, y1, x2, y2)
        (lon_min, lon_max, lat_min, lat_max) = extremes
        (lon_levs, lon_n, lon_factor) = self.grid_locator1(lon_min, lon_max)
        lon_levs = np.asarray(lon_levs)
        (lat_levs, lat_n, lat_factor) = self.grid_locator2(lat_min, lat_max)
        lat_levs = np.asarray(lat_levs)
        lon_values = lon_levs[:lon_n] / lon_factor
        lat_values = lat_levs[:lat_n] / lat_factor
        (lon_lines, lat_lines) = self._get_raw_grid_lines(lon_values, lat_values, lon_min, lon_max, lat_min, lat_max)
        bb = Bbox.from_extents(x1, y1, x2, y2).expanded(1 + 2e-10, 1 + 2e-10)
        grid_info = {'extremes': extremes}
        for (idx, lon_or_lat, levs, factor, values, lines) in [(1, 'lon', lon_levs, lon_factor, lon_values, lon_lines), (2, 'lat', lat_levs, lat_factor, lat_values, lat_lines)]:
            grid_info[lon_or_lat] = gi = {'lines': [[l] for l in lines], 'ticks': {'left': [], 'right': [], 'bottom': [], 'top': []}}
            for ((lx, ly), v, level) in zip(lines, values, levs):
                all_crossings = _find_line_box_crossings(np.column_stack([lx, ly]), bb)
                for (side, crossings) in zip(['left', 'right', 'bottom', 'top'], all_crossings):
                    for crossing in crossings:
                        gi['ticks'][side].append({'level': level, 'loc': crossing})
            for side in gi['ticks']:
                levs = [tick['level'] for tick in gi['ticks'][side]]
                labels = self._format_ticks(idx, side, factor, levs)
                for (tick, label) in zip(gi['ticks'][side], labels):
                    tick['label'] = label
        return grid_info

    def _get_raw_grid_lines(self, lon_values, lat_values, lon_min, lon_max, lat_min, lat_max):
        lons_i = np.linspace(lon_min, lon_max, 100)
        lats_i = np.linspace(lat_min, lat_max, 100)
        lon_lines = [self.transform_xy(np.full_like(lats_i, lon), lats_i) for lon in lon_values]
        lat_lines = [self.transform_xy(lons_i, np.full_like(lons_i, lat)) for lat in lat_values]
        return (lon_lines, lat_lines)

    def set_transform(self, aux_trans):
        if isinstance(aux_trans, Transform):
            self._aux_transform = aux_trans
        elif len(aux_trans) == 2 and all(map(callable, aux_trans)):
            self._aux_transform = _User2DTransform(*aux_trans)
        else:
            raise TypeError("'aux_trans' must be either a Transform instance or a pair of callables")

    def get_transform(self):
        return self._aux_transform
    update_transform = set_transform

    def transform_xy(self, x, y):
        return self._aux_transform.transform(np.column_stack([x, y])).T

    def inv_transform_xy(self, x, y):
        return self._aux_transform.inverted().transform(np.column_stack([x, y])).T

    def update(self, **kwargs):
        for (k, v) in kwargs.items():
            if k in ['extreme_finder', 'grid_locator1', 'grid_locator2', 'tick_formatter1', 'tick_formatter2']:
                setattr(self, k, v)
            else:
                raise ValueError(f'Unknown update property {k!r}')

class MaxNLocator(mticker.MaxNLocator):

    def __init__(self, nbins=10, steps=None, trim=True, integer=False, symmetric=False, prune=None):
        super().__init__(nbins, steps=steps, integer=integer, symmetric=symmetric, prune=prune)
        self.create_dummy_axis()

    def __call__(self, v1, v2):
        locs = super().tick_values(v1, v2)
        return (np.array(locs), len(locs), 1)

class FixedLocator:

    def __init__(self, locs):
        self._locs = locs

    def __call__(self, v1, v2):
        (v1, v2) = sorted([v1, v2])
        locs = np.array([l for l in self._locs if v1 <= l <= v2])
        return (locs, len(locs), 1)

class FormatterPrettyPrint:

    def __init__(self, useMathText=True):
        self._fmt = mticker.ScalarFormatter(useMathText=useMathText, useOffset=False)
        self._fmt.create_dummy_axis()

    def __call__(self, direction, factor, values):
        return self._fmt.format_ticks(values)

class DictFormatter:

    def __init__(self, format_dict, formatter=None):
        super().__init__()
        self._format_dict = format_dict
        self._fallback_formatter = formatter

    def __call__(self, direction, factor, values):
        if self._fallback_formatter:
            fallback_strings = self._fallback_formatter(direction, factor, values)
        else:
            fallback_strings = [''] * len(values)
        return [self._format_dict.get(k, v) for (k, v) in zip(values, fallback_strings)]

# File: matplotlib-main/lib/mpl_toolkits/axisartist/grid_helper_curvelinear.py
""""""
import functools
import numpy as np
import matplotlib as mpl
from matplotlib import _api
from matplotlib.path import Path
from matplotlib.transforms import Affine2D, IdentityTransform
from .axislines import _FixedAxisArtistHelperBase, _FloatingAxisArtistHelperBase, GridHelperBase
from .axis_artist import AxisArtist
from .grid_finder import GridFinder

def _value_and_jacobian(func, xs, ys, xlims, ylims):
    eps = np.finfo(float).eps ** (1 / 2)
    val = func(xs, ys)
    (xlo, xhi) = sorted(xlims)
    dxlo = xs - xlo
    dxhi = xhi - xs
    xeps = np.take([-1, 1], dxhi >= dxlo) * np.minimum(eps, np.maximum(dxlo, dxhi))
    val_dx = func(xs + xeps, ys)
    (ylo, yhi) = sorted(ylims)
    dylo = ys - ylo
    dyhi = yhi - ys
    yeps = np.take([-1, 1], dyhi >= dylo) * np.minimum(eps, np.maximum(dylo, dyhi))
    val_dy = func(xs, ys + yeps)
    return (val, (val_dx - val) / xeps, (val_dy - val) / yeps)

class FixedAxisArtistHelper(_FixedAxisArtistHelperBase):

    def __init__(self, grid_helper, side, nth_coord_ticks=None):
        super().__init__(loc=side)
        self.grid_helper = grid_helper
        if nth_coord_ticks is None:
            nth_coord_ticks = self.nth_coord
        self.nth_coord_ticks = nth_coord_ticks
        self.side = side

    def update_lim(self, axes):
        self.grid_helper.update_lim(axes)

    def get_tick_transform(self, axes):
        return axes.transData

    def get_tick_iterators(self, axes):
        (v1, v2) = axes.get_ylim() if self.nth_coord == 0 else axes.get_xlim()
        if v1 > v2:
            side = {'left': 'right', 'right': 'left', 'top': 'bottom', 'bottom': 'top'}[self.side]
        else:
            side = self.side
        angle_tangent = dict(left=90, right=90, bottom=0, top=0)[side]

        def iter_major():
            for (nth_coord, show_labels) in [(self.nth_coord_ticks, True), (1 - self.nth_coord_ticks, False)]:
                gi = self.grid_helper._grid_info[['lon', 'lat'][nth_coord]]
                for tick in gi['ticks'][side]:
                    yield (*tick['loc'], angle_tangent, tick['label'] if show_labels else '')
        return (iter_major(), iter([]))

class FloatingAxisArtistHelper(_FloatingAxisArtistHelperBase):

    def __init__(self, grid_helper, nth_coord, value, axis_direction=None):
        super().__init__(nth_coord, value)
        self.value = value
        self.grid_helper = grid_helper
        self._extremes = (-np.inf, np.inf)
        self._line_num_points = 100

    def set_extremes(self, e1, e2):
        if e1 is None:
            e1 = -np.inf
        if e2 is None:
            e2 = np.inf
        self._extremes = (e1, e2)

    def update_lim(self, axes):
        self.grid_helper.update_lim(axes)
        (x1, x2) = axes.get_xlim()
        (y1, y2) = axes.get_ylim()
        grid_finder = self.grid_helper.grid_finder
        extremes = grid_finder.extreme_finder(grid_finder.inv_transform_xy, x1, y1, x2, y2)
        (lon_min, lon_max, lat_min, lat_max) = extremes
        (e_min, e_max) = self._extremes
        if self.nth_coord == 0:
            lat_min = max(e_min, lat_min)
            lat_max = min(e_max, lat_max)
        elif self.nth_coord == 1:
            lon_min = max(e_min, lon_min)
            lon_max = min(e_max, lon_max)
        (lon_levs, lon_n, lon_factor) = grid_finder.grid_locator1(lon_min, lon_max)
        (lat_levs, lat_n, lat_factor) = grid_finder.grid_locator2(lat_min, lat_max)
        if self.nth_coord == 0:
            xx0 = np.full(self._line_num_points, self.value)
            yy0 = np.linspace(lat_min, lat_max, self._line_num_points)
            (xx, yy) = grid_finder.transform_xy(xx0, yy0)
        elif self.nth_coord == 1:
            xx0 = np.linspace(lon_min, lon_max, self._line_num_points)
            yy0 = np.full(self._line_num_points, self.value)
            (xx, yy) = grid_finder.transform_xy(xx0, yy0)
        self._grid_info = {'extremes': (lon_min, lon_max, lat_min, lat_max), 'lon_info': (lon_levs, lon_n, np.asarray(lon_factor)), 'lat_info': (lat_levs, lat_n, np.asarray(lat_factor)), 'lon_labels': grid_finder._format_ticks(1, 'bottom', lon_factor, lon_levs), 'lat_labels': grid_finder._format_ticks(2, 'bottom', lat_factor, lat_levs), 'line_xy': (xx, yy)}

    def get_axislabel_transform(self, axes):
        return Affine2D()

    def get_axislabel_pos_angle(self, axes):

        def trf_xy(x, y):
            trf = self.grid_helper.grid_finder.get_transform() + axes.transData
            return trf.transform([x, y]).T
        (xmin, xmax, ymin, ymax) = self._grid_info['extremes']
        if self.nth_coord == 0:
            xx0 = self.value
            yy0 = (ymin + ymax) / 2
        elif self.nth_coord == 1:
            xx0 = (xmin + xmax) / 2
            yy0 = self.value
        (xy1, dxy1_dx, dxy1_dy) = _value_and_jacobian(trf_xy, xx0, yy0, (xmin, xmax), (ymin, ymax))
        p = axes.transAxes.inverted().transform(xy1)
        if 0 <= p[0] <= 1 and 0 <= p[1] <= 1:
            d = [dxy1_dy, dxy1_dx][self.nth_coord]
            return (xy1, np.rad2deg(np.arctan2(*d[::-1])))
        else:
            return (None, None)

    def get_tick_transform(self, axes):
        return IdentityTransform()

    def get_tick_iterators(self, axes):
        (lat_levs, lat_n, lat_factor) = self._grid_info['lat_info']
        yy0 = lat_levs / lat_factor
        (lon_levs, lon_n, lon_factor) = self._grid_info['lon_info']
        xx0 = lon_levs / lon_factor
        (e0, e1) = self._extremes

        def trf_xy(x, y):
            trf = self.grid_helper.grid_finder.get_transform() + axes.transData
            return trf.transform(np.column_stack(np.broadcast_arrays(x, y))).T
        if self.nth_coord == 0:
            mask = (e0 <= yy0) & (yy0 <= e1)
            ((xx1, yy1), (dxx1, dyy1), (dxx2, dyy2)) = _value_and_jacobian(trf_xy, self.value, yy0[mask], (-np.inf, np.inf), (e0, e1))
            labels = self._grid_info['lat_labels']
        elif self.nth_coord == 1:
            mask = (e0 <= xx0) & (xx0 <= e1)
            ((xx1, yy1), (dxx2, dyy2), (dxx1, dyy1)) = _value_and_jacobian(trf_xy, xx0[mask], self.value, (-np.inf, np.inf), (e0, e1))
            labels = self._grid_info['lon_labels']
        labels = [l for (l, m) in zip(labels, mask) if m]
        angle_normal = np.arctan2(dyy1, dxx1)
        angle_tangent = np.arctan2(dyy2, dxx2)
        mm = (dyy1 == 0) & (dxx1 == 0)
        angle_normal[mm] = angle_tangent[mm] + np.pi / 2
        tick_to_axes = self.get_tick_transform(axes) - axes.transAxes
        in_01 = functools.partial(mpl.transforms._interval_contains_close, (0, 1))

        def iter_major():
            for (x, y, normal, tangent, lab) in zip(xx1, yy1, angle_normal, angle_tangent, labels):
                c2 = tick_to_axes.transform((x, y))
                if in_01(c2[0]) and in_01(c2[1]):
                    yield ([x, y], *np.rad2deg([normal, tangent]), lab)
        return (iter_major(), iter([]))

    def get_line_transform(self, axes):
        return axes.transData

    def get_line(self, axes):
        self.update_lim(axes)
        (x, y) = self._grid_info['line_xy']
        return Path(np.column_stack([x, y]))

class GridHelperCurveLinear(GridHelperBase):

    def __init__(self, aux_trans, extreme_finder=None, grid_locator1=None, grid_locator2=None, tick_formatter1=None, tick_formatter2=None):
        super().__init__()
        self._grid_info = None
        self.grid_finder = GridFinder(aux_trans, extreme_finder, grid_locator1, grid_locator2, tick_formatter1, tick_formatter2)

    def update_grid_finder(self, aux_trans=None, **kwargs):
        if aux_trans is not None:
            self.grid_finder.update_transform(aux_trans)
        self.grid_finder.update(**kwargs)
        self._old_limits = None

    @_api.make_keyword_only('3.9', 'nth_coord')
    def new_fixed_axis(self, loc, nth_coord=None, axis_direction=None, offset=None, axes=None):
        if axes is None:
            axes = self.axes
        if axis_direction is None:
            axis_direction = loc
        helper = FixedAxisArtistHelper(self, loc, nth_coord_ticks=nth_coord)
        axisline = AxisArtist(axes, helper, axis_direction=axis_direction)
        return axisline

    def new_floating_axis(self, nth_coord, value, axes=None, axis_direction='bottom'):
        if axes is None:
            axes = self.axes
        helper = FloatingAxisArtistHelper(self, nth_coord, value, axis_direction)
        axisline = AxisArtist(axes, helper)
        axisline.line.set_clip_on(True)
        axisline.line.set_clip_box(axisline.axes.bbox)
        return axisline

    def _update_grid(self, x1, y1, x2, y2):
        self._grid_info = self.grid_finder.get_grid_info(x1, y1, x2, y2)

    def get_gridlines(self, which='major', axis='both'):
        grid_lines = []
        if axis in ['both', 'x']:
            for gl in self._grid_info['lon']['lines']:
                grid_lines.extend(gl)
        if axis in ['both', 'y']:
            for gl in self._grid_info['lat']['lines']:
                grid_lines.extend(gl)
        return grid_lines

    @_api.deprecated('3.9')
    def get_tick_iterator(self, nth_coord, axis_side, minor=False):
        angle_tangent = dict(left=90, right=90, bottom=0, top=0)[axis_side]
        lon_or_lat = ['lon', 'lat'][nth_coord]
        if not minor:
            for tick in self._grid_info[lon_or_lat]['ticks'][axis_side]:
                yield (*tick['loc'], angle_tangent, tick['label'])
        else:
            for tick in self._grid_info[lon_or_lat]['ticks'][axis_side]:
                yield (*tick['loc'], angle_tangent, '')

# File: matplotlib-main/lib/mpl_toolkits/mplot3d/art3d.py
""""""
import math
import numpy as np
from contextlib import contextmanager
from matplotlib import _api, artist, cbook, colors as mcolors, lines, text as mtext, path as mpath
from matplotlib.collections import Collection, LineCollection, PolyCollection, PatchCollection, PathCollection
from matplotlib.colors import Normalize
from matplotlib.patches import Patch
from . import proj3d

def _norm_angle(a):
    a = (a + 360) % 360
    if a > 180:
        a = a - 360
    return a

def _norm_text_angle(a):
    a = (a + 180) % 180
    if a > 90:
        a = a - 180
    return a

def get_dir_vector(zdir):
    if zdir == 'x':
        return np.array((1, 0, 0))
    elif zdir == 'y':
        return np.array((0, 1, 0))
    elif zdir == 'z':
        return np.array((0, 0, 1))
    elif zdir is None:
        return np.array((0, 0, 0))
    elif np.iterable(zdir) and len(zdir) == 3:
        return np.array(zdir)
    else:
        raise ValueError("'x', 'y', 'z', None or vector of length 3 expected")

class Text3D(mtext.Text):

    def __init__(self, x=0, y=0, z=0, text='', zdir='z', **kwargs):
        mtext.Text.__init__(self, x, y, text, **kwargs)
        self.set_3d_properties(z, zdir)

    def get_position_3d(self):
        return (self._x, self._y, self._z)

    def set_position_3d(self, xyz, zdir=None):
        super().set_position(xyz[:2])
        self.set_z(xyz[2])
        if zdir is not None:
            self._dir_vec = get_dir_vector(zdir)

    def set_z(self, z):
        self._z = z
        self.stale = True

    def set_3d_properties(self, z=0, zdir='z'):
        self._z = z
        self._dir_vec = get_dir_vector(zdir)
        self.stale = True

    @artist.allow_rasterization
    def draw(self, renderer):
        position3d = np.array((self._x, self._y, self._z))
        proj = proj3d._proj_trans_points([position3d, position3d + self._dir_vec], self.axes.M)
        dx = proj[0][1] - proj[0][0]
        dy = proj[1][1] - proj[1][0]
        angle = math.degrees(math.atan2(dy, dx))
        with cbook._setattr_cm(self, _x=proj[0][0], _y=proj[1][0], _rotation=_norm_text_angle(angle)):
            mtext.Text.draw(self, renderer)
        self.stale = False

    def get_tightbbox(self, renderer=None):
        return None

def text_2d_to_3d(obj, z=0, zdir='z'):
    obj.__class__ = Text3D
    obj.set_3d_properties(z, zdir)

class Line3D(lines.Line2D):

    def __init__(self, xs, ys, zs, *args, **kwargs):
        super().__init__([], [], *args, **kwargs)
        self.set_data_3d(xs, ys, zs)

    def set_3d_properties(self, zs=0, zdir='z'):
        xs = self.get_xdata()
        ys = self.get_ydata()
        zs = cbook._to_unmasked_float_array(zs).ravel()
        zs = np.broadcast_to(zs, len(xs))
        self._verts3d = juggle_axes(xs, ys, zs, zdir)
        self.stale = True

    def set_data_3d(self, *args):
        if len(args) == 1:
            args = args[0]
        for (name, xyz) in zip('xyz', args):
            if not np.iterable(xyz):
                raise RuntimeError(f'{name} must be a sequence')
        self._verts3d = args
        self.stale = True

    def get_data_3d(self):
        return self._verts3d

    @artist.allow_rasterization
    def draw(self, renderer):
        (xs3d, ys3d, zs3d) = self._verts3d
        (xs, ys, zs, tis) = proj3d._proj_transform_clip(xs3d, ys3d, zs3d, self.axes.M, self.axes._focal_length)
        self.set_data(xs, ys)
        super().draw(renderer)
        self.stale = False

def line_2d_to_3d(line, zs=0, zdir='z'):
    line.__class__ = Line3D
    line.set_3d_properties(zs, zdir)

def _path_to_3d_segment(path, zs=0, zdir='z'):
    zs = np.broadcast_to(zs, len(path))
    pathsegs = path.iter_segments(simplify=False, curves=False)
    seg = [(x, y, z) for (((x, y), code), z) in zip(pathsegs, zs)]
    seg3d = [juggle_axes(x, y, z, zdir) for (x, y, z) in seg]
    return seg3d

def _paths_to_3d_segments(paths, zs=0, zdir='z'):
    if not np.iterable(zs):
        zs = np.broadcast_to(zs, len(paths))
    elif len(zs) != len(paths):
        raise ValueError('Number of z-coordinates does not match paths.')
    segs = [_path_to_3d_segment(path, pathz, zdir) for (path, pathz) in zip(paths, zs)]
    return segs

def _path_to_3d_segment_with_codes(path, zs=0, zdir='z'):
    zs = np.broadcast_to(zs, len(path))
    pathsegs = path.iter_segments(simplify=False, curves=False)
    seg_codes = [((x, y, z), code) for (((x, y), code), z) in zip(pathsegs, zs)]
    if seg_codes:
        (seg, codes) = zip(*seg_codes)
        seg3d = [juggle_axes(x, y, z, zdir) for (x, y, z) in seg]
    else:
        seg3d = []
        codes = []
    return (seg3d, list(codes))

def _paths_to_3d_segments_with_codes(paths, zs=0, zdir='z'):
    zs = np.broadcast_to(zs, len(paths))
    segments_codes = [_path_to_3d_segment_with_codes(path, pathz, zdir) for (path, pathz) in zip(paths, zs)]
    if segments_codes:
        (segments, codes) = zip(*segments_codes)
    else:
        (segments, codes) = ([], [])
    return (list(segments), list(codes))

class Collection3D(Collection):

    def do_3d_projection(self):
        xyzs_list = [proj3d.proj_transform(*vs.T, self.axes.M) for (vs, _) in self._3dverts_codes]
        self._paths = [mpath.Path(np.column_stack([xs, ys]), cs) for ((xs, ys, _), (_, cs)) in zip(xyzs_list, self._3dverts_codes)]
        zs = np.concatenate([zs for (_, _, zs) in xyzs_list])
        return zs.min() if len(zs) else 1000000000.0

def collection_2d_to_3d(col, zs=0, zdir='z'):
    zs = np.broadcast_to(zs, len(col.get_paths()))
    col._3dverts_codes = [(np.column_stack(juggle_axes(*np.column_stack([p.vertices, np.broadcast_to(z, len(p.vertices))]).T, zdir)), p.codes) for (p, z) in zip(col.get_paths(), zs)]
    col.__class__ = cbook._make_class_factory(Collection3D, '{}3D')(type(col))

class Line3DCollection(LineCollection):

    def set_sort_zpos(self, val):
        self._sort_zpos = val
        self.stale = True

    def set_segments(self, segments):
        self._segments3d = segments
        super().set_segments([])

    def do_3d_projection(self):
        xyslist = [proj3d._proj_trans_points(points, self.axes.M) for points in self._segments3d]
        segments_2d = [np.column_stack([xs, ys]) for (xs, ys, zs) in xyslist]
        LineCollection.set_segments(self, segments_2d)
        minz = 1000000000.0
        for (xs, ys, zs) in xyslist:
            minz = min(minz, min(zs))
        return minz

def line_collection_2d_to_3d(col, zs=0, zdir='z'):
    segments3d = _paths_to_3d_segments(col.get_paths(), zs, zdir)
    col.__class__ = Line3DCollection
    col.set_segments(segments3d)

class Patch3D(Patch):

    def __init__(self, *args, zs=(), zdir='z', **kwargs):
        super().__init__(*args, **kwargs)
        self.set_3d_properties(zs, zdir)

    def set_3d_properties(self, verts, zs=0, zdir='z'):
        zs = np.broadcast_to(zs, len(verts))
        self._segment3d = [juggle_axes(x, y, z, zdir) for ((x, y), z) in zip(verts, zs)]

    def get_path(self):
        if not hasattr(self, '_path2d'):
            self.axes.M = self.axes.get_proj()
            self.do_3d_projection()
        return self._path2d

    def do_3d_projection(self):
        s = self._segment3d
        (xs, ys, zs) = zip(*s)
        (vxs, vys, vzs, vis) = proj3d._proj_transform_clip(xs, ys, zs, self.axes.M, self.axes._focal_length)
        self._path2d = mpath.Path(np.column_stack([vxs, vys]))
        return min(vzs)

class PathPatch3D(Patch3D):

    def __init__(self, path, *, zs=(), zdir='z', **kwargs):
        Patch.__init__(self, **kwargs)
        self.set_3d_properties(path, zs, zdir)

    def set_3d_properties(self, path, zs=0, zdir='z'):
        Patch3D.set_3d_properties(self, path.vertices, zs=zs, zdir=zdir)
        self._code3d = path.codes

    def do_3d_projection(self):
        s = self._segment3d
        (xs, ys, zs) = zip(*s)
        (vxs, vys, vzs, vis) = proj3d._proj_transform_clip(xs, ys, zs, self.axes.M, self.axes._focal_length)
        self._path2d = mpath.Path(np.column_stack([vxs, vys]), self._code3d)
        return min(vzs)

def _get_patch_verts(patch):
    trans = patch.get_patch_transform()
    path = patch.get_path()
    polygons = path.to_polygons(trans)
    return polygons[0] if len(polygons) else np.array([])

def patch_2d_to_3d(patch, z=0, zdir='z'):
    verts = _get_patch_verts(patch)
    patch.__class__ = Patch3D
    patch.set_3d_properties(verts, z, zdir)

def pathpatch_2d_to_3d(pathpatch, z=0, zdir='z'):
    path = pathpatch.get_path()
    trans = pathpatch.get_patch_transform()
    mpath = trans.transform_path(path)
    pathpatch.__class__ = PathPatch3D
    pathpatch.set_3d_properties(mpath, z, zdir)

class Patch3DCollection(PatchCollection):

    def __init__(self, *args, zs=0, zdir='z', depthshade=True, **kwargs):
        self._depthshade = depthshade
        super().__init__(*args, **kwargs)
        self.set_3d_properties(zs, zdir)

    def get_depthshade(self):
        return self._depthshade

    def set_depthshade(self, depthshade):
        self._depthshade = depthshade
        self.stale = True

    def set_sort_zpos(self, val):
        self._sort_zpos = val
        self.stale = True

    def set_3d_properties(self, zs, zdir):
        self.update_scalarmappable()
        offsets = self.get_offsets()
        if len(offsets) > 0:
            (xs, ys) = offsets.T
        else:
            xs = []
            ys = []
        self._offsets3d = juggle_axes(xs, ys, np.atleast_1d(zs), zdir)
        self._z_markers_idx = slice(-1)
        self._vzs = None
        self.stale = True

    def do_3d_projection(self):
        (xs, ys, zs) = self._offsets3d
        (vxs, vys, vzs, vis) = proj3d._proj_transform_clip(xs, ys, zs, self.axes.M, self.axes._focal_length)
        self._vzs = vzs
        super().set_offsets(np.column_stack([vxs, vys]))
        if vzs.size > 0:
            return min(vzs)
        else:
            return np.nan

    def _maybe_depth_shade_and_sort_colors(self, color_array):
        color_array = _zalpha(color_array, self._vzs) if self._vzs is not None and self._depthshade else color_array
        if len(color_array) > 1:
            color_array = color_array[self._z_markers_idx]
        return mcolors.to_rgba_array(color_array, self._alpha)

    def get_facecolor(self):
        return self._maybe_depth_shade_and_sort_colors(super().get_facecolor())

    def get_edgecolor(self):
        if cbook._str_equal(self._edgecolors, 'face'):
            return self.get_facecolor()
        return self._maybe_depth_shade_and_sort_colors(super().get_edgecolor())

class Path3DCollection(PathCollection):

    def __init__(self, *args, zs=0, zdir='z', depthshade=True, **kwargs):
        self._depthshade = depthshade
        self._in_draw = False
        super().__init__(*args, **kwargs)
        self.set_3d_properties(zs, zdir)
        self._offset_zordered = None

    def draw(self, renderer):
        with self._use_zordered_offset():
            with cbook._setattr_cm(self, _in_draw=True):
                super().draw(renderer)

    def set_sort_zpos(self, val):
        self._sort_zpos = val
        self.stale = True

    def set_3d_properties(self, zs, zdir):
        self.update_scalarmappable()
        offsets = self.get_offsets()
        if len(offsets) > 0:
            (xs, ys) = offsets.T
        else:
            xs = []
            ys = []
        self._offsets3d = juggle_axes(xs, ys, np.atleast_1d(zs), zdir)
        self._sizes3d = self._sizes
        self._linewidths3d = np.array(self._linewidths)
        (xs, ys, zs) = self._offsets3d
        self._z_markers_idx = slice(-1)
        self._vzs = None
        self.stale = True

    def set_sizes(self, sizes, dpi=72.0):
        super().set_sizes(sizes, dpi)
        if not self._in_draw:
            self._sizes3d = sizes

    def set_linewidth(self, lw):
        super().set_linewidth(lw)
        if not self._in_draw:
            self._linewidths3d = np.array(self._linewidths)

    def get_depthshade(self):
        return self._depthshade

    def set_depthshade(self, depthshade):
        self._depthshade = depthshade
        self.stale = True

    def do_3d_projection(self):
        (xs, ys, zs) = self._offsets3d
        (vxs, vys, vzs, vis) = proj3d._proj_transform_clip(xs, ys, zs, self.axes.M, self.axes._focal_length)
        z_markers_idx = self._z_markers_idx = np.argsort(vzs)[::-1]
        self._vzs = vzs
        if len(self._sizes3d) > 1:
            self._sizes = self._sizes3d[z_markers_idx]
        if len(self._linewidths3d) > 1:
            self._linewidths = self._linewidths3d[z_markers_idx]
        PathCollection.set_offsets(self, np.column_stack((vxs, vys)))
        vzs = vzs[z_markers_idx]
        vxs = vxs[z_markers_idx]
        vys = vys[z_markers_idx]
        self._offset_zordered = np.column_stack((vxs, vys))
        return np.min(vzs) if vzs.size else np.nan

    @contextmanager
    def _use_zordered_offset(self):
        if self._offset_zordered is None:
            yield
        else:
            old_offset = self._offsets
            super().set_offsets(self._offset_zordered)
            try:
                yield
            finally:
                self._offsets = old_offset

    def _maybe_depth_shade_and_sort_colors(self, color_array):
        color_array = _zalpha(color_array, self._vzs) if self._vzs is not None and self._depthshade else color_array
        if len(color_array) > 1:
            color_array = color_array[self._z_markers_idx]
        return mcolors.to_rgba_array(color_array, self._alpha)

    def get_facecolor(self):
        return self._maybe_depth_shade_and_sort_colors(super().get_facecolor())

    def get_edgecolor(self):
        if cbook._str_equal(self._edgecolors, 'face'):
            return self.get_facecolor()
        return self._maybe_depth_shade_and_sort_colors(super().get_edgecolor())

def patch_collection_2d_to_3d(col, zs=0, zdir='z', depthshade=True):
    if isinstance(col, PathCollection):
        col.__class__ = Path3DCollection
        col._offset_zordered = None
    elif isinstance(col, PatchCollection):
        col.__class__ = Patch3DCollection
    col._depthshade = depthshade
    col._in_draw = False
    col.set_3d_properties(zs, zdir)

class Poly3DCollection(PolyCollection):

    def __init__(self, verts, *args, zsort='average', shade=False, lightsource=None, **kwargs):
        if shade:
            normals = _generate_normals(verts)
            facecolors = kwargs.get('facecolors', None)
            if facecolors is not None:
                kwargs['facecolors'] = _shade_colors(facecolors, normals, lightsource)
            edgecolors = kwargs.get('edgecolors', None)
            if edgecolors is not None:
                kwargs['edgecolors'] = _shade_colors(edgecolors, normals, lightsource)
            if facecolors is None and edgecolors is None:
                raise ValueError('You must provide facecolors, edgecolors, or both for shade to work.')
        super().__init__(verts, *args, **kwargs)
        if isinstance(verts, np.ndarray):
            if verts.ndim != 3:
                raise ValueError('verts must be a list of (N, 3) array-like')
        elif any((len(np.shape(vert)) != 2 for vert in verts)):
            raise ValueError('verts must be a list of (N, 3) array-like')
        self.set_zsort(zsort)
        self._codes3d = None
    _zsort_functions = {'average': np.average, 'min': np.min, 'max': np.max}

    def set_zsort(self, zsort):
        self._zsortfunc = self._zsort_functions[zsort]
        self._sort_zpos = None
        self.stale = True

    @_api.deprecated('3.10')
    def get_vector(self, segments3d):
        return self._get_vector(segments3d)

    def _get_vector(self, segments3d):
        if len(segments3d):
            (xs, ys, zs) = np.vstack(segments3d).T
        else:
            (xs, ys, zs) = ([], [], [])
        ones = np.ones(len(xs))
        self._vec = np.array([xs, ys, zs, ones])
        indices = [0, *np.cumsum([len(segment) for segment in segments3d])]
        self._segslices = [*map(slice, indices[:-1], indices[1:])]

    def set_verts(self, verts, closed=True):
        self._get_vector(verts)
        super().set_verts([], False)
        self._closed = closed

    def set_verts_and_codes(self, verts, codes):
        self.set_verts(verts, closed=False)
        self._codes3d = codes

    def set_3d_properties(self):
        self.update_scalarmappable()
        self._sort_zpos = None
        self.set_zsort('average')
        self._facecolor3d = PolyCollection.get_facecolor(self)
        self._edgecolor3d = PolyCollection.get_edgecolor(self)
        self._alpha3d = PolyCollection.get_alpha(self)
        self.stale = True

    def set_sort_zpos(self, val):
        self._sort_zpos = val
        self.stale = True

    def do_3d_projection(self):
        if self._A is not None:
            self.update_scalarmappable()
            if self._face_is_mapped:
                self._facecolor3d = self._facecolors
            if self._edge_is_mapped:
                self._edgecolor3d = self._edgecolors
        (txs, tys, tzs) = proj3d._proj_transform_vec(self._vec, self.axes.M)
        xyzlist = [(txs[sl], tys[sl], tzs[sl]) for sl in self._segslices]
        cface = self._facecolor3d
        cedge = self._edgecolor3d
        if len(cface) != len(xyzlist):
            cface = cface.repeat(len(xyzlist), axis=0)
        if len(cedge) != len(xyzlist):
            if len(cedge) == 0:
                cedge = cface
            else:
                cedge = cedge.repeat(len(xyzlist), axis=0)
        if xyzlist:
            z_segments_2d = sorted(((self._zsortfunc(zs), np.column_stack([xs, ys]), fc, ec, idx) for (idx, ((xs, ys, zs), fc, ec)) in enumerate(zip(xyzlist, cface, cedge))), key=lambda x: x[0], reverse=True)
            (_, segments_2d, self._facecolors2d, self._edgecolors2d, idxs) = zip(*z_segments_2d)
        else:
            segments_2d = []
            self._facecolors2d = np.empty((0, 4))
            self._edgecolors2d = np.empty((0, 4))
            idxs = []
        if self._codes3d is not None:
            codes = [self._codes3d[idx] for idx in idxs]
            PolyCollection.set_verts_and_codes(self, segments_2d, codes)
        else:
            PolyCollection.set_verts(self, segments_2d, self._closed)
        if len(self._edgecolor3d) != len(cface):
            self._edgecolors2d = self._edgecolor3d
        if self._sort_zpos is not None:
            zvec = np.array([[0], [0], [self._sort_zpos], [1]])
            ztrans = proj3d._proj_transform_vec(zvec, self.axes.M)
            return ztrans[2][0]
        elif tzs.size > 0:
            return np.min(tzs)
        else:
            return np.nan

    def set_facecolor(self, colors):
        super().set_facecolor(colors)
        self._facecolor3d = PolyCollection.get_facecolor(self)

    def set_edgecolor(self, colors):
        super().set_edgecolor(colors)
        self._edgecolor3d = PolyCollection.get_edgecolor(self)

    def set_alpha(self, alpha):
        artist.Artist.set_alpha(self, alpha)
        try:
            self._facecolor3d = mcolors.to_rgba_array(self._facecolor3d, self._alpha)
        except (AttributeError, TypeError, IndexError):
            pass
        try:
            self._edgecolors = mcolors.to_rgba_array(self._edgecolor3d, self._alpha)
        except (AttributeError, TypeError, IndexError):
            pass
        self.stale = True

    def get_facecolor(self):
        if not hasattr(self, '_facecolors2d'):
            self.axes.M = self.axes.get_proj()
            self.do_3d_projection()
        return np.asarray(self._facecolors2d)

    def get_edgecolor(self):
        if not hasattr(self, '_edgecolors2d'):
            self.axes.M = self.axes.get_proj()
            self.do_3d_projection()
        return np.asarray(self._edgecolors2d)

def poly_collection_2d_to_3d(col, zs=0, zdir='z'):
    (segments_3d, codes) = _paths_to_3d_segments_with_codes(col.get_paths(), zs, zdir)
    col.__class__ = Poly3DCollection
    col.set_verts_and_codes(segments_3d, codes)
    col.set_3d_properties()

def juggle_axes(xs, ys, zs, zdir):
    if zdir == 'x':
        return (zs, xs, ys)
    elif zdir == 'y':
        return (xs, zs, ys)
    elif zdir[0] == '-':
        return rotate_axes(xs, ys, zs, zdir)
    else:
        return (xs, ys, zs)

def rotate_axes(xs, ys, zs, zdir):
    if zdir in ('x', '-y'):
        return (ys, zs, xs)
    elif zdir in ('-x', 'y'):
        return (zs, xs, ys)
    else:
        return (xs, ys, zs)

def _zalpha(colors, zs):
    if len(colors) == 0 or len(zs) == 0:
        return np.zeros((0, 4))
    norm = Normalize(min(zs), max(zs))
    sats = 1 - norm(zs) * 0.7
    rgba = np.broadcast_to(mcolors.to_rgba_array(colors), (len(zs), 4))
    return np.column_stack([rgba[:, :3], rgba[:, 3] * sats])

def _all_points_on_plane(xs, ys, zs, atol=1e-08):
    (xs, ys, zs) = (np.asarray(xs), np.asarray(ys), np.asarray(zs))
    points = np.column_stack([xs, ys, zs])
    points = points[~np.isnan(points).any(axis=1)]
    points = np.unique(points, axis=0)
    if len(points) <= 3:
        return True
    vs = (points - points[0])[1:]
    vs = vs / np.linalg.norm(vs, axis=1)[:, np.newaxis]
    vs = np.unique(vs, axis=0)
    if len(vs) <= 2:
        return True
    cross_norms = np.linalg.norm(np.cross(vs[0], vs[1:]), axis=1)
    zero_cross_norms = np.where(np.isclose(cross_norms, 0, atol=atol))[0] + 1
    vs = np.delete(vs, zero_cross_norms, axis=0)
    if len(vs) <= 2:
        return True
    n = np.cross(vs[0], vs[1])
    n = n / np.linalg.norm(n)
    dots = np.dot(n, vs.transpose())
    return np.allclose(dots, 0, atol=atol)

def _generate_normals(polygons):
    if isinstance(polygons, np.ndarray):
        n = polygons.shape[-2]
        (i1, i2, i3) = (0, n // 3, 2 * n // 3)
        v1 = polygons[..., i1, :] - polygons[..., i2, :]
        v2 = polygons[..., i2, :] - polygons[..., i3, :]
    else:
        v1 = np.empty((len(polygons), 3))
        v2 = np.empty((len(polygons), 3))
        for (poly_i, ps) in enumerate(polygons):
            n = len(ps)
            (i1, i2, i3) = (0, n // 3, 2 * n // 3)
            v1[poly_i, :] = ps[i1, :] - ps[i2, :]
            v2[poly_i, :] = ps[i2, :] - ps[i3, :]
    return np.cross(v1, v2)

def _shade_colors(color, normals, lightsource=None):
    if lightsource is None:
        lightsource = mcolors.LightSource(azdeg=225, altdeg=19.4712)
    with np.errstate(invalid='ignore'):
        shade = normals / np.linalg.norm(normals, axis=1, keepdims=True) @ lightsource.direction
    mask = ~np.isnan(shade)
    if mask.any():
        in_norm = mcolors.Normalize(-1, 1)
        out_norm = mcolors.Normalize(0.3, 1).inverse

        def norm(x):
            return out_norm(in_norm(x))
        shade[~mask] = 0
        color = mcolors.to_rgba_array(color)
        alpha = color[:, 3]
        colors = norm(shade)[:, np.newaxis] * color
        colors[:, 3] = alpha
    else:
        colors = np.asanyarray(color).copy()
    return colors

# File: matplotlib-main/lib/mpl_toolkits/mplot3d/axes3d.py
""""""
from collections import defaultdict
import itertools
import math
import textwrap
import warnings
import numpy as np
import matplotlib as mpl
from matplotlib import _api, cbook, _docstring, _preprocess_data
import matplotlib.artist as martist
import matplotlib.collections as mcoll
import matplotlib.colors as mcolors
import matplotlib.image as mimage
import matplotlib.lines as mlines
import matplotlib.patches as mpatches
import matplotlib.container as mcontainer
import matplotlib.transforms as mtransforms
from matplotlib.axes import Axes
from matplotlib.axes._base import _axis_method_wrapper, _process_plot_format
from matplotlib.transforms import Bbox
from matplotlib.tri._triangulation import Triangulation
from . import art3d
from . import proj3d
from . import axis3d

@_docstring.interpd
@_api.define_aliases({'xlim': ['xlim3d'], 'ylim': ['ylim3d'], 'zlim': ['zlim3d']})
class Axes3D(Axes):
    name = '3d'
    _axis_names = ('x', 'y', 'z')
    Axes._shared_axes['z'] = cbook.Grouper()
    Axes._shared_axes['view'] = cbook.Grouper()

    def __init__(self, fig, rect=None, *args, elev=30, azim=-60, roll=0, shareview=None, sharez=None, proj_type='persp', focal_length=None, box_aspect=None, computed_zorder=True, **kwargs):
        if rect is None:
            rect = [0.0, 0.0, 1.0, 1.0]
        self.initial_azim = azim
        self.initial_elev = elev
        self.initial_roll = roll
        self.set_proj_type(proj_type, focal_length)
        self.computed_zorder = computed_zorder
        self.xy_viewLim = Bbox.unit()
        self.zz_viewLim = Bbox.unit()
        xymargin = 0.05 * 10 / 11
        self.xy_dataLim = Bbox([[xymargin, xymargin], [1 - xymargin, 1 - xymargin]])
        self.zz_dataLim = Bbox.unit()
        self.view_init(self.initial_elev, self.initial_azim, self.initial_roll)
        self._sharez = sharez
        if sharez is not None:
            self._shared_axes['z'].join(self, sharez)
            self._adjustable = 'datalim'
        self._shareview = shareview
        if shareview is not None:
            self._shared_axes['view'].join(self, shareview)
        if kwargs.pop('auto_add_to_figure', False):
            raise AttributeError('auto_add_to_figure is no longer supported for Axes3D. Use fig.add_axes(ax) instead.')
        super().__init__(fig, rect, *args, frameon=True, box_aspect=box_aspect, **kwargs)
        super().set_axis_off()
        self.set_axis_on()
        self.M = None
        self.invM = None
        self._view_margin = 1 / 48
        self.autoscale_view()
        self.fmt_zdata = None
        self.mouse_init()
        fig = self.get_figure(root=True)
        fig.canvas.callbacks._connect_picklable('motion_notify_event', self._on_move)
        fig.canvas.callbacks._connect_picklable('button_press_event', self._button_press)
        fig.canvas.callbacks._connect_picklable('button_release_event', self._button_release)
        self.set_top_view()
        self.patch.set_linewidth(0)
        pseudo_bbox = self.transLimits.inverted().transform([(0, 0), (1, 1)])
        (self._pseudo_w, self._pseudo_h) = pseudo_bbox[1] - pseudo_bbox[0]
        self.spines[:].set_visible(False)

    def set_axis_off(self):
        self._axis3don = False
        self.stale = True

    def set_axis_on(self):
        self._axis3don = True
        self.stale = True

    def convert_zunits(self, z):
        return self.zaxis.convert_units(z)

    def set_top_view(self):
        xdwl = 0.95 / self._dist
        xdw = 0.9 / self._dist
        ydwl = 0.95 / self._dist
        ydw = 0.9 / self._dist
        self.viewLim.intervalx = (-xdwl, xdw)
        self.viewLim.intervaly = (-ydwl, ydw)
        self.stale = True

    def _init_axis(self):
        self.xaxis = axis3d.XAxis(self)
        self.yaxis = axis3d.YAxis(self)
        self.zaxis = axis3d.ZAxis(self)

    def get_zaxis(self):
        return self.zaxis
    get_zgridlines = _axis_method_wrapper('zaxis', 'get_gridlines')
    get_zticklines = _axis_method_wrapper('zaxis', 'get_ticklines')

    def _transformed_cube(self, vals):
        (minx, maxx, miny, maxy, minz, maxz) = vals
        xyzs = [(minx, miny, minz), (maxx, miny, minz), (maxx, maxy, minz), (minx, maxy, minz), (minx, miny, maxz), (maxx, miny, maxz), (maxx, maxy, maxz), (minx, maxy, maxz)]
        return proj3d._proj_points(xyzs, self.M)

    def set_aspect(self, aspect, adjustable=None, anchor=None, share=False):
        _api.check_in_list(('auto', 'equal', 'equalxy', 'equalyz', 'equalxz'), aspect=aspect)
        super().set_aspect(aspect='auto', adjustable=adjustable, anchor=anchor, share=share)
        self._aspect = aspect
        if aspect in ('equal', 'equalxy', 'equalxz', 'equalyz'):
            ax_indices = self._equal_aspect_axis_indices(aspect)
            view_intervals = np.array([self.xaxis.get_view_interval(), self.yaxis.get_view_interval(), self.zaxis.get_view_interval()])
            ptp = np.ptp(view_intervals, axis=1)
            if self._adjustable == 'datalim':
                mean = np.mean(view_intervals, axis=1)
                scale = max(ptp[ax_indices] / self._box_aspect[ax_indices])
                deltas = scale * self._box_aspect
                for (i, set_lim) in enumerate((self.set_xlim3d, self.set_ylim3d, self.set_zlim3d)):
                    if i in ax_indices:
                        set_lim(mean[i] - deltas[i] / 2.0, mean[i] + deltas[i] / 2.0, auto=True, view_margin=None)
            else:
                box_aspect = np.array(self._box_aspect)
                box_aspect[ax_indices] = ptp[ax_indices]
                remaining_ax_indices = {0, 1, 2}.difference(ax_indices)
                if remaining_ax_indices:
                    remaining = remaining_ax_indices.pop()
                    old_diag = np.linalg.norm(self._box_aspect[ax_indices])
                    new_diag = np.linalg.norm(box_aspect[ax_indices])
                    box_aspect[remaining] *= new_diag / old_diag
                self.set_box_aspect(box_aspect)

    def _equal_aspect_axis_indices(self, aspect):
        ax_indices = []
        if aspect == 'equal':
            ax_indices = [0, 1, 2]
        elif aspect == 'equalxy':
            ax_indices = [0, 1]
        elif aspect == 'equalxz':
            ax_indices = [0, 2]
        elif aspect == 'equalyz':
            ax_indices = [1, 2]
        return ax_indices

    def set_box_aspect(self, aspect, *, zoom=1):
        if zoom <= 0:
            raise ValueError(f'Argument zoom = {zoom} must be > 0')
        if aspect is None:
            aspect = np.asarray((4, 4, 3), dtype=float)
        else:
            aspect = np.asarray(aspect, dtype=float)
            _api.check_shape((3,), aspect=aspect)
        aspect *= 1.8294640721620434 * 25 / 24 * zoom / np.linalg.norm(aspect)
        self._box_aspect = self._roll_to_vertical(aspect, reverse=True)
        self.stale = True

    def apply_aspect(self, position=None):
        if position is None:
            position = self.get_position(original=True)
        trans = self.get_figure().transSubfigure
        bb = mtransforms.Bbox.unit().transformed(trans)
        fig_aspect = bb.height / bb.width
        box_aspect = 1
        pb = position.frozen()
        pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)
        self._set_position(pb1.anchored(self.get_anchor(), pb), 'active')

    @martist.allow_rasterization
    def draw(self, renderer):
        if not self.get_visible():
            return
        self._unstale_viewLim()
        self.patch.draw(renderer)
        self._frameon = False
        locator = self.get_axes_locator()
        self.apply_aspect(locator(self, renderer) if locator else None)
        self.M = self.get_proj()
        self.invM = np.linalg.inv(self.M)
        collections_and_patches = (artist for artist in self._children if isinstance(artist, (mcoll.Collection, mpatches.Patch)) and artist.get_visible())
        if self.computed_zorder:
            zorder_offset = max((axis.get_zorder() for axis in self._axis_map.values())) + 1
            collection_zorder = patch_zorder = zorder_offset
            for artist in sorted(collections_and_patches, key=lambda artist: artist.do_3d_projection(), reverse=True):
                if isinstance(artist, mcoll.Collection):
                    artist.zorder = collection_zorder
                    collection_zorder += 1
                elif isinstance(artist, mpatches.Patch):
                    artist.zorder = patch_zorder
                    patch_zorder += 1
        else:
            for artist in collections_and_patches:
                artist.do_3d_projection()
        if self._axis3don:
            for axis in self._axis_map.values():
                axis.draw_pane(renderer)
            for axis in self._axis_map.values():
                axis.draw_grid(renderer)
            for axis in self._axis_map.values():
                axis.draw(renderer)
        super().draw(renderer)

    def get_axis_position(self):
        tc = self._transformed_cube(self.get_w_lims())
        xhigh = tc[1][2] > tc[2][2]
        yhigh = tc[3][2] > tc[2][2]
        zhigh = tc[0][2] > tc[2][2]
        return (xhigh, yhigh, zhigh)

    def update_datalim(self, xys, **kwargs):
        pass
    get_autoscalez_on = _axis_method_wrapper('zaxis', '_get_autoscale_on')
    set_autoscalez_on = _axis_method_wrapper('zaxis', '_set_autoscale_on')

    def get_zmargin(self):
        return self._zmargin

    def set_zmargin(self, m):
        if m <= -0.5:
            raise ValueError('margin must be greater than -0.5')
        self._zmargin = m
        self._request_autoscale_view('z')
        self.stale = True

    def margins(self, *margins, x=None, y=None, z=None, tight=True):
        if margins and (x is not None or y is not None or z is not None):
            raise TypeError('Cannot pass both positional and keyword arguments for x, y, and/or z.')
        elif len(margins) == 1:
            x = y = z = margins[0]
        elif len(margins) == 3:
            (x, y, z) = margins
        elif margins:
            raise TypeError('Must pass a single positional argument for all margins, or one for each margin (x, y, z).')
        if x is None and y is None and (z is None):
            if tight is not True:
                _api.warn_external(f'ignoring tight={tight!r} in get mode')
            return (self._xmargin, self._ymargin, self._zmargin)
        if x is not None:
            self.set_xmargin(x)
        if y is not None:
            self.set_ymargin(y)
        if z is not None:
            self.set_zmargin(z)
        self.autoscale_view(tight=tight, scalex=x is not None, scaley=y is not None, scalez=z is not None)

    def autoscale(self, enable=True, axis='both', tight=None):
        if enable is None:
            scalex = True
            scaley = True
            scalez = True
        else:
            if axis in ['x', 'both']:
                self.set_autoscalex_on(enable)
                scalex = self.get_autoscalex_on()
            else:
                scalex = False
            if axis in ['y', 'both']:
                self.set_autoscaley_on(enable)
                scaley = self.get_autoscaley_on()
            else:
                scaley = False
            if axis in ['z', 'both']:
                self.set_autoscalez_on(enable)
                scalez = self.get_autoscalez_on()
            else:
                scalez = False
        if scalex:
            self._request_autoscale_view('x', tight=tight)
        if scaley:
            self._request_autoscale_view('y', tight=tight)
        if scalez:
            self._request_autoscale_view('z', tight=tight)

    def auto_scale_xyz(self, X, Y, Z=None, had_data=None):
        if np.shape(X) == np.shape(Y):
            self.xy_dataLim.update_from_data_xy(np.column_stack([np.ravel(X), np.ravel(Y)]), not had_data)
        else:
            self.xy_dataLim.update_from_data_x(X, not had_data)
            self.xy_dataLim.update_from_data_y(Y, not had_data)
        if Z is not None:
            self.zz_dataLim.update_from_data_x(Z, not had_data)
        self.autoscale_view()

    def autoscale_view(self, tight=None, scalex=True, scaley=True, scalez=True):
        if tight is None:
            _tight = self._tight
            if not _tight:
                for artist in self._children:
                    if isinstance(artist, mimage.AxesImage):
                        _tight = True
                    elif isinstance(artist, (mlines.Line2D, mpatches.Patch)):
                        _tight = False
                        break
        else:
            _tight = self._tight = bool(tight)
        if scalex and self.get_autoscalex_on():
            (x0, x1) = self.xy_dataLim.intervalx
            xlocator = self.xaxis.get_major_locator()
            (x0, x1) = xlocator.nonsingular(x0, x1)
            if self._xmargin > 0:
                delta = (x1 - x0) * self._xmargin
                x0 -= delta
                x1 += delta
            if not _tight:
                (x0, x1) = xlocator.view_limits(x0, x1)
            self.set_xbound(x0, x1, self._view_margin)
        if scaley and self.get_autoscaley_on():
            (y0, y1) = self.xy_dataLim.intervaly
            ylocator = self.yaxis.get_major_locator()
            (y0, y1) = ylocator.nonsingular(y0, y1)
            if self._ymargin > 0:
                delta = (y1 - y0) * self._ymargin
                y0 -= delta
                y1 += delta
            if not _tight:
                (y0, y1) = ylocator.view_limits(y0, y1)
            self.set_ybound(y0, y1, self._view_margin)
        if scalez and self.get_autoscalez_on():
            (z0, z1) = self.zz_dataLim.intervalx
            zlocator = self.zaxis.get_major_locator()
            (z0, z1) = zlocator.nonsingular(z0, z1)
            if self._zmargin > 0:
                delta = (z1 - z0) * self._zmargin
                z0 -= delta
                z1 += delta
            if not _tight:
                (z0, z1) = zlocator.view_limits(z0, z1)
            self.set_zbound(z0, z1, self._view_margin)

    def get_w_lims(self):
        (minx, maxx) = self.get_xlim3d()
        (miny, maxy) = self.get_ylim3d()
        (minz, maxz) = self.get_zlim3d()
        return (minx, maxx, miny, maxy, minz, maxz)

    def _set_bound3d(self, get_bound, set_lim, axis_inverted, lower=None, upper=None, view_margin=None):
        if upper is None and np.iterable(lower):
            (lower, upper) = lower
        (old_lower, old_upper) = get_bound()
        if lower is None:
            lower = old_lower
        if upper is None:
            upper = old_upper
        set_lim(sorted((lower, upper), reverse=bool(axis_inverted())), auto=None, view_margin=view_margin)

    def set_xbound(self, lower=None, upper=None, view_margin=None):
        self._set_bound3d(self.get_xbound, self.set_xlim, self.xaxis_inverted, lower, upper, view_margin)

    def set_ybound(self, lower=None, upper=None, view_margin=None):
        self._set_bound3d(self.get_ybound, self.set_ylim, self.yaxis_inverted, lower, upper, view_margin)

    def set_zbound(self, lower=None, upper=None, view_margin=None):
        self._set_bound3d(self.get_zbound, self.set_zlim, self.zaxis_inverted, lower, upper, view_margin)

    def _set_lim3d(self, axis, lower=None, upper=None, *, emit=True, auto=False, view_margin=None, axmin=None, axmax=None):
        if upper is None:
            if np.iterable(lower):
                (lower, upper) = lower
            elif axmax is None:
                upper = axis.get_view_interval()[1]
        if lower is None and axmin is None:
            lower = axis.get_view_interval()[0]
        if axmin is not None:
            if lower is not None:
                raise TypeError("Cannot pass both 'lower' and 'min'")
            lower = axmin
        if axmax is not None:
            if upper is not None:
                raise TypeError("Cannot pass both 'upper' and 'max'")
            upper = axmax
        if np.isinf(lower) or np.isinf(upper):
            raise ValueError(f'Axis limits {lower}, {upper} cannot be infinite')
        if view_margin is None:
            if mpl.rcParams['axes3d.automargin']:
                view_margin = self._view_margin
            else:
                view_margin = 0
        delta = (upper - lower) * view_margin
        lower -= delta
        upper += delta
        return axis._set_lim(lower, upper, emit=emit, auto=auto)

    def set_xlim(self, left=None, right=None, *, emit=True, auto=False, view_margin=None, xmin=None, xmax=None):
        return self._set_lim3d(self.xaxis, left, right, emit=emit, auto=auto, view_margin=view_margin, axmin=xmin, axmax=xmax)

    def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False, view_margin=None, ymin=None, ymax=None):
        return self._set_lim3d(self.yaxis, bottom, top, emit=emit, auto=auto, view_margin=view_margin, axmin=ymin, axmax=ymax)

    def set_zlim(self, bottom=None, top=None, *, emit=True, auto=False, view_margin=None, zmin=None, zmax=None):
        return self._set_lim3d(self.zaxis, bottom, top, emit=emit, auto=auto, view_margin=view_margin, axmin=zmin, axmax=zmax)
    set_xlim3d = set_xlim
    set_ylim3d = set_ylim
    set_zlim3d = set_zlim

    def get_xlim(self):
        return tuple(self.xy_viewLim.intervalx)

    def get_ylim(self):
        return tuple(self.xy_viewLim.intervaly)

    def get_zlim(self):
        return tuple(self.zz_viewLim.intervalx)
    get_zscale = _axis_method_wrapper('zaxis', 'get_scale')
    set_xscale = _axis_method_wrapper('xaxis', '_set_axes_scale')
    set_yscale = _axis_method_wrapper('yaxis', '_set_axes_scale')
    set_zscale = _axis_method_wrapper('zaxis', '_set_axes_scale')
    (set_xscale.__doc__, set_yscale.__doc__, set_zscale.__doc__) = map('\n        Set the {}-axis scale.\n\n        Parameters\n        ----------\n        value : {{"linear"}}\n            The axis scale type to apply.  3D Axes currently only support\n            linear scales; other scales yield nonsensical results.\n\n        **kwargs\n            Keyword arguments are nominally forwarded to the scale class, but\n            none of them is applicable for linear scales.\n        '.format, ['x', 'y', 'z'])
    get_zticks = _axis_method_wrapper('zaxis', 'get_ticklocs')
    set_zticks = _axis_method_wrapper('zaxis', 'set_ticks')
    get_zmajorticklabels = _axis_method_wrapper('zaxis', 'get_majorticklabels')
    get_zminorticklabels = _axis_method_wrapper('zaxis', 'get_minorticklabels')
    get_zticklabels = _axis_method_wrapper('zaxis', 'get_ticklabels')
    set_zticklabels = _axis_method_wrapper('zaxis', 'set_ticklabels', doc_sub={'Axis.set_ticks': 'Axes3D.set_zticks'})
    zaxis_date = _axis_method_wrapper('zaxis', 'axis_date')
    if zaxis_date.__doc__:
        zaxis_date.__doc__ += textwrap.dedent('\n\n        Notes\n        -----\n        This function is merely provided for completeness, but 3D Axes do not\n        support dates for ticks, and so this may not work as expected.\n        ')

    def clabel(self, *args, **kwargs):
        return None

    def view_init(self, elev=None, azim=None, roll=None, vertical_axis='z', share=False):
        self._dist = 10
        if elev is None:
            elev = self.initial_elev
        if azim is None:
            azim = self.initial_azim
        if roll is None:
            roll = self.initial_roll
        vertical_axis = _api.check_getitem({name: idx for (idx, name) in enumerate(self._axis_names)}, vertical_axis=vertical_axis)
        if share:
            axes = {sibling for sibling in self._shared_axes['view'].get_siblings(self)}
        else:
            axes = [self]
        for ax in axes:
            ax.elev = elev
            ax.azim = azim
            ax.roll = roll
            ax._vertical_axis = vertical_axis

    def set_proj_type(self, proj_type, focal_length=None):
        _api.check_in_list(['persp', 'ortho'], proj_type=proj_type)
        if proj_type == 'persp':
            if focal_length is None:
                focal_length = 1
            elif focal_length <= 0:
                raise ValueError(f'focal_length = {focal_length} must be greater than 0')
            self._focal_length = focal_length
        else:
            if focal_length not in (None, np.inf):
                raise ValueError(f'focal_length = {focal_length} must be None for proj_type = {proj_type}')
            self._focal_length = np.inf

    def _roll_to_vertical(self, arr: 'np.typing.ArrayLike', reverse: bool=False) -> np.ndarray:
        if reverse:
            return np.roll(arr, (self._vertical_axis - 2) * -1)
        else:
            return np.roll(arr, self._vertical_axis - 2)

    def get_proj(self):
        box_aspect = self._roll_to_vertical(self._box_aspect)
        worldM = proj3d.world_transformation(*self.get_xlim3d(), *self.get_ylim3d(), *self.get_zlim3d(), pb_aspect=box_aspect)
        R = 0.5 * box_aspect
        elev_rad = np.deg2rad(self.elev)
        azim_rad = np.deg2rad(self.azim)
        p0 = np.cos(elev_rad) * np.cos(azim_rad)
        p1 = np.cos(elev_rad) * np.sin(azim_rad)
        p2 = np.sin(elev_rad)
        ps = self._roll_to_vertical([p0, p1, p2])
        eye = R + self._dist * ps
        (u, v, w) = self._calc_view_axes(eye)
        self._view_u = u
        self._view_v = v
        self._view_w = w
        if self._focal_length == np.inf:
            viewM = proj3d._view_transformation_uvw(u, v, w, eye)
            projM = proj3d._ortho_transformation(-self._dist, self._dist)
        else:
            eye_focal = R + self._dist * ps * self._focal_length
            viewM = proj3d._view_transformation_uvw(u, v, w, eye_focal)
            projM = proj3d._persp_transformation(-self._dist, self._dist, self._focal_length)
        M0 = np.dot(viewM, worldM)
        M = np.dot(projM, M0)
        return M

    def mouse_init(self, rotate_btn=1, pan_btn=2, zoom_btn=3):
        self.button_pressed = None
        self._rotate_btn = np.atleast_1d(rotate_btn).tolist()
        self._pan_btn = np.atleast_1d(pan_btn).tolist()
        self._zoom_btn = np.atleast_1d(zoom_btn).tolist()

    def disable_mouse_rotation(self):
        self.mouse_init(rotate_btn=[], pan_btn=[], zoom_btn=[])

    def can_zoom(self):
        return True

    def can_pan(self):
        return True

    def sharez(self, other):
        _api.check_isinstance(Axes3D, other=other)
        if self._sharez is not None and other is not self._sharez:
            raise ValueError('z-axis is already shared')
        self._shared_axes['z'].join(self, other)
        self._sharez = other
        self.zaxis.major = other.zaxis.major
        self.zaxis.minor = other.zaxis.minor
        (z0, z1) = other.get_zlim()
        self.set_zlim(z0, z1, emit=False, auto=other.get_autoscalez_on())
        self.zaxis._scale = other.zaxis._scale

    def shareview(self, other):
        _api.check_isinstance(Axes3D, other=other)
        if self._shareview is not None and other is not self._shareview:
            raise ValueError('view angles are already shared')
        self._shared_axes['view'].join(self, other)
        self._shareview = other
        vertical_axis = self._axis_names[other._vertical_axis]
        self.view_init(elev=other.elev, azim=other.azim, roll=other.roll, vertical_axis=vertical_axis, share=True)

    def clear(self):
        super().clear()
        if self._focal_length == np.inf:
            self._zmargin = mpl.rcParams['axes.zmargin']
        else:
            self._zmargin = 0.0
        xymargin = 0.05 * 10 / 11
        self.xy_dataLim = Bbox([[xymargin, xymargin], [1 - xymargin, 1 - xymargin]])
        self.zz_dataLim = Bbox.unit()
        self._view_margin = 1 / 48
        self.autoscale_view()
        self.grid(mpl.rcParams['axes3d.grid'])

    def _button_press(self, event):
        if event.inaxes == self:
            self.button_pressed = event.button
            (self._sx, self._sy) = (event.xdata, event.ydata)
            toolbar = self.get_figure(root=True).canvas.toolbar
            if toolbar and toolbar._nav_stack() is None:
                toolbar.push_current()
            if toolbar:
                toolbar.set_message(toolbar._mouse_event_to_message(event))

    def _button_release(self, event):
        self.button_pressed = None
        toolbar = self.get_figure(root=True).canvas.toolbar
        if toolbar and self.get_navigate_mode() is None:
            toolbar.push_current()
        if toolbar:
            toolbar.set_message(toolbar._mouse_event_to_message(event))

    def _get_view(self):
        return ({'xlim': self.get_xlim(), 'autoscalex_on': self.get_autoscalex_on(), 'ylim': self.get_ylim(), 'autoscaley_on': self.get_autoscaley_on(), 'zlim': self.get_zlim(), 'autoscalez_on': self.get_autoscalez_on()}, (self.elev, self.azim, self.roll))

    def _set_view(self, view):
        (props, (elev, azim, roll)) = view
        self.set(**props)
        self.elev = elev
        self.azim = azim
        self.roll = roll

    def format_zdata(self, z):
        try:
            return self.fmt_zdata(z)
        except (AttributeError, TypeError):
            func = self.zaxis.get_major_formatter().format_data_short
            val = func(z)
            return val

    def format_coord(self, xv, yv, renderer=None):
        coords = ''
        if self.button_pressed in self._rotate_btn:
            coords = self._rotation_coords()
        elif self.M is not None:
            coords = self._location_coords(xv, yv, renderer)
        return coords

    def _rotation_coords(self):
        norm_elev = art3d._norm_angle(self.elev)
        norm_azim = art3d._norm_angle(self.azim)
        norm_roll = art3d._norm_angle(self.roll)
        coords = f'elevation={norm_elev:.0f}°, azimuth={norm_azim:.0f}°, roll={norm_roll:.0f}°'.replace('-', '−')
        return coords

    def _location_coords(self, xv, yv, renderer):
        (p1, pane_idx) = self._calc_coord(xv, yv, renderer)
        xs = self.format_xdata(p1[0])
        ys = self.format_ydata(p1[1])
        zs = self.format_zdata(p1[2])
        if pane_idx == 0:
            coords = f'x pane={xs}, y={ys}, z={zs}'
        elif pane_idx == 1:
            coords = f'x={xs}, y pane={ys}, z={zs}'
        elif pane_idx == 2:
            coords = f'x={xs}, y={ys}, z pane={zs}'
        return coords

    def _get_camera_loc(self):
        (cx, cy, cz, dx, dy, dz) = self._get_w_centers_ranges()
        c = np.array([cx, cy, cz])
        r = np.array([dx, dy, dz])
        if self._focal_length == np.inf:
            focal_length = 1000000000.0
        else:
            focal_length = self._focal_length
        eye = c + self._view_w * self._dist * r / self._box_aspect * focal_length
        return eye

    def _calc_coord(self, xv, yv, renderer=None):
        if self._focal_length == np.inf:
            zv = 1
        else:
            zv = -1 / self._focal_length
        p1 = np.array(proj3d.inv_transform(xv, yv, zv, self.invM)).ravel()
        vec = self._get_camera_loc() - p1
        pane_locs = []
        for axis in self._axis_map.values():
            (xys, loc) = axis.active_pane()
            pane_locs.append(loc)
        scales = np.zeros(3)
        for i in range(3):
            if vec[i] == 0:
                scales[i] = np.inf
            else:
                scales[i] = (p1[i] - pane_locs[i]) / vec[i]
        pane_idx = np.argmin(abs(scales))
        scale = scales[pane_idx]
        p2 = p1 - scale * vec
        return (p2, pane_idx)

    def _arcball(self, x: float, y: float) -> np.ndarray:
        x *= 2
        y *= 2
        r2 = x * x + y * y
        if r2 > 1:
            p = np.array([0, x / math.sqrt(r2), y / math.sqrt(r2)])
        else:
            p = np.array([math.sqrt(1 - r2), x, y])
        return p

    def _on_move(self, event):
        if not self.button_pressed:
            return
        if self.get_navigate_mode() is not None:
            return
        if self.M is None:
            return
        (x, y) = (event.xdata, event.ydata)
        if x is None or event.inaxes != self:
            return
        (dx, dy) = (x - self._sx, y - self._sy)
        w = self._pseudo_w
        h = self._pseudo_h
        if self.button_pressed in self._rotate_btn:
            if dx == 0 and dy == 0:
                return
            elev = np.deg2rad(self.elev)
            azim = np.deg2rad(self.azim)
            roll = np.deg2rad(self.roll)
            q = _Quaternion.from_cardan_angles(elev, azim, roll)
            current_vec = self._arcball(self._sx / w, self._sy / h)
            new_vec = self._arcball(x / w, y / h)
            dq = _Quaternion.rotate_from_to(current_vec, new_vec)
            q = dq * q
            (elev, azim, roll) = q.as_cardan_angles()
            azim = np.rad2deg(azim)
            elev = np.rad2deg(elev)
            roll = np.rad2deg(roll)
            vertical_axis = self._axis_names[self._vertical_axis]
            self.view_init(elev=elev, azim=azim, roll=roll, vertical_axis=vertical_axis, share=True)
            self.stale = True
        elif self.button_pressed in self._pan_btn:
            (px, py) = self.transData.transform([self._sx, self._sy])
            self.start_pan(px, py, 2)
            self.drag_pan(2, None, event.x, event.y)
            self.end_pan()
        elif self.button_pressed in self._zoom_btn:
            scale = h / (h - dy)
            self._scale_axis_limits(scale, scale, scale)
        (self._sx, self._sy) = (x, y)
        self.get_figure(root=True).canvas.draw_idle()

    def drag_pan(self, button, key, x, y):
        p = self._pan_start
        ((xdata, ydata), (xdata_start, ydata_start)) = p.trans_inverse.transform([(x, y), (p.x, p.y)])
        (self._sx, self._sy) = (xdata, ydata)
        self.start_pan(x, y, button)
        (du, dv) = (xdata - xdata_start, ydata - ydata_start)
        dw = 0
        if key == 'x':
            dv = 0
        elif key == 'y':
            du = 0
        if du == 0 and dv == 0:
            return
        R = np.array([self._view_u, self._view_v, self._view_w])
        R = -R / self._box_aspect * self._dist
        duvw_projected = R.T @ np.array([du, dv, dw])
        (minx, maxx, miny, maxy, minz, maxz) = self.get_w_lims()
        dx = (maxx - minx) * duvw_projected[0]
        dy = (maxy - miny) * duvw_projected[1]
        dz = (maxz - minz) * duvw_projected[2]
        self.set_xlim3d(minx + dx, maxx + dx, auto=None)
        self.set_ylim3d(miny + dy, maxy + dy, auto=None)
        self.set_zlim3d(minz + dz, maxz + dz, auto=None)

    def _calc_view_axes(self, eye):
        elev_rad = np.deg2rad(art3d._norm_angle(self.elev))
        roll_rad = np.deg2rad(art3d._norm_angle(self.roll))
        R = 0.5 * self._roll_to_vertical(self._box_aspect)
        V = np.zeros(3)
        V[self._vertical_axis] = -1 if abs(elev_rad) > np.pi / 2 else 1
        (u, v, w) = proj3d._view_axes(eye, R, V, roll_rad)
        return (u, v, w)

    def _set_view_from_bbox(self, bbox, direction='in', mode=None, twinx=False, twiny=False):
        (start_x, start_y, stop_x, stop_y) = bbox
        if mode == 'x':
            start_y = self.bbox.min[1]
            stop_y = self.bbox.max[1]
        elif mode == 'y':
            start_x = self.bbox.min[0]
            stop_x = self.bbox.max[0]
        (start_x, stop_x) = np.clip(sorted([start_x, stop_x]), self.bbox.min[0], self.bbox.max[0])
        (start_y, stop_y) = np.clip(sorted([start_y, stop_y]), self.bbox.min[1], self.bbox.max[1])
        zoom_center_x = (start_x + stop_x) / 2
        zoom_center_y = (start_y + stop_y) / 2
        ax_center_x = (self.bbox.max[0] + self.bbox.min[0]) / 2
        ax_center_y = (self.bbox.max[1] + self.bbox.min[1]) / 2
        self.start_pan(zoom_center_x, zoom_center_y, 2)
        self.drag_pan(2, None, ax_center_x, ax_center_y)
        self.end_pan()
        dx = abs(start_x - stop_x)
        dy = abs(start_y - stop_y)
        scale_u = dx / (self.bbox.max[0] - self.bbox.min[0])
        scale_v = dy / (self.bbox.max[1] - self.bbox.min[1])
        scale = max(scale_u, scale_v)
        if direction == 'out':
            scale = 1 / scale
        self._zoom_data_limits(scale, scale, scale)

    def _zoom_data_limits(self, scale_u, scale_v, scale_w):
        scale = np.array([scale_u, scale_v, scale_w])
        if not np.allclose(scale, scale_u):
            R = np.array([self._view_u, self._view_v, self._view_w])
            S = scale * np.eye(3)
            scale = np.linalg.norm(R.T @ S, axis=1)
            if self._aspect in ('equal', 'equalxy', 'equalxz', 'equalyz'):
                ax_idxs = self._equal_aspect_axis_indices(self._aspect)
                min_ax_idxs = np.argmin(np.abs(scale[ax_idxs] - 1))
                scale[ax_idxs] = scale[ax_idxs][min_ax_idxs]
        self._scale_axis_limits(scale[0], scale[1], scale[2])

    def _scale_axis_limits(self, scale_x, scale_y, scale_z):
        (cx, cy, cz, dx, dy, dz) = self._get_w_centers_ranges()
        self.set_xlim3d(cx - dx * scale_x / 2, cx + dx * scale_x / 2, auto=None)
        self.set_ylim3d(cy - dy * scale_y / 2, cy + dy * scale_y / 2, auto=None)
        self.set_zlim3d(cz - dz * scale_z / 2, cz + dz * scale_z / 2, auto=None)

    def _get_w_centers_ranges(self):
        (minx, maxx, miny, maxy, minz, maxz) = self.get_w_lims()
        cx = (maxx + minx) / 2
        cy = (maxy + miny) / 2
        cz = (maxz + minz) / 2
        dx = maxx - minx
        dy = maxy - miny
        dz = maxz - minz
        return (cx, cy, cz, dx, dy, dz)

    def set_zlabel(self, zlabel, fontdict=None, labelpad=None, **kwargs):
        if labelpad is not None:
            self.zaxis.labelpad = labelpad
        return self.zaxis.set_label_text(zlabel, fontdict, **kwargs)

    def get_zlabel(self):
        label = self.zaxis.get_label()
        return label.get_text()
    get_frame_on = None
    set_frame_on = None

    def grid(self, visible=True, **kwargs):
        if len(kwargs):
            visible = True
        self._draw_grid = visible
        self.stale = True

    def tick_params(self, axis='both', **kwargs):
        _api.check_in_list(['x', 'y', 'z', 'both'], axis=axis)
        if axis in ['x', 'y', 'both']:
            super().tick_params(axis, **kwargs)
        if axis in ['z', 'both']:
            zkw = dict(kwargs)
            zkw.pop('top', None)
            zkw.pop('bottom', None)
            zkw.pop('labeltop', None)
            zkw.pop('labelbottom', None)
            self.zaxis.set_tick_params(**zkw)

    def invert_zaxis(self):
        (bottom, top) = self.get_zlim()
        self.set_zlim(top, bottom, auto=None)
    zaxis_inverted = _axis_method_wrapper('zaxis', 'get_inverted')

    def get_zbound(self):
        (lower, upper) = self.get_zlim()
        if lower < upper:
            return (lower, upper)
        else:
            return (upper, lower)

    def text(self, x, y, z, s, zdir=None, **kwargs):
        text = super().text(x, y, s, **kwargs)
        art3d.text_2d_to_3d(text, z, zdir)
        return text
    text3D = text
    text2D = Axes.text

    def plot(self, xs, ys, *args, zdir='z', **kwargs):
        had_data = self.has_data()
        if args and (not isinstance(args[0], str)):
            (zs, *args) = args
            if 'zs' in kwargs:
                raise TypeError("plot() for multiple values for argument 'zs'")
        else:
            zs = kwargs.pop('zs', 0)
        (xs, ys, zs) = cbook._broadcast_with_masks(xs, ys, zs)
        lines = super().plot(xs, ys, *args, **kwargs)
        for line in lines:
            art3d.line_2d_to_3d(line, zs=zs, zdir=zdir)
        (xs, ys, zs) = art3d.juggle_axes(xs, ys, zs, zdir)
        self.auto_scale_xyz(xs, ys, zs, had_data)
        return lines
    plot3D = plot

    def fill_between(self, x1, y1, z1, x2, y2, z2, *, where=None, mode='auto', facecolors=None, shade=None, **kwargs):
        _api.check_in_list(['auto', 'quad', 'polygon'], mode=mode)
        had_data = self.has_data()
        (x1, y1, z1, x2, y2, z2) = cbook._broadcast_with_masks(x1, y1, z1, x2, y2, z2)
        if facecolors is None:
            facecolors = [self._get_patches_for_fill.get_next_color()]
        facecolors = list(mcolors.to_rgba_array(facecolors))
        if where is None:
            where = True
        else:
            where = np.asarray(where, dtype=bool)
            if where.size != x1.size:
                raise ValueError(f'where size ({where.size}) does not match size ({x1.size})')
        where = where & ~np.isnan(x1)
        if mode == 'auto':
            if art3d._all_points_on_plane(np.concatenate((x1[where], x2[where])), np.concatenate((y1[where], y2[where])), np.concatenate((z1[where], z2[where])), atol=1e-12):
                mode = 'polygon'
            else:
                mode = 'quad'
        if shade is None:
            if mode == 'quad':
                shade = True
            else:
                shade = False
        polys = []
        for (idx0, idx1) in cbook.contiguous_regions(where):
            x1i = x1[idx0:idx1]
            y1i = y1[idx0:idx1]
            z1i = z1[idx0:idx1]
            x2i = x2[idx0:idx1]
            y2i = y2[idx0:idx1]
            z2i = z2[idx0:idx1]
            if not len(x1i):
                continue
            if mode == 'quad':
                n_polys_i = len(x1i) - 1
                polys_i = np.empty((n_polys_i, 4, 3))
                polys_i[:, 0, :] = np.column_stack((x1i[:-1], y1i[:-1], z1i[:-1]))
                polys_i[:, 1, :] = np.column_stack((x1i[1:], y1i[1:], z1i[1:]))
                polys_i[:, 2, :] = np.column_stack((x2i[1:], y2i[1:], z2i[1:]))
                polys_i[:, 3, :] = np.column_stack((x2i[:-1], y2i[:-1], z2i[:-1]))
                polys = polys + [*polys_i]
            elif mode == 'polygon':
                line1 = np.column_stack((x1i, y1i, z1i))
                line2 = np.column_stack((x2i[::-1], y2i[::-1], z2i[::-1]))
                poly = np.concatenate((line1, line2), axis=0)
                polys.append(poly)
        polyc = art3d.Poly3DCollection(polys, facecolors=facecolors, shade=shade, **kwargs)
        self.add_collection(polyc)
        self.auto_scale_xyz([x1, x2], [y1, y2], [z1, z2], had_data)
        return polyc

    def plot_surface(self, X, Y, Z, *, norm=None, vmin=None, vmax=None, lightsource=None, **kwargs):
        had_data = self.has_data()
        if Z.ndim != 2:
            raise ValueError('Argument Z must be 2-dimensional.')
        Z = cbook._to_unmasked_float_array(Z)
        (X, Y, Z) = np.broadcast_arrays(X, Y, Z)
        (rows, cols) = Z.shape
        has_stride = 'rstride' in kwargs or 'cstride' in kwargs
        has_count = 'rcount' in kwargs or 'ccount' in kwargs
        if has_stride and has_count:
            raise ValueError('Cannot specify both stride and count arguments')
        rstride = kwargs.pop('rstride', 10)
        cstride = kwargs.pop('cstride', 10)
        rcount = kwargs.pop('rcount', 50)
        ccount = kwargs.pop('ccount', 50)
        if mpl.rcParams['_internal.classic_mode']:
            compute_strides = has_count
        else:
            compute_strides = not has_stride
        if compute_strides:
            rstride = int(max(np.ceil(rows / rcount), 1))
            cstride = int(max(np.ceil(cols / ccount), 1))
        fcolors = kwargs.pop('facecolors', None)
        cmap = kwargs.get('cmap', None)
        shade = kwargs.pop('shade', cmap is None)
        if shade is None:
            raise ValueError('shade cannot be None.')
        colset = []
        if (rows - 1) % rstride == 0 and (cols - 1) % cstride == 0 and (fcolors is None):
            polys = np.stack([cbook._array_patch_perimeters(a, rstride, cstride) for a in (X, Y, Z)], axis=-1)
        else:
            row_inds = list(range(0, rows - 1, rstride)) + [rows - 1]
            col_inds = list(range(0, cols - 1, cstride)) + [cols - 1]
            polys = []
            for (rs, rs_next) in itertools.pairwise(row_inds):
                for (cs, cs_next) in itertools.pairwise(col_inds):
                    ps = [cbook._array_perimeter(a[rs:rs_next + 1, cs:cs_next + 1]) for a in (X, Y, Z)]
                    ps = np.array(ps).T
                    polys.append(ps)
                    if fcolors is not None:
                        colset.append(fcolors[rs][cs])
        if not isinstance(polys, np.ndarray) or not np.isfinite(polys).all():
            new_polys = []
            new_colset = []
            for (p, col) in itertools.zip_longest(polys, colset):
                new_poly = np.array(p)[np.isfinite(p).all(axis=1)]
                if len(new_poly):
                    new_polys.append(new_poly)
                    new_colset.append(col)
            polys = new_polys
            if fcolors is not None:
                colset = new_colset
        if fcolors is not None:
            polyc = art3d.Poly3DCollection(polys, edgecolors=colset, facecolors=colset, shade=shade, lightsource=lightsource, **kwargs)
        elif cmap:
            polyc = art3d.Poly3DCollection(polys, **kwargs)
            if isinstance(polys, np.ndarray):
                avg_z = polys[..., 2].mean(axis=-1)
            else:
                avg_z = np.array([ps[:, 2].mean() for ps in polys])
            polyc.set_array(avg_z)
            if vmin is not None or vmax is not None:
                polyc.set_clim(vmin, vmax)
            if norm is not None:
                polyc.set_norm(norm)
        else:
            color = kwargs.pop('color', None)
            if color is None:
                color = self._get_lines.get_next_color()
            color = np.array(mcolors.to_rgba(color))
            polyc = art3d.Poly3DCollection(polys, facecolors=color, shade=shade, lightsource=lightsource, **kwargs)
        self.add_collection(polyc)
        self.auto_scale_xyz(X, Y, Z, had_data)
        return polyc

    def plot_wireframe(self, X, Y, Z, **kwargs):
        had_data = self.has_data()
        if Z.ndim != 2:
            raise ValueError('Argument Z must be 2-dimensional.')
        (X, Y, Z) = np.broadcast_arrays(X, Y, Z)
        (rows, cols) = Z.shape
        has_stride = 'rstride' in kwargs or 'cstride' in kwargs
        has_count = 'rcount' in kwargs or 'ccount' in kwargs
        if has_stride and has_count:
            raise ValueError('Cannot specify both stride and count arguments')
        rstride = kwargs.pop('rstride', 1)
        cstride = kwargs.pop('cstride', 1)
        rcount = kwargs.pop('rcount', 50)
        ccount = kwargs.pop('ccount', 50)
        if mpl.rcParams['_internal.classic_mode']:
            if has_count:
                rstride = int(max(np.ceil(rows / rcount), 1)) if rcount else 0
                cstride = int(max(np.ceil(cols / ccount), 1)) if ccount else 0
        elif not has_stride:
            rstride = int(max(np.ceil(rows / rcount), 1)) if rcount else 0
            cstride = int(max(np.ceil(cols / ccount), 1)) if ccount else 0
        (tX, tY, tZ) = (np.transpose(X), np.transpose(Y), np.transpose(Z))
        if rstride:
            rii = list(range(0, rows, rstride))
            if rows > 0 and rii[-1] != rows - 1:
                rii += [rows - 1]
        else:
            rii = []
        if cstride:
            cii = list(range(0, cols, cstride))
            if cols > 0 and cii[-1] != cols - 1:
                cii += [cols - 1]
        else:
            cii = []
        if rstride == 0 and cstride == 0:
            raise ValueError('Either rstride or cstride must be non zero')
        if Z.size == 0:
            rii = []
            cii = []
        xlines = [X[i] for i in rii]
        ylines = [Y[i] for i in rii]
        zlines = [Z[i] for i in rii]
        txlines = [tX[i] for i in cii]
        tylines = [tY[i] for i in cii]
        tzlines = [tZ[i] for i in cii]
        lines = [list(zip(xl, yl, zl)) for (xl, yl, zl) in zip(xlines, ylines, zlines)] + [list(zip(xl, yl, zl)) for (xl, yl, zl) in zip(txlines, tylines, tzlines)]
        linec = art3d.Line3DCollection(lines, **kwargs)
        self.add_collection(linec)
        self.auto_scale_xyz(X, Y, Z, had_data)
        return linec

    def plot_trisurf(self, *args, color=None, norm=None, vmin=None, vmax=None, lightsource=None, **kwargs):
        had_data = self.has_data()
        if color is None:
            color = self._get_lines.get_next_color()
        color = np.array(mcolors.to_rgba(color))
        cmap = kwargs.get('cmap', None)
        shade = kwargs.pop('shade', cmap is None)
        (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
        try:
            z = kwargs.pop('Z')
        except KeyError:
            (z, *args) = args
        z = np.asarray(z)
        triangles = tri.get_masked_triangles()
        xt = tri.x[triangles]
        yt = tri.y[triangles]
        zt = z[triangles]
        verts = np.stack((xt, yt, zt), axis=-1)
        if cmap:
            polyc = art3d.Poly3DCollection(verts, *args, **kwargs)
            avg_z = verts[:, :, 2].mean(axis=1)
            polyc.set_array(avg_z)
            if vmin is not None or vmax is not None:
                polyc.set_clim(vmin, vmax)
            if norm is not None:
                polyc.set_norm(norm)
        else:
            polyc = art3d.Poly3DCollection(verts, *args, shade=shade, lightsource=lightsource, facecolors=color, **kwargs)
        self.add_collection(polyc)
        self.auto_scale_xyz(tri.x, tri.y, z, had_data)
        return polyc

    def _3d_extend_contour(self, cset, stride=5):
        dz = (cset.levels[1] - cset.levels[0]) / 2
        polyverts = []
        colors = []
        for (idx, level) in enumerate(cset.levels):
            path = cset.get_paths()[idx]
            subpaths = [*path._iter_connected_components()]
            color = cset.get_edgecolor()[idx]
            top = art3d._paths_to_3d_segments(subpaths, level - dz)
            bot = art3d._paths_to_3d_segments(subpaths, level + dz)
            if not len(top[0]):
                continue
            nsteps = max(round(len(top[0]) / stride), 2)
            stepsize = (len(top[0]) - 1) / (nsteps - 1)
            polyverts.extend([(top[0][round(i * stepsize)], top[0][round((i + 1) * stepsize)], bot[0][round((i + 1) * stepsize)], bot[0][round(i * stepsize)]) for i in range(round(nsteps) - 1)])
            colors.extend([color] * (round(nsteps) - 1))
        self.add_collection3d(art3d.Poly3DCollection(np.array(polyverts), facecolors=colors, edgecolors=colors, shade=True))
        cset.remove()

    def add_contour_set(self, cset, extend3d=False, stride=5, zdir='z', offset=None):
        zdir = '-' + zdir
        if extend3d:
            self._3d_extend_contour(cset, stride)
        else:
            art3d.collection_2d_to_3d(cset, zs=offset if offset is not None else cset.levels, zdir=zdir)

    def add_contourf_set(self, cset, zdir='z', offset=None):
        self._add_contourf_set(cset, zdir=zdir, offset=offset)

    def _add_contourf_set(self, cset, zdir='z', offset=None):
        zdir = '-' + zdir
        midpoints = cset.levels[:-1] + np.diff(cset.levels) / 2
        if cset._extend_min:
            min_level = cset.levels[0] - np.diff(cset.levels[:2]) / 2
            midpoints = np.insert(midpoints, 0, min_level)
        if cset._extend_max:
            max_level = cset.levels[-1] + np.diff(cset.levels[-2:]) / 2
            midpoints = np.append(midpoints, max_level)
        art3d.collection_2d_to_3d(cset, zs=offset if offset is not None else midpoints, zdir=zdir)
        return midpoints

    @_preprocess_data()
    def contour(self, X, Y, Z, *args, extend3d=False, stride=5, zdir='z', offset=None, **kwargs):
        had_data = self.has_data()
        (jX, jY, jZ) = art3d.rotate_axes(X, Y, Z, zdir)
        cset = super().contour(jX, jY, jZ, *args, **kwargs)
        self.add_contour_set(cset, extend3d, stride, zdir, offset)
        self.auto_scale_xyz(X, Y, Z, had_data)
        return cset
    contour3D = contour

    @_preprocess_data()
    def tricontour(self, *args, extend3d=False, stride=5, zdir='z', offset=None, **kwargs):
        had_data = self.has_data()
        (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
        X = tri.x
        Y = tri.y
        if 'Z' in kwargs:
            Z = kwargs.pop('Z')
        else:
            (Z, *args) = args
        (jX, jY, jZ) = art3d.rotate_axes(X, Y, Z, zdir)
        tri = Triangulation(jX, jY, tri.triangles, tri.mask)
        cset = super().tricontour(tri, jZ, *args, **kwargs)
        self.add_contour_set(cset, extend3d, stride, zdir, offset)
        self.auto_scale_xyz(X, Y, Z, had_data)
        return cset

    def _auto_scale_contourf(self, X, Y, Z, zdir, levels, had_data):
        dim_vals = {'x': X, 'y': Y, 'z': Z, zdir: levels}
        limits = [(np.nanmin(dim_vals[dim]), np.nanmax(dim_vals[dim])) for dim in ['x', 'y', 'z']]
        self.auto_scale_xyz(*limits, had_data)

    @_preprocess_data()
    def contourf(self, X, Y, Z, *args, zdir='z', offset=None, **kwargs):
        had_data = self.has_data()
        (jX, jY, jZ) = art3d.rotate_axes(X, Y, Z, zdir)
        cset = super().contourf(jX, jY, jZ, *args, **kwargs)
        levels = self._add_contourf_set(cset, zdir, offset)
        self._auto_scale_contourf(X, Y, Z, zdir, levels, had_data)
        return cset
    contourf3D = contourf

    @_preprocess_data()
    def tricontourf(self, *args, zdir='z', offset=None, **kwargs):
        had_data = self.has_data()
        (tri, args, kwargs) = Triangulation.get_from_args_and_kwargs(*args, **kwargs)
        X = tri.x
        Y = tri.y
        if 'Z' in kwargs:
            Z = kwargs.pop('Z')
        else:
            (Z, *args) = args
        (jX, jY, jZ) = art3d.rotate_axes(X, Y, Z, zdir)
        tri = Triangulation(jX, jY, tri.triangles, tri.mask)
        cset = super().tricontourf(tri, jZ, *args, **kwargs)
        levels = self._add_contourf_set(cset, zdir, offset)
        self._auto_scale_contourf(X, Y, Z, zdir, levels, had_data)
        return cset

    def add_collection3d(self, col, zs=0, zdir='z', autolim=True):
        had_data = self.has_data()
        zvals = np.atleast_1d(zs)
        zsortval = np.min(zvals) if zvals.size else 0
        if type(col) is mcoll.PolyCollection:
            art3d.poly_collection_2d_to_3d(col, zs=zs, zdir=zdir)
            col.set_sort_zpos(zsortval)
        elif type(col) is mcoll.LineCollection:
            art3d.line_collection_2d_to_3d(col, zs=zs, zdir=zdir)
            col.set_sort_zpos(zsortval)
        elif type(col) is mcoll.PatchCollection:
            art3d.patch_collection_2d_to_3d(col, zs=zs, zdir=zdir)
            col.set_sort_zpos(zsortval)
        if autolim:
            if isinstance(col, art3d.Line3DCollection):
                self.auto_scale_xyz(*np.array(col._segments3d).transpose(), had_data=had_data)
            elif isinstance(col, art3d.Poly3DCollection):
                self.auto_scale_xyz(*col._vec[:-1], had_data=had_data)
            elif isinstance(col, art3d.Patch3DCollection):
                pass
        collection = super().add_collection(col)
        return collection

    @_preprocess_data(replace_names=['xs', 'ys', 'zs', 's', 'edgecolors', 'c', 'facecolor', 'facecolors', 'color'])
    def scatter(self, xs, ys, zs=0, zdir='z', s=20, c=None, depthshade=True, *args, **kwargs):
        had_data = self.has_data()
        zs_orig = zs
        (xs, ys, zs) = cbook._broadcast_with_masks(xs, ys, zs)
        s = np.ma.ravel(s)
        (xs, ys, zs, s, c, color) = cbook.delete_masked_points(xs, ys, zs, s, c, kwargs.get('color', None))
        if kwargs.get('color') is not None:
            kwargs['color'] = color
        if np.may_share_memory(zs_orig, zs):
            zs = zs.copy()
        patches = super().scatter(xs, ys, *args, s=s, c=c, **kwargs)
        art3d.patch_collection_2d_to_3d(patches, zs=zs, zdir=zdir, depthshade=depthshade)
        if self._zmargin < 0.05 and xs.size > 0:
            self.set_zmargin(0.05)
        self.auto_scale_xyz(xs, ys, zs, had_data)
        return patches
    scatter3D = scatter

    @_preprocess_data()
    def bar(self, left, height, zs=0, zdir='z', *args, **kwargs):
        had_data = self.has_data()
        patches = super().bar(left, height, *args, **kwargs)
        zs = np.broadcast_to(zs, len(left), subok=True)
        verts = []
        verts_zs = []
        for (p, z) in zip(patches, zs):
            vs = art3d._get_patch_verts(p)
            verts += vs.tolist()
            verts_zs += [z] * len(vs)
            art3d.patch_2d_to_3d(p, z, zdir)
            if 'alpha' in kwargs:
                p.set_alpha(kwargs['alpha'])
        if len(verts) > 0:
            (xs, ys) = zip(*verts)
        else:
            (xs, ys) = ([], [])
        (xs, ys, verts_zs) = art3d.juggle_axes(xs, ys, verts_zs, zdir)
        self.auto_scale_xyz(xs, ys, verts_zs, had_data)
        return patches

    @_preprocess_data()
    def bar3d(self, x, y, z, dx, dy, dz, color=None, zsort='average', shade=True, lightsource=None, *args, **kwargs):
        had_data = self.has_data()
        (x, y, z, dx, dy, dz) = np.broadcast_arrays(np.atleast_1d(x), y, z, dx, dy, dz)
        minx = np.min(x)
        maxx = np.max(x + dx)
        miny = np.min(y)
        maxy = np.max(y + dy)
        minz = np.min(z)
        maxz = np.max(z + dz)
        cuboid = np.array([((0, 0, 0), (0, 1, 0), (1, 1, 0), (1, 0, 0)), ((0, 0, 1), (1, 0, 1), (1, 1, 1), (0, 1, 1)), ((0, 0, 0), (1, 0, 0), (1, 0, 1), (0, 0, 1)), ((0, 1, 0), (0, 1, 1), (1, 1, 1), (1, 1, 0)), ((0, 0, 0), (0, 0, 1), (0, 1, 1), (0, 1, 0)), ((1, 0, 0), (1, 1, 0), (1, 1, 1), (1, 0, 1))])
        polys = np.empty(x.shape + cuboid.shape)
        for (i, p, dp) in [(0, x, dx), (1, y, dy), (2, z, dz)]:
            p = p[..., np.newaxis, np.newaxis]
            dp = dp[..., np.newaxis, np.newaxis]
            polys[..., i] = p + dp * cuboid[..., i]
        polys = polys.reshape((-1,) + polys.shape[2:])
        facecolors = []
        if color is None:
            color = [self._get_patches_for_fill.get_next_color()]
        color = list(mcolors.to_rgba_array(color))
        if len(color) == len(x):
            for c in color:
                facecolors.extend([c] * 6)
        else:
            facecolors = color
            if len(facecolors) < len(x):
                facecolors *= 6 * len(x)
        col = art3d.Poly3DCollection(polys, *args, zsort=zsort, facecolors=facecolors, shade=shade, lightsource=lightsource, **kwargs)
        self.add_collection(col)
        self.auto_scale_xyz((minx, maxx), (miny, maxy), (minz, maxz), had_data)
        return col

    def set_title(self, label, fontdict=None, loc='center', **kwargs):
        ret = super().set_title(label, fontdict=fontdict, loc=loc, **kwargs)
        (x, y) = self.title.get_position()
        self.title.set_y(0.92 * y)
        return ret

    @_preprocess_data()
    def quiver(self, X, Y, Z, U, V, W, *, length=1, arrow_length_ratio=0.3, pivot='tail', normalize=False, **kwargs):

        def calc_arrows(UVW):
            x = UVW[:, 0]
            y = UVW[:, 1]
            norm = np.linalg.norm(UVW[:, :2], axis=1)
            x_p = np.divide(y, norm, where=norm != 0, out=np.zeros_like(x))
            y_p = np.divide(-x, norm, where=norm != 0, out=np.ones_like(x))
            rangle = math.radians(15)
            c = math.cos(rangle)
            s = math.sin(rangle)
            r13 = y_p * s
            r32 = x_p * s
            r12 = x_p * y_p * (1 - c)
            Rpos = np.array([[c + x_p ** 2 * (1 - c), r12, r13], [r12, c + y_p ** 2 * (1 - c), -r32], [-r13, r32, np.full_like(x_p, c)]])
            Rneg = Rpos.copy()
            Rneg[[0, 1, 2, 2], [2, 2, 0, 1]] *= -1
            Rpos_vecs = np.einsum('ij...,...j->...i', Rpos, UVW)
            Rneg_vecs = np.einsum('ij...,...j->...i', Rneg, UVW)
            return np.stack([Rpos_vecs, Rneg_vecs], axis=1)
        had_data = self.has_data()
        input_args = cbook._broadcast_with_masks(X, Y, Z, U, V, W, compress=True)
        if any((len(v) == 0 for v in input_args)):
            linec = art3d.Line3DCollection([], **kwargs)
            self.add_collection(linec)
            return linec
        shaft_dt = np.array([0.0, length], dtype=float)
        arrow_dt = shaft_dt * arrow_length_ratio
        _api.check_in_list(['tail', 'middle', 'tip'], pivot=pivot)
        if pivot == 'tail':
            shaft_dt -= length
        elif pivot == 'middle':
            shaft_dt -= length / 2
        XYZ = np.column_stack(input_args[:3])
        UVW = np.column_stack(input_args[3:]).astype(float)
        if normalize:
            norm = np.linalg.norm(UVW, axis=1)
            norm[norm == 0] = 1
            UVW = UVW / norm.reshape((-1, 1))
        if len(XYZ) > 0:
            shafts = (XYZ - np.multiply.outer(shaft_dt, UVW)).swapaxes(0, 1)
            head_dirs = calc_arrows(UVW)
            heads = shafts[:, :1] - np.multiply.outer(arrow_dt, head_dirs)
            heads = heads.reshape((len(arrow_dt), -1, 3))
            heads = heads.swapaxes(0, 1)
            lines = [*shafts, *heads[::2], *heads[1::2]]
        else:
            lines = []
        linec = art3d.Line3DCollection(lines, **kwargs)
        self.add_collection(linec)
        self.auto_scale_xyz(XYZ[:, 0], XYZ[:, 1], XYZ[:, 2], had_data)
        return linec
    quiver3D = quiver

    def voxels(self, *args, facecolors=None, edgecolors=None, shade=True, lightsource=None, **kwargs):
        if len(args) >= 3:

            def voxels(__x, __y, __z, filled, **kwargs):
                return ((__x, __y, __z), filled, kwargs)
        else:

            def voxels(filled, **kwargs):
                return (None, filled, kwargs)
        (xyz, filled, kwargs) = voxels(*args, **kwargs)
        if filled.ndim != 3:
            raise ValueError('Argument filled must be 3-dimensional')
        size = np.array(filled.shape, dtype=np.intp)
        coord_shape = tuple(size + 1)
        if xyz is None:
            (x, y, z) = np.indices(coord_shape)
        else:
            (x, y, z) = (np.broadcast_to(c, coord_shape) for c in xyz)

        def _broadcast_color_arg(color, name):
            if np.ndim(color) in (0, 1):
                return np.broadcast_to(color, filled.shape + np.shape(color))
            elif np.ndim(color) in (3, 4):
                if np.shape(color)[:3] != filled.shape:
                    raise ValueError(f'When multidimensional, {name} must match the shape of filled')
                return color
            else:
                raise ValueError(f'Invalid {name} argument')
        if facecolors is None:
            facecolors = self._get_patches_for_fill.get_next_color()
        facecolors = _broadcast_color_arg(facecolors, 'facecolors')
        edgecolors = _broadcast_color_arg(edgecolors, 'edgecolors')
        self.auto_scale_xyz(x, y, z)
        square = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], dtype=np.intp)
        voxel_faces = defaultdict(list)

        def permutation_matrices(n):
            mat = np.eye(n, dtype=np.intp)
            for i in range(n):
                yield mat
                mat = np.roll(mat, 1, axis=0)
        for permute in permutation_matrices(3):
            (pc, qc, rc) = permute.T.dot(size)
            pinds = np.arange(pc)
            qinds = np.arange(qc)
            rinds = np.arange(rc)
            square_rot_pos = square.dot(permute.T)
            square_rot_neg = square_rot_pos[::-1]
            for p in pinds:
                for q in qinds:
                    p0 = permute.dot([p, q, 0])
                    i0 = tuple(p0)
                    if filled[i0]:
                        voxel_faces[i0].append(p0 + square_rot_neg)
                    for (r1, r2) in itertools.pairwise(rinds):
                        p1 = permute.dot([p, q, r1])
                        p2 = permute.dot([p, q, r2])
                        i1 = tuple(p1)
                        i2 = tuple(p2)
                        if filled[i1] and (not filled[i2]):
                            voxel_faces[i1].append(p2 + square_rot_pos)
                        elif not filled[i1] and filled[i2]:
                            voxel_faces[i2].append(p2 + square_rot_neg)
                    pk = permute.dot([p, q, rc - 1])
                    pk2 = permute.dot([p, q, rc])
                    ik = tuple(pk)
                    if filled[ik]:
                        voxel_faces[ik].append(pk2 + square_rot_pos)
        polygons = {}
        for (coord, faces_inds) in voxel_faces.items():
            if xyz is None:
                faces = faces_inds
            else:
                faces = []
                for face_inds in faces_inds:
                    ind = (face_inds[:, 0], face_inds[:, 1], face_inds[:, 2])
                    face = np.empty(face_inds.shape)
                    face[:, 0] = x[ind]
                    face[:, 1] = y[ind]
                    face[:, 2] = z[ind]
                    faces.append(face)
            facecolor = facecolors[coord]
            edgecolor = edgecolors[coord]
            poly = art3d.Poly3DCollection(faces, facecolors=facecolor, edgecolors=edgecolor, shade=shade, lightsource=lightsource, **kwargs)
            self.add_collection3d(poly)
            polygons[coord] = poly
        return polygons

    @_preprocess_data(replace_names=['x', 'y', 'z', 'xerr', 'yerr', 'zerr'])
    def errorbar(self, x, y, z, zerr=None, yerr=None, xerr=None, fmt='', barsabove=False, errorevery=1, ecolor=None, elinewidth=None, capsize=None, capthick=None, xlolims=False, xuplims=False, ylolims=False, yuplims=False, zlolims=False, zuplims=False, **kwargs):
        had_data = self.has_data()
        kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
        kwargs = {k: v for (k, v) in kwargs.items() if v is not None}
        kwargs.setdefault('zorder', 2)
        self._process_unit_info([('x', x), ('y', y), ('z', z)], kwargs, convert=False)
        x = x if np.iterable(x) else [x]
        y = y if np.iterable(y) else [y]
        z = z if np.iterable(z) else [z]
        if not len(x) == len(y) == len(z):
            raise ValueError("'x', 'y', and 'z' must have the same size")
        everymask = self._errorevery_to_mask(x, errorevery)
        label = kwargs.pop('label', None)
        kwargs['label'] = '_nolegend_'
        ((data_line, base_style),) = self._get_lines._plot_args(self, (x, y) if fmt == '' else (x, y, fmt), kwargs, return_kwargs=True)
        art3d.line_2d_to_3d(data_line, zs=z)
        if barsabove:
            data_line.set_zorder(kwargs['zorder'] - 0.1)
        else:
            data_line.set_zorder(kwargs['zorder'] + 0.1)
        if fmt.lower() != 'none':
            self.add_line(data_line)
        else:
            data_line = None
            base_style.pop('color')
        if 'color' not in base_style:
            base_style['color'] = 'C0'
        if ecolor is None:
            ecolor = base_style['color']
        for key in ['marker', 'markersize', 'markerfacecolor', 'markeredgewidth', 'markeredgecolor', 'markevery', 'linestyle', 'fillstyle', 'drawstyle', 'dash_capstyle', 'dash_joinstyle', 'solid_capstyle', 'solid_joinstyle']:
            base_style.pop(key, None)
        eb_lines_style = {**base_style, 'color': ecolor}
        if elinewidth:
            eb_lines_style['linewidth'] = elinewidth
        elif 'linewidth' in kwargs:
            eb_lines_style['linewidth'] = kwargs['linewidth']
        for key in ('transform', 'alpha', 'zorder', 'rasterized'):
            if key in kwargs:
                eb_lines_style[key] = kwargs[key]
        eb_cap_style = {**base_style, 'linestyle': 'None'}
        if capsize is None:
            capsize = mpl.rcParams['errorbar.capsize']
        if capsize > 0:
            eb_cap_style['markersize'] = 2.0 * capsize
        if capthick is not None:
            eb_cap_style['markeredgewidth'] = capthick
        eb_cap_style['color'] = ecolor

        def _apply_mask(arrays, mask):
            return [[*itertools.compress(array, mask)] for array in arrays]

        def _extract_errs(err, data, lomask, himask):
            if len(err.shape) == 2:
                (low_err, high_err) = err
            else:
                (low_err, high_err) = (err, err)
            lows = np.where(lomask | ~everymask, data, data - low_err)
            highs = np.where(himask | ~everymask, data, data + high_err)
            return (lows, highs)
        (errlines, caplines, limmarks) = ([], [], [])
        coorderrs = []
        capmarker = {0: '|', 1: '|', 2: '_'}
        i_xyz = {'x': 0, 'y': 1, 'z': 2}
        quiversize = eb_cap_style.get('markersize', mpl.rcParams['lines.markersize']) ** 2
        quiversize *= self.get_figure(root=True).dpi / 72
        quiversize = self.transAxes.inverted().transform([(0, 0), (quiversize, quiversize)])
        quiversize = np.mean(np.diff(quiversize, axis=0))
        with cbook._setattr_cm(self, elev=0, azim=0, roll=0):
            invM = np.linalg.inv(self.get_proj())
        quiversize = np.dot(invM, [quiversize, 0, 0, 0])[1]
        quiversize *= 1.8660254037844388
        eb_quiver_style = {**eb_cap_style, 'length': quiversize, 'arrow_length_ratio': 1}
        eb_quiver_style.pop('markersize', None)
        for (zdir, data, err, lolims, uplims) in zip(['x', 'y', 'z'], [x, y, z], [xerr, yerr, zerr], [xlolims, ylolims, zlolims], [xuplims, yuplims, zuplims]):
            dir_vector = art3d.get_dir_vector(zdir)
            i_zdir = i_xyz[zdir]
            if err is None:
                continue
            if not np.iterable(err):
                err = [err] * len(data)
            err = np.atleast_1d(err)
            lolims = np.broadcast_to(lolims, len(data)).astype(bool)
            uplims = np.broadcast_to(uplims, len(data)).astype(bool)
            coorderr = [_extract_errs(err * dir_vector[i], coord, lolims, uplims) for (i, coord) in enumerate([x, y, z])]
            ((xl, xh), (yl, yh), (zl, zh)) = coorderr
            nolims = ~(lolims | uplims)
            if nolims.any() and capsize > 0:
                lo_caps_xyz = _apply_mask([xl, yl, zl], nolims & everymask)
                hi_caps_xyz = _apply_mask([xh, yh, zh], nolims & everymask)
                cap_lo = art3d.Line3D(*lo_caps_xyz, ls='', marker=capmarker[i_zdir], **eb_cap_style)
                cap_hi = art3d.Line3D(*hi_caps_xyz, ls='', marker=capmarker[i_zdir], **eb_cap_style)
                self.add_line(cap_lo)
                self.add_line(cap_hi)
                caplines.append(cap_lo)
                caplines.append(cap_hi)
            if lolims.any():
                (xh0, yh0, zh0) = _apply_mask([xh, yh, zh], lolims & everymask)
                self.quiver(xh0, yh0, zh0, *dir_vector, **eb_quiver_style)
            if uplims.any():
                (xl0, yl0, zl0) = _apply_mask([xl, yl, zl], uplims & everymask)
                self.quiver(xl0, yl0, zl0, *-dir_vector, **eb_quiver_style)
            errline = art3d.Line3DCollection(np.array(coorderr).T, **eb_lines_style)
            self.add_collection(errline)
            errlines.append(errline)
            coorderrs.append(coorderr)
        coorderrs = np.array(coorderrs)

        def _digout_minmax(err_arr, coord_label):
            return (np.nanmin(err_arr[:, i_xyz[coord_label], :, :]), np.nanmax(err_arr[:, i_xyz[coord_label], :, :]))
        (minx, maxx) = _digout_minmax(coorderrs, 'x')
        (miny, maxy) = _digout_minmax(coorderrs, 'y')
        (minz, maxz) = _digout_minmax(coorderrs, 'z')
        self.auto_scale_xyz((minx, maxx), (miny, maxy), (minz, maxz), had_data)
        errorbar_container = mcontainer.ErrorbarContainer((data_line, tuple(caplines), tuple(errlines)), has_xerr=xerr is not None or yerr is not None, has_yerr=zerr is not None, label=label)
        self.containers.append(errorbar_container)
        return (errlines, caplines, limmarks)

    def get_tightbbox(self, renderer=None, *, call_axes_locator=True, bbox_extra_artists=None, for_layout_only=False):
        ret = super().get_tightbbox(renderer, call_axes_locator=call_axes_locator, bbox_extra_artists=bbox_extra_artists, for_layout_only=for_layout_only)
        batch = [ret]
        if self._axis3don:
            for axis in self._axis_map.values():
                if axis.get_visible():
                    axis_bb = martist._get_tightbbox_for_layout_only(axis, renderer)
                    if axis_bb:
                        batch.append(axis_bb)
        return mtransforms.Bbox.union(batch)

    @_preprocess_data()
    def stem(self, x, y, z, *, linefmt='C0-', markerfmt='C0o', basefmt='C3-', bottom=0, label=None, orientation='z'):
        from matplotlib.container import StemContainer
        had_data = self.has_data()
        _api.check_in_list(['x', 'y', 'z'], orientation=orientation)
        xlim = (np.min(x), np.max(x))
        ylim = (np.min(y), np.max(y))
        zlim = (np.min(z), np.max(z))
        if orientation == 'x':
            (basex, basexlim) = (y, ylim)
            (basey, baseylim) = (z, zlim)
            lines = [[(bottom, thisy, thisz), (thisx, thisy, thisz)] for (thisx, thisy, thisz) in zip(x, y, z)]
        elif orientation == 'y':
            (basex, basexlim) = (x, xlim)
            (basey, baseylim) = (z, zlim)
            lines = [[(thisx, bottom, thisz), (thisx, thisy, thisz)] for (thisx, thisy, thisz) in zip(x, y, z)]
        else:
            (basex, basexlim) = (x, xlim)
            (basey, baseylim) = (y, ylim)
            lines = [[(thisx, thisy, bottom), (thisx, thisy, thisz)] for (thisx, thisy, thisz) in zip(x, y, z)]
        (linestyle, linemarker, linecolor) = _process_plot_format(linefmt)
        if linestyle is None:
            linestyle = mpl.rcParams['lines.linestyle']
        (baseline,) = self.plot(basex, basey, basefmt, zs=bottom, zdir=orientation, label='_nolegend_')
        stemlines = art3d.Line3DCollection(lines, linestyles=linestyle, colors=linecolor, label='_nolegend_')
        self.add_collection(stemlines)
        (markerline,) = self.plot(x, y, z, markerfmt, label='_nolegend_')
        stem_container = StemContainer((markerline, stemlines, baseline), label=label)
        self.add_container(stem_container)
        (jx, jy, jz) = art3d.juggle_axes(basexlim, baseylim, [bottom, bottom], orientation)
        self.auto_scale_xyz([*jx, *xlim], [*jy, *ylim], [*jz, *zlim], had_data)
        return stem_container
    stem3D = stem

def get_test_data(delta=0.05):
    x = y = np.arange(-3.0, 3.0, delta)
    (X, Y) = np.meshgrid(x, y)
    Z1 = np.exp(-(X ** 2 + Y ** 2) / 2) / (2 * np.pi)
    Z2 = np.exp(-(((X - 1) / 1.5) ** 2 + ((Y - 1) / 0.5) ** 2) / 2) / (2 * np.pi * 0.5 * 1.5)
    Z = Z2 - Z1
    X = X * 10
    Y = Y * 10
    Z = Z * 500
    return (X, Y, Z)

class _Quaternion:

    def __init__(self, scalar, vector):
        self.scalar = scalar
        self.vector = np.array(vector)

    def __neg__(self):
        return self.__class__(-self.scalar, -self.vector)

    def __mul__(self, other):
        return self.__class__(self.scalar * other.scalar - np.dot(self.vector, other.vector), self.scalar * other.vector + self.vector * other.scalar + np.cross(self.vector, other.vector))

    def conjugate(self):
        return self.__class__(self.scalar, -self.vector)

    @property
    def norm(self):
        return self.scalar * self.scalar + np.dot(self.vector, self.vector)

    def normalize(self):
        n = np.sqrt(self.norm)
        return self.__class__(self.scalar / n, self.vector / n)

    def reciprocal(self):
        n = self.norm
        return self.__class__(self.scalar / n, -self.vector / n)

    def __div__(self, other):
        return self * other.reciprocal()
    __truediv__ = __div__

    def rotate(self, v):
        v = self.__class__(0, v)
        v = self * v / self
        return v.vector

    def __eq__(self, other):
        return self.scalar == other.scalar and (self.vector == other.vector).all

    def __repr__(self):
        return '_Quaternion({}, {})'.format(repr(self.scalar), repr(self.vector))

    @classmethod
    def rotate_from_to(cls, r1, r2):
        k = np.cross(r1, r2)
        nk = np.linalg.norm(k)
        th = np.arctan2(nk, np.dot(r1, r2))
        th = th / 2
        if nk == 0:
            if np.dot(r1, r2) < 0:
                warnings.warn('Rotation defined by anti-parallel vectors is ambiguous')
                k = np.zeros(3)
                k[np.argmin(r1 * r1)] = 1
                k = np.cross(r1, k)
                k = k / np.linalg.norm(k)
                q = cls(0, k)
            else:
                q = cls(1, [0, 0, 0])
        else:
            q = cls(math.cos(th), k * math.sin(th) / nk)
        return q

    @classmethod
    def from_cardan_angles(cls, elev, azim, roll):
        (ca, sa) = (np.cos(azim / 2), np.sin(azim / 2))
        (ce, se) = (np.cos(elev / 2), np.sin(elev / 2))
        (cr, sr) = (np.cos(roll / 2), np.sin(roll / 2))
        qw = ca * ce * cr + sa * se * sr
        qx = ca * ce * sr - sa * se * cr
        qy = ca * se * cr + sa * ce * sr
        qz = ca * se * sr - sa * ce * cr
        return cls(qw, [qx, qy, qz])

    def as_cardan_angles(self):
        qw = self.scalar
        (qx, qy, qz) = self.vector[..., :]
        azim = np.arctan2(2 * (-qw * qz + qx * qy), qw * qw + qx * qx - qy * qy - qz * qz)
        elev = np.arcsin(2 * (qw * qy + qz * qx) / (qw * qw + qx * qx + qy * qy + qz * qz))
        roll = np.arctan2(2 * (qw * qx - qy * qz), qw * qw - qx * qx - qy * qy + qz * qz)
        return (elev, azim, roll)

# File: matplotlib-main/lib/mpl_toolkits/mplot3d/axis3d.py
import inspect
import numpy as np
import matplotlib as mpl
from matplotlib import _api, artist, lines as mlines, axis as maxis, patches as mpatches, transforms as mtransforms, colors as mcolors
from . import art3d, proj3d

def _move_from_center(coord, centers, deltas, axmask=(True, True, True)):
    coord = np.asarray(coord)
    return coord + axmask * np.copysign(1, coord - centers) * deltas

def _tick_update_position(tick, tickxs, tickys, labelpos):
    tick.label1.set_position(labelpos)
    tick.label2.set_position(labelpos)
    tick.tick1line.set_visible(True)
    tick.tick2line.set_visible(False)
    tick.tick1line.set_linestyle('-')
    tick.tick1line.set_marker('')
    tick.tick1line.set_data(tickxs, tickys)
    tick.gridline.set_data([0], [0])

class Axis(maxis.XAxis):
    _PLANES = ((0, 3, 7, 4), (1, 2, 6, 5), (0, 1, 5, 4), (3, 2, 6, 7), (0, 1, 2, 3), (4, 5, 6, 7))
    _AXINFO = {'x': {'i': 0, 'tickdir': 1, 'juggled': (1, 0, 2)}, 'y': {'i': 1, 'tickdir': 0, 'juggled': (0, 1, 2)}, 'z': {'i': 2, 'tickdir': 0, 'juggled': (0, 2, 1)}}

    def _old_init(self, adir, v_intervalx, d_intervalx, axes, *args, rotate_label=None, **kwargs):
        return locals()

    def _new_init(self, axes, *, rotate_label=None, **kwargs):
        return locals()

    def __init__(self, *args, **kwargs):
        params = _api.select_matching_signature([self._old_init, self._new_init], *args, **kwargs)
        if 'adir' in params:
            _api.warn_deprecated('3.6', message=f'The signature of 3D Axis constructors has changed in %(since)s; the new signature is {inspect.signature(type(self).__init__)}', pending=True)
            if params['adir'] != self.axis_name:
                raise ValueError(f"Cannot instantiate {type(self).__name__} with adir={params['adir']!r}")
        axes = params['axes']
        rotate_label = params['rotate_label']
        args = params.get('args', ())
        kwargs = params['kwargs']
        name = self.axis_name
        self._label_position = 'default'
        self._tick_position = 'default'
        self._axinfo = self._AXINFO[name].copy()
        self._axinfo.update({'label': {'va': 'center', 'ha': 'center', 'rotation_mode': 'anchor'}, 'color': mpl.rcParams[f'axes3d.{name}axis.panecolor'], 'tick': {'inward_factor': 0.2, 'outward_factor': 0.1}})
        if mpl.rcParams['_internal.classic_mode']:
            self._axinfo.update({'axisline': {'linewidth': 0.75, 'color': (0, 0, 0, 1)}, 'grid': {'color': (0.9, 0.9, 0.9, 1), 'linewidth': 1.0, 'linestyle': '-'}})
            self._axinfo['tick'].update({'linewidth': {True: mpl.rcParams['lines.linewidth'], False: mpl.rcParams['lines.linewidth']}})
        else:
            self._axinfo.update({'axisline': {'linewidth': mpl.rcParams['axes.linewidth'], 'color': mpl.rcParams['axes.edgecolor']}, 'grid': {'color': mpl.rcParams['grid.color'], 'linewidth': mpl.rcParams['grid.linewidth'], 'linestyle': mpl.rcParams['grid.linestyle']}})
            self._axinfo['tick'].update({'linewidth': {True: mpl.rcParams['xtick.major.width'] if name in 'xz' else mpl.rcParams['ytick.major.width'], False: mpl.rcParams['xtick.minor.width'] if name in 'xz' else mpl.rcParams['ytick.minor.width']}})
        super().__init__(axes, *args, **kwargs)
        if 'd_intervalx' in params:
            self.set_data_interval(*params['d_intervalx'])
        if 'v_intervalx' in params:
            self.set_view_interval(*params['v_intervalx'])
        self.set_rotate_label(rotate_label)
        self._init3d()
    __init__.__signature__ = inspect.signature(_new_init)
    adir = _api.deprecated('3.6', pending=True)(property(lambda self: self.axis_name))

    def _init3d(self):
        self.line = mlines.Line2D(xdata=(0, 0), ydata=(0, 0), linewidth=self._axinfo['axisline']['linewidth'], color=self._axinfo['axisline']['color'], antialiased=True)
        self.pane = mpatches.Polygon([[0, 0], [0, 1]], closed=False)
        self.set_pane_color(self._axinfo['color'])
        self.axes._set_artist_props(self.line)
        self.axes._set_artist_props(self.pane)
        self.gridlines = art3d.Line3DCollection([])
        self.axes._set_artist_props(self.gridlines)
        self.axes._set_artist_props(self.label)
        self.axes._set_artist_props(self.offsetText)
        self.label._transform = self.axes.transData
        self.offsetText._transform = self.axes.transData

    @_api.deprecated('3.6', pending=True)
    def init3d(self):
        self._init3d()

    def get_major_ticks(self, numticks=None):
        ticks = super().get_major_ticks(numticks)
        for t in ticks:
            for obj in [t.tick1line, t.tick2line, t.gridline, t.label1, t.label2]:
                obj.set_transform(self.axes.transData)
        return ticks

    def get_minor_ticks(self, numticks=None):
        ticks = super().get_minor_ticks(numticks)
        for t in ticks:
            for obj in [t.tick1line, t.tick2line, t.gridline, t.label1, t.label2]:
                obj.set_transform(self.axes.transData)
        return ticks

    def set_ticks_position(self, position):
        if position in ['top', 'bottom']:
            _api.warn_deprecated('3.8', name=f'position={position!r}', obj_type='argument value', alternative="'upper' or 'lower'")
            return
        _api.check_in_list(['lower', 'upper', 'both', 'default', 'none'], position=position)
        self._tick_position = position

    def get_ticks_position(self):
        return self._tick_position

    def set_label_position(self, position):
        if position in ['top', 'bottom']:
            _api.warn_deprecated('3.8', name=f'position={position!r}', obj_type='argument value', alternative="'upper' or 'lower'")
            return
        _api.check_in_list(['lower', 'upper', 'both', 'default', 'none'], position=position)
        self._label_position = position

    def get_label_position(self):
        return self._label_position

    def set_pane_color(self, color, alpha=None):
        color = mcolors.to_rgba(color, alpha)
        self._axinfo['color'] = color
        self.pane.set_edgecolor(color)
        self.pane.set_facecolor(color)
        self.pane.set_alpha(color[-1])
        self.stale = True

    def set_rotate_label(self, val):
        self._rotate_label = val
        self.stale = True

    def get_rotate_label(self, text):
        if self._rotate_label is not None:
            return self._rotate_label
        else:
            return len(text) > 4

    def _get_coord_info(self):
        (mins, maxs) = np.array([self.axes.get_xbound(), self.axes.get_ybound(), self.axes.get_zbound()]).T
        bounds = (mins[0], maxs[0], mins[1], maxs[1], mins[2], maxs[2])
        bounds_proj = self.axes._transformed_cube(bounds)
        means_z0 = np.zeros(3)
        means_z1 = np.zeros(3)
        for i in range(3):
            means_z0[i] = np.mean(bounds_proj[self._PLANES[2 * i], 2])
            means_z1[i] = np.mean(bounds_proj[self._PLANES[2 * i + 1], 2])
        highs = means_z0 < means_z1
        equals = np.abs(means_z0 - means_z1) <= np.finfo(float).eps
        if np.sum(equals) == 2:
            vertical = np.where(~equals)[0][0]
            if vertical == 2:
                highs = np.array([True, True, highs[2]])
            elif vertical == 1:
                highs = np.array([True, highs[1], False])
            elif vertical == 0:
                highs = np.array([highs[0], False, False])
        return (mins, maxs, bounds_proj, highs)

    def _calc_centers_deltas(self, maxs, mins):
        centers = 0.5 * (maxs + mins)
        scale = 0.08
        deltas = (maxs - mins) * scale
        return (centers, deltas)

    def _get_axis_line_edge_points(self, minmax, maxmin, position=None):
        mb = [minmax, maxmin]
        mb_rev = mb[::-1]
        mm = [[mb, mb_rev, mb_rev], [mb_rev, mb_rev, mb], [mb, mb, mb]]
        mm = mm[self.axes._vertical_axis][self._axinfo['i']]
        juggled = self._axinfo['juggled']
        edge_point_0 = mm[0].copy()
        if position == 'lower' and mm[1][juggled[-1]] < mm[0][juggled[-1]] or (position == 'upper' and mm[1][juggled[-1]] > mm[0][juggled[-1]]):
            edge_point_0[juggled[-1]] = mm[1][juggled[-1]]
        else:
            edge_point_0[juggled[0]] = mm[1][juggled[0]]
        edge_point_1 = edge_point_0.copy()
        edge_point_1[juggled[1]] = mm[1][juggled[1]]
        return (edge_point_0, edge_point_1)

    def _get_all_axis_line_edge_points(self, minmax, maxmin, axis_position=None):
        edgep1s = []
        edgep2s = []
        position = []
        if axis_position in (None, 'default'):
            (edgep1, edgep2) = self._get_axis_line_edge_points(minmax, maxmin)
            edgep1s = [edgep1]
            edgep2s = [edgep2]
            position = ['default']
        else:
            (edgep1_l, edgep2_l) = self._get_axis_line_edge_points(minmax, maxmin, position='lower')
            (edgep1_u, edgep2_u) = self._get_axis_line_edge_points(minmax, maxmin, position='upper')
            if axis_position in ('lower', 'both'):
                edgep1s.append(edgep1_l)
                edgep2s.append(edgep2_l)
                position.append('lower')
            if axis_position in ('upper', 'both'):
                edgep1s.append(edgep1_u)
                edgep2s.append(edgep2_u)
                position.append('upper')
        return (edgep1s, edgep2s, position)

    def _get_tickdir(self, position):
        _api.check_in_list(('upper', 'lower', 'default'), position=position)
        tickdirs_base = [v['tickdir'] for v in self._AXINFO.values()]
        elev_mod = np.mod(self.axes.elev + 180, 360) - 180
        azim_mod = np.mod(self.axes.azim, 360)
        if position == 'upper':
            if elev_mod >= 0:
                tickdirs_base = [2, 2, 0]
            else:
                tickdirs_base = [1, 0, 0]
            if 0 <= azim_mod < 180:
                tickdirs_base[2] = 1
        elif position == 'lower':
            if elev_mod >= 0:
                tickdirs_base = [1, 0, 1]
            else:
                tickdirs_base = [2, 2, 1]
            if 0 <= azim_mod < 180:
                tickdirs_base[2] = 0
        info_i = [v['i'] for v in self._AXINFO.values()]
        i = self._axinfo['i']
        vert_ax = self.axes._vertical_axis
        j = vert_ax - 2
        tickdir = np.roll(info_i, -j)[np.roll(tickdirs_base, j)][i]
        return tickdir

    def active_pane(self):
        (mins, maxs, tc, highs) = self._get_coord_info()
        info = self._axinfo
        index = info['i']
        if not highs[index]:
            loc = mins[index]
            plane = self._PLANES[2 * index]
        else:
            loc = maxs[index]
            plane = self._PLANES[2 * index + 1]
        xys = np.array([tc[p] for p in plane])
        return (xys, loc)

    def draw_pane(self, renderer):
        renderer.open_group('pane3d', gid=self.get_gid())
        (xys, loc) = self.active_pane()
        self.pane.xy = xys[:, :2]
        self.pane.draw(renderer)
        renderer.close_group('pane3d')

    def _axmask(self):
        axmask = [True, True, True]
        axmask[self._axinfo['i']] = False
        return axmask

    def _draw_ticks(self, renderer, edgep1, centers, deltas, highs, deltas_per_point, pos):
        ticks = self._update_ticks()
        info = self._axinfo
        index = info['i']
        juggled = info['juggled']
        (mins, maxs, tc, highs) = self._get_coord_info()
        (centers, deltas) = self._calc_centers_deltas(maxs, mins)
        tickdir = self._get_tickdir(pos)
        tickdelta = deltas[tickdir] if highs[tickdir] else -deltas[tickdir]
        tick_info = info['tick']
        tick_out = tick_info['outward_factor'] * tickdelta
        tick_in = tick_info['inward_factor'] * tickdelta
        tick_lw = tick_info['linewidth']
        edgep1_tickdir = edgep1[tickdir]
        out_tickdir = edgep1_tickdir + tick_out
        in_tickdir = edgep1_tickdir - tick_in
        default_label_offset = 8.0
        points = deltas_per_point * deltas
        for tick in ticks:
            pos = edgep1.copy()
            pos[index] = tick.get_loc()
            pos[tickdir] = out_tickdir
            (x1, y1, z1) = proj3d.proj_transform(*pos, self.axes.M)
            pos[tickdir] = in_tickdir
            (x2, y2, z2) = proj3d.proj_transform(*pos, self.axes.M)
            labeldeltas = (tick.get_pad() + default_label_offset) * points
            pos[tickdir] = edgep1_tickdir
            pos = _move_from_center(pos, centers, labeldeltas, self._axmask())
            (lx, ly, lz) = proj3d.proj_transform(*pos, self.axes.M)
            _tick_update_position(tick, (x1, x2), (y1, y2), (lx, ly))
            tick.tick1line.set_linewidth(tick_lw[tick._major])
            tick.draw(renderer)

    def _draw_offset_text(self, renderer, edgep1, edgep2, labeldeltas, centers, highs, pep, dx, dy):
        info = self._axinfo
        index = info['i']
        juggled = info['juggled']
        tickdir = info['tickdir']
        if juggled[2] == 2:
            outeredgep = edgep1
            outerindex = 0
        else:
            outeredgep = edgep2
            outerindex = 1
        pos = _move_from_center(outeredgep, centers, labeldeltas, self._axmask())
        (olx, oly, olz) = proj3d.proj_transform(*pos, self.axes.M)
        self.offsetText.set_text(self.major.formatter.get_offset())
        self.offsetText.set_position((olx, oly))
        angle = art3d._norm_text_angle(np.rad2deg(np.arctan2(dy, dx)))
        self.offsetText.set_rotation(angle)
        self.offsetText.set_rotation_mode('anchor')
        centpt = proj3d.proj_transform(*centers, self.axes.M)
        if centpt[tickdir] > pep[tickdir, outerindex]:
            if centpt[index] <= pep[index, outerindex] and np.count_nonzero(highs) % 2 == 0:
                if highs.tolist() == [False, True, True] and index in (1, 2):
                    align = 'left'
                else:
                    align = 'right'
            else:
                align = 'left'
        elif centpt[index] > pep[index, outerindex] and np.count_nonzero(highs) % 2 == 0:
            align = 'right' if index == 2 else 'left'
        else:
            align = 'right'
        self.offsetText.set_va('center')
        self.offsetText.set_ha(align)
        self.offsetText.draw(renderer)

    def _draw_labels(self, renderer, edgep1, edgep2, labeldeltas, centers, dx, dy):
        label = self._axinfo['label']
        lxyz = 0.5 * (edgep1 + edgep2)
        lxyz = _move_from_center(lxyz, centers, labeldeltas, self._axmask())
        (tlx, tly, tlz) = proj3d.proj_transform(*lxyz, self.axes.M)
        self.label.set_position((tlx, tly))
        if self.get_rotate_label(self.label.get_text()):
            angle = art3d._norm_text_angle(np.rad2deg(np.arctan2(dy, dx)))
            self.label.set_rotation(angle)
        self.label.set_va(label['va'])
        self.label.set_ha(label['ha'])
        self.label.set_rotation_mode(label['rotation_mode'])
        self.label.draw(renderer)

    @artist.allow_rasterization
    def draw(self, renderer):
        self.label._transform = self.axes.transData
        self.offsetText._transform = self.axes.transData
        renderer.open_group('axis3d', gid=self.get_gid())
        (mins, maxs, tc, highs) = self._get_coord_info()
        (centers, deltas) = self._calc_centers_deltas(maxs, mins)
        reltoinches = self.get_figure(root=False).dpi_scale_trans.inverted()
        ax_inches = reltoinches.transform(self.axes.bbox.size)
        ax_points_estimate = sum(72.0 * ax_inches)
        deltas_per_point = 48 / ax_points_estimate
        default_offset = 21.0
        labeldeltas = (self.labelpad + default_offset) * deltas_per_point * deltas
        minmax = np.where(highs, maxs, mins)
        maxmin = np.where(~highs, maxs, mins)
        for (edgep1, edgep2, pos) in zip(*self._get_all_axis_line_edge_points(minmax, maxmin, self._tick_position)):
            pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
            pep = np.asarray(pep)
            (dx, dy) = (self.axes.transAxes.transform([pep[0:2, 1]]) - self.axes.transAxes.transform([pep[0:2, 0]]))[0]
            self.line.set_data(pep[0], pep[1])
            self.line.draw(renderer)
            self._draw_ticks(renderer, edgep1, centers, deltas, highs, deltas_per_point, pos)
            self._draw_offset_text(renderer, edgep1, edgep2, labeldeltas, centers, highs, pep, dx, dy)
        for (edgep1, edgep2, pos) in zip(*self._get_all_axis_line_edge_points(minmax, maxmin, self._label_position)):
            pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
            pep = np.asarray(pep)
            (dx, dy) = (self.axes.transAxes.transform([pep[0:2, 1]]) - self.axes.transAxes.transform([pep[0:2, 0]]))[0]
            self._draw_labels(renderer, edgep1, edgep2, labeldeltas, centers, dx, dy)
        renderer.close_group('axis3d')
        self.stale = False

    @artist.allow_rasterization
    def draw_grid(self, renderer):
        if not self.axes._draw_grid:
            return
        renderer.open_group('grid3d', gid=self.get_gid())
        ticks = self._update_ticks()
        if len(ticks):
            info = self._axinfo
            index = info['i']
            (mins, maxs, tc, highs) = self._get_coord_info()
            minmax = np.where(highs, maxs, mins)
            maxmin = np.where(~highs, maxs, mins)
            xyz0 = np.tile(minmax, (len(ticks), 1))
            xyz0[:, index] = [tick.get_loc() for tick in ticks]
            lines = np.stack([xyz0, xyz0, xyz0], axis=1)
            lines[:, 0, index - 2] = maxmin[index - 2]
            lines[:, 2, index - 1] = maxmin[index - 1]
            self.gridlines.set_segments(lines)
            gridinfo = info['grid']
            self.gridlines.set_color(gridinfo['color'])
            self.gridlines.set_linewidth(gridinfo['linewidth'])
            self.gridlines.set_linestyle(gridinfo['linestyle'])
            self.gridlines.do_3d_projection()
            self.gridlines.draw(renderer)
        renderer.close_group('grid3d')

    def get_tightbbox(self, renderer=None, *, for_layout_only=False):
        if not self.get_visible():
            return
        major_locs = self.get_majorticklocs()
        minor_locs = self.get_minorticklocs()
        ticks = [*self.get_minor_ticks(len(minor_locs)), *self.get_major_ticks(len(major_locs))]
        (view_low, view_high) = self.get_view_interval()
        if view_low > view_high:
            (view_low, view_high) = (view_high, view_low)
        interval_t = self.get_transform().transform([view_low, view_high])
        ticks_to_draw = []
        for tick in ticks:
            try:
                loc_t = self.get_transform().transform(tick.get_loc())
            except AssertionError:
                pass
            else:
                if mtransforms._interval_contains_close(interval_t, loc_t):
                    ticks_to_draw.append(tick)
        ticks = ticks_to_draw
        (bb_1, bb_2) = self._get_ticklabel_bboxes(ticks, renderer)
        other = []
        if self.line.get_visible():
            other.append(self.line.get_window_extent(renderer))
        if self.label.get_visible() and (not for_layout_only) and self.label.get_text():
            other.append(self.label.get_window_extent(renderer))
        return mtransforms.Bbox.union([*bb_1, *bb_2, *other])
    d_interval = _api.deprecated('3.6', alternative='get_data_interval', pending=True)(property(lambda self: self.get_data_interval(), lambda self, minmax: self.set_data_interval(*minmax)))
    v_interval = _api.deprecated('3.6', alternative='get_view_interval', pending=True)(property(lambda self: self.get_view_interval(), lambda self, minmax: self.set_view_interval(*minmax)))

class XAxis(Axis):
    axis_name = 'x'
    (get_view_interval, set_view_interval) = maxis._make_getset_interval('view', 'xy_viewLim', 'intervalx')
    (get_data_interval, set_data_interval) = maxis._make_getset_interval('data', 'xy_dataLim', 'intervalx')

class YAxis(Axis):
    axis_name = 'y'
    (get_view_interval, set_view_interval) = maxis._make_getset_interval('view', 'xy_viewLim', 'intervaly')
    (get_data_interval, set_data_interval) = maxis._make_getset_interval('data', 'xy_dataLim', 'intervaly')

class ZAxis(Axis):
    axis_name = 'z'
    (get_view_interval, set_view_interval) = maxis._make_getset_interval('view', 'zz_viewLim', 'intervalx')
    (get_data_interval, set_data_interval) = maxis._make_getset_interval('data', 'zz_dataLim', 'intervalx')

# File: matplotlib-main/lib/mpl_toolkits/mplot3d/proj3d.py
""""""
import numpy as np
from matplotlib import _api

def world_transformation(xmin, xmax, ymin, ymax, zmin, zmax, pb_aspect=None):
    dx = xmax - xmin
    dy = ymax - ymin
    dz = zmax - zmin
    if pb_aspect is not None:
        (ax, ay, az) = pb_aspect
        dx /= ax
        dy /= ay
        dz /= az
    return np.array([[1 / dx, 0, 0, -xmin / dx], [0, 1 / dy, 0, -ymin / dy], [0, 0, 1 / dz, -zmin / dz], [0, 0, 0, 1]])

def _rotation_about_vector(v, angle):
    (vx, vy, vz) = v / np.linalg.norm(v)
    s = np.sin(angle)
    c = np.cos(angle)
    t = 2 * np.sin(angle / 2) ** 2
    R = np.array([[t * vx * vx + c, t * vx * vy - vz * s, t * vx * vz + vy * s], [t * vy * vx + vz * s, t * vy * vy + c, t * vy * vz - vx * s], [t * vz * vx - vy * s, t * vz * vy + vx * s, t * vz * vz + c]])
    return R

def _view_axes(E, R, V, roll):
    w = E - R
    w = w / np.linalg.norm(w)
    u = np.cross(V, w)
    u = u / np.linalg.norm(u)
    v = np.cross(w, u)
    if roll != 0:
        Rroll = _rotation_about_vector(w, -roll)
        u = np.dot(Rroll, u)
        v = np.dot(Rroll, v)
    return (u, v, w)

def _view_transformation_uvw(u, v, w, E):
    Mr = np.eye(4)
    Mt = np.eye(4)
    Mr[:3, :3] = [u, v, w]
    Mt[:3, -1] = -E
    M = np.dot(Mr, Mt)
    return M

def _persp_transformation(zfront, zback, focal_length):
    e = focal_length
    a = 1
    b = (zfront + zback) / (zfront - zback)
    c = -2 * (zfront * zback) / (zfront - zback)
    proj_matrix = np.array([[e, 0, 0, 0], [0, e / a, 0, 0], [0, 0, b, c], [0, 0, -1, 0]])
    return proj_matrix

def _ortho_transformation(zfront, zback):
    a = -(zfront + zback)
    b = -(zfront - zback)
    proj_matrix = np.array([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, -2, 0], [0, 0, a, b]])
    return proj_matrix

def _proj_transform_vec(vec, M):
    vecw = np.dot(M, vec)
    w = vecw[3]
    (txs, tys, tzs) = (vecw[0] / w, vecw[1] / w, vecw[2] / w)
    return (txs, tys, tzs)

def _proj_transform_vec_clip(vec, M, focal_length):
    vecw = np.dot(M, vec)
    w = vecw[3]
    (txs, tys, tzs) = (vecw[0] / w, vecw[1] / w, vecw[2] / w)
    if np.isinf(focal_length):
        tis = np.ones(txs.shape, dtype=bool)
    else:
        tis = (-1 <= txs) & (txs <= 1) & (-1 <= tys) & (tys <= 1) & (tzs <= 0)
    txs = np.ma.masked_array(txs, ~tis)
    tys = np.ma.masked_array(tys, ~tis)
    tzs = np.ma.masked_array(tzs, ~tis)
    return (txs, tys, tzs, tis)

def inv_transform(xs, ys, zs, invM):
    vec = _vec_pad_ones(xs, ys, zs)
    vecr = np.dot(invM, vec)
    if vecr.shape == (4,):
        vecr = vecr.reshape((4, 1))
    for i in range(vecr.shape[1]):
        if vecr[3][i] != 0:
            vecr[:, i] = vecr[:, i] / vecr[3][i]
    return (vecr[0], vecr[1], vecr[2])

def _vec_pad_ones(xs, ys, zs):
    return np.array([xs, ys, zs, np.ones_like(xs)])

def proj_transform(xs, ys, zs, M):
    vec = _vec_pad_ones(xs, ys, zs)
    return _proj_transform_vec(vec, M)

@_api.deprecated('3.10')
def proj_transform_clip(xs, ys, zs, M):
    return _proj_transform_clip(xs, ys, zs, M, focal_length=np.inf)

def _proj_transform_clip(xs, ys, zs, M, focal_length):
    vec = _vec_pad_ones(xs, ys, zs)
    return _proj_transform_vec_clip(vec, M, focal_length)

def _proj_points(points, M):
    return np.column_stack(_proj_trans_points(points, M))

def _proj_trans_points(points, M):
    (xs, ys, zs) = zip(*points)
    return proj_transform(xs, ys, zs, M)

# File: matplotlib-main/tools/boilerplate.py
""""""
import ast
from enum import Enum
import functools
import inspect
from inspect import Parameter
from pathlib import Path
import sys
import subprocess
import numpy as np
from matplotlib import _api, mlab
from matplotlib.axes import Axes
from matplotlib.figure import Figure
PYPLOT_MAGIC_HEADER = '################# REMAINING CONTENT GENERATED BY boilerplate.py ##############\n'
AUTOGEN_MSG = '\n\n# Autogenerated by boilerplate.py.  Do not edit as changes will be lost.'
AXES_CMAPPABLE_METHOD_TEMPLATE = AUTOGEN_MSG + '\n@_copy_docstring_and_deprecators(Axes.{called_name})\ndef {name}{signature}:\n    __ret = gca().{called_name}{call}\n    {sci_command}\n    return __ret\n'
AXES_METHOD_TEMPLATE = AUTOGEN_MSG + '\n@_copy_docstring_and_deprecators(Axes.{called_name})\ndef {name}{signature}:\n    {return_statement}gca().{called_name}{call}\n'
FIGURE_METHOD_TEMPLATE = AUTOGEN_MSG + '\n@_copy_docstring_and_deprecators(Figure.{called_name})\ndef {name}{signature}:\n    {return_statement}gcf().{called_name}{call}\n'
CMAP_TEMPLATE = '\ndef {name}() -> None:\n    """\n    Set the colormap to {name!r}.\n\n    This changes the default colormap as well as the colormap of the current\n    image if there is one. See ``help(colormaps)`` for more information.\n    """\n    set_cmap({name!r})\n'

class value_formatter:

    def __init__(self, value):
        if value is mlab.detrend_none:
            self._repr = 'mlab.detrend_none'
        elif value is mlab.window_hanning:
            self._repr = 'mlab.window_hanning'
        elif value is np.mean:
            self._repr = 'np.mean'
        elif value is _api.deprecation._deprecated_parameter:
            self._repr = '_api.deprecation._deprecated_parameter'
        elif isinstance(value, Enum):
            self._repr = f'{type(value).__name__}.{value.name}'
        else:
            self._repr = repr(value)

    def __repr__(self):
        return self._repr

class direct_repr:

    def __init__(self, value):
        self._repr = value

    def __repr__(self):
        return self._repr

def generate_function(name, called_fullname, template, **kwargs):
    (class_name, called_name) = called_fullname.split('.')
    class_ = {'Axes': Axes, 'Figure': Figure}[class_name]
    meth = getattr(class_, called_name)
    decorator = _api.deprecation.DECORATORS.get(meth)
    if decorator and decorator.func is _api.make_keyword_only:
        meth = meth.__wrapped__
    annotated_trees = get_ast_mro_trees(class_)
    signature = get_matching_signature(meth, annotated_trees)
    params = list(signature.parameters.values())[1:]
    has_return_value = str(signature.return_annotation) != 'None'
    signature = str(signature.replace(parameters=[param.replace(default=value_formatter(param.default)) if param.default is not param.empty else param for param in params]))
    call = '(' + ', '.join((('{0}' if param.kind in [Parameter.POSITIONAL_OR_KEYWORD] and param.default is Parameter.empty else '**({{"data": data}} if data is not None else {{}})' if param.name == 'data' else '{0}={0}' if param.kind in [Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY] else '{0}' if param.kind is Parameter.POSITIONAL_ONLY else '*{0}' if param.kind is Parameter.VAR_POSITIONAL else '**{0}' if param.kind is Parameter.VAR_KEYWORD else None).format(param.name) for param in params)) + ')'
    return_statement = 'return ' if has_return_value else ''
    for reserved in ('gca', 'gci', 'gcf', '__ret'):
        if reserved in params:
            raise ValueError(f'Method {called_fullname} has kwarg named {reserved}')
    return template.format(name=name, called_name=called_name, signature=signature, call=call, return_statement=return_statement, **kwargs)

def boilerplate_gen():
    _figure_commands = ('figimage', 'figtext:text', 'gca', 'gci:_gci', 'ginput', 'subplots_adjust', 'suptitle', 'tight_layout', 'waitforbuttonpress')
    _axes_commands = ('acorr', 'angle_spectrum', 'annotate', 'arrow', 'autoscale', 'axhline', 'axhspan', 'axis', 'axline', 'axvline', 'axvspan', 'bar', 'barbs', 'barh', 'bar_label', 'boxplot', 'broken_barh', 'clabel', 'cohere', 'contour', 'contourf', 'csd', 'ecdf', 'errorbar', 'eventplot', 'fill', 'fill_between', 'fill_betweenx', 'grid', 'hexbin', 'hist', 'stairs', 'hist2d', 'hlines', 'imshow', 'legend', 'locator_params', 'loglog', 'magnitude_spectrum', 'margins', 'minorticks_off', 'minorticks_on', 'pcolor', 'pcolormesh', 'phase_spectrum', 'pie', 'plot', 'plot_date', 'psd', 'quiver', 'quiverkey', 'scatter', 'semilogx', 'semilogy', 'specgram', 'spy', 'stackplot', 'stem', 'step', 'streamplot', 'table', 'text', 'tick_params', 'ticklabel_format', 'tricontour', 'tricontourf', 'tripcolor', 'triplot', 'violinplot', 'vlines', 'xcorr', 'sci:_sci', 'title:set_title', 'xlabel:set_xlabel', 'ylabel:set_ylabel', 'xscale:set_xscale', 'yscale:set_yscale')
    cmappable = {'contour': 'if __ret._A is not None:  # type: ignore[attr-defined]\n        sci(__ret)', 'contourf': 'if __ret._A is not None:  # type: ignore[attr-defined]\n        sci(__ret)', 'hexbin': 'sci(__ret)', 'scatter': 'sci(__ret)', 'pcolor': 'sci(__ret)', 'pcolormesh': 'sci(__ret)', 'hist2d': 'sci(__ret[-1])', 'imshow': 'sci(__ret)', 'spy': 'if isinstance(__ret, cm.ScalarMappable):\n        sci(__ret)', 'quiver': 'sci(__ret)', 'specgram': 'sci(__ret[-1])', 'streamplot': 'sci(__ret.lines)', 'tricontour': 'if __ret._A is not None:  # type: ignore[attr-defined]\n        sci(__ret)', 'tricontourf': 'if __ret._A is not None:  # type: ignore[attr-defined]\n        sci(__ret)', 'tripcolor': 'sci(__ret)'}
    for spec in _figure_commands:
        if ':' in spec:
            (name, called_name) = spec.split(':')
        else:
            name = called_name = spec
        yield generate_function(name, f'Figure.{called_name}', FIGURE_METHOD_TEMPLATE)
    for spec in _axes_commands:
        if ':' in spec:
            (name, called_name) = spec.split(':')
        else:
            name = called_name = spec
        template = AXES_CMAPPABLE_METHOD_TEMPLATE if name in cmappable else AXES_METHOD_TEMPLATE
        yield generate_function(name, f'Axes.{called_name}', template, sci_command=cmappable.get(name))
    cmaps = ('autumn', 'bone', 'cool', 'copper', 'flag', 'gray', 'hot', 'hsv', 'jet', 'pink', 'prism', 'spring', 'summer', 'winter', 'magma', 'inferno', 'plasma', 'viridis', 'nipy_spectral')
    for name in cmaps:
        yield AUTOGEN_MSG
        yield CMAP_TEMPLATE.format(name=name)

def build_pyplot(pyplot_path):
    pyplot_orig = pyplot_path.read_text().splitlines(keepends=True)
    try:
        pyplot_orig = pyplot_orig[:pyplot_orig.index(PYPLOT_MAGIC_HEADER) + 1]
    except IndexError as err:
        raise ValueError('The pyplot.py file *must* have the exact line: %s' % PYPLOT_MAGIC_HEADER) from err
    with pyplot_path.open('w') as pyplot:
        pyplot.writelines(pyplot_orig)
        pyplot.writelines(boilerplate_gen())
    subprocess.run([sys.executable, '-m', 'black', '--line-length=88', pyplot_path], check=True)

def get_ast_tree(cls):
    path = Path(inspect.getfile(cls))
    stubpath = path.with_suffix('.pyi')
    path = stubpath if stubpath.exists() else path
    tree = ast.parse(path.read_text())
    for item in tree.body:
        if isinstance(item, ast.ClassDef) and item.name == cls.__name__:
            return item
    raise ValueError(f'Cannot find {cls.__name__} in ast')

@functools.lru_cache
def get_ast_mro_trees(cls):
    return [get_ast_tree(c) for c in cls.__mro__ if c.__module__ != 'builtins']

def get_matching_signature(method, trees):
    sig = inspect.signature(method)
    for tree in trees:
        for item in tree.body:
            if not isinstance(item, ast.FunctionDef):
                continue
            if item.name == method.__name__:
                return update_sig_from_node(item, sig)
    return sig

def update_sig_from_node(node, sig):
    params = dict(sig.parameters)
    args = node.args
    allargs = (*args.posonlyargs, *args.args, args.vararg, *args.kwonlyargs, args.kwarg)
    for param in allargs:
        if param is None:
            continue
        if param.annotation is None:
            continue
        annotation = direct_repr(ast.unparse(param.annotation))
        params[param.arg] = params[param.arg].replace(annotation=annotation)
    if node.returns is not None:
        return inspect.Signature(params.values(), return_annotation=direct_repr(ast.unparse(node.returns)))
    else:
        return inspect.Signature(params.values())
if __name__ == '__main__':
    if len(sys.argv) > 1:
        pyplot_path = Path(sys.argv[1])
    else:
        pyplot_path = Path(__file__).parent / '../lib/matplotlib/pyplot.py'
    build_pyplot(pyplot_path)

# File: matplotlib-main/tools/cache_zenodo_svg.py
import urllib.request
from io import BytesIO
import os
from pathlib import Path

def download_or_cache(url, version):
    cache_dir = _get_xdg_cache_dir()
    if cache_dir is not None:
        try:
            data = (cache_dir / version).read_bytes()
        except OSError:
            pass
        else:
            return BytesIO(data)
    with urllib.request.urlopen(urllib.request.Request(url, headers={'User-Agent': ''})) as req:
        data = req.read()
    if cache_dir is not None:
        try:
            cache_dir.mkdir(parents=True, exist_ok=True)
            with open(cache_dir / version, 'xb') as fout:
                fout.write(data)
        except OSError:
            pass
    return BytesIO(data)

def _get_xdg_cache_dir():
    cache_dir = os.environ.get('XDG_CACHE_HOME')
    if not cache_dir:
        cache_dir = os.path.expanduser('~/.cache')
        if cache_dir.startswith('~/'):
            return None
    return Path(cache_dir, 'matplotlib')
if __name__ == '__main__':
    data = {'v3.9.2': '13308876', 'v3.9.1': '12652732', 'v3.9.0': '11201097', 'v3.8.4': '10916799', 'v3.8.3': '10661079', 'v3.8.2': '10150955', 'v3.8.1': '10059757', 'v3.8.0': '8347255', 'v3.7.3': '8336761', 'v3.7.2': '8118151', 'v3.7.1': '7697899', 'v3.7.0': '7637593', 'v3.6.3': '7527665', 'v3.6.2': '7275322', 'v3.6.1': '7162185', 'v3.6.0': '7084615', 'v3.5.3': '6982547', 'v3.5.2': '6513224', 'v3.5.1': '5773480', 'v3.5.0': '5706396', 'v3.4.3': '5194481', 'v3.4.2': '4743323', 'v3.4.1': '4649959', 'v3.4.0': '4638398', 'v3.3.4': '4475376', 'v3.3.3': '4268928', 'v3.3.2': '4030140', 'v3.3.1': '3984190', 'v3.3.0': '3948793', 'v3.2.2': '3898017', 'v3.2.1': '3714460', 'v3.2.0': '3695547', 'v3.1.3': '3633844', 'v3.1.2': '3563226', 'v3.1.1': '3264781', 'v3.1.0': '2893252', 'v3.0.3': '2577644', 'v3.0.2': '1482099', 'v3.0.1': '1482098', 'v2.2.5': '3633833', 'v3.0.0': '1420605', 'v2.2.4': '2669103', 'v2.2.3': '1343133', 'v2.2.2': '1202077', 'v2.2.1': '1202050', 'v2.2.0': '1189358', 'v2.1.2': '1154287', 'v2.1.1': '1098480', 'v2.1.0': '1004650', 'v2.0.2': '573577', 'v2.0.1': '570311', 'v2.0.0': '248351', 'v1.5.3': '61948', 'v1.5.2': '56926', 'v1.5.1': '44579', 'v1.5.0': '32914', 'v1.4.3': '15423', 'v1.4.2': '12400', 'v1.4.1': '12287', 'v1.4.0': '11451'}
    doc_dir = Path(__file__).parent.parent.absolute() / 'doc'
    target_dir = doc_dir / '_static/zenodo_cache'
    citing = doc_dir / 'project/citing.rst'
    target_dir.mkdir(exist_ok=True, parents=True)
    header = []
    footer = []
    with open(citing) as fin:
        target = header
        for ln in fin:
            if target is not None:
                target.append(ln.rstrip())
            if ln.strip() == '.. START OF AUTOGENERATED':
                target.extend(['', ''])
                target = None
            if ln.strip() == '.. END OF AUTOGENERATED':
                target = footer
                target.append(ln.rstrip())
    with open(citing, 'w') as fout:
        fout.write('\n'.join(header))
        for (version, doi) in data.items():
            svg_path = target_dir / f'{doi}.svg'
            if not svg_path.exists():
                url = f'https://zenodo.org/badge/doi/10.5281/zenodo.{doi}.svg'
                payload = download_or_cache(url, f'{doi}.svg')
                with open(svg_path, 'xb') as svgout:
                    svgout.write(payload.read())
            fout.write(f'\n{version}\n   .. image:: ../_static/zenodo_cache/{doi}.svg\n      :target:  https://doi.org/10.5281/zenodo.{doi}')
        fout.write('\n\n')
        fout.write('\n'.join(footer))
        fout.write('\n')

# File: matplotlib-main/tools/check_typehints.py
""""""
import ast
import pathlib
import sys
MISSING_STUB = 1
MISSING_IMPL = 2
POS_ARGS = 4
ARGS = 8
VARARG = 16
KWARGS = 32
VARKWARG = 64

def check_file(path, ignore=0):
    stubpath = path.with_suffix('.pyi')
    ret = 0
    if not stubpath.exists():
        return (0, 0)
    tree = ast.parse(path.read_text())
    stubtree = ast.parse(stubpath.read_text())
    return check_namespace(tree, stubtree, path, ignore)

def check_namespace(tree, stubtree, path, ignore=0):
    ret = 0
    count = 0
    tree_items = set((i.name for i in tree.body if hasattr(i, 'name') and (not i.name.startswith('_') or i.name.endswith('__'))))
    stubtree_items = set((i.name for i in stubtree.body if hasattr(i, 'name') and (not i.name.startswith('_') or i.name.endswith('__'))))
    for item in tree.body:
        if isinstance(item, ast.Assign):
            tree_items |= set((i.id for i in item.targets if hasattr(i, 'id') and (not i.id.startswith('_') or i.id.endswith('__'))))
            for target in item.targets:
                if isinstance(target, ast.Tuple):
                    tree_items |= set((i.id for i in target.elts))
        elif isinstance(item, ast.AnnAssign):
            tree_items |= {item.target.id}
    for item in stubtree.body:
        if isinstance(item, ast.Assign):
            stubtree_items |= set((i.id for i in item.targets if hasattr(i, 'id') and (not i.id.startswith('_') or i.id.endswith('__'))))
            for target in item.targets:
                if isinstance(target, ast.Tuple):
                    stubtree_items |= set((i.id for i in target.elts))
        elif isinstance(item, ast.AnnAssign):
            stubtree_items |= {item.target.id}
    try:
        all_ = ast.literal_eval(ast.unparse(get_subtree(tree, '__all__').value))
    except ValueError:
        all_ = []
    if all_:
        missing = tree_items - stubtree_items & set(all_)
    else:
        missing = tree_items - stubtree_items
    deprecated = set()
    for item_name in missing:
        item = get_subtree(tree, item_name)
        if hasattr(item, 'decorator_list'):
            if 'deprecated' in [i.func.attr for i in item.decorator_list if hasattr(i, 'func') and hasattr(i.func, 'attr')]:
                deprecated |= {item_name}
    if missing - deprecated and ~ignore & MISSING_STUB:
        print(f'{path}: {missing - deprecated} missing from stubs')
        ret |= MISSING_STUB
        count += 1
    non_class_or_func = set()
    for item_name in stubtree_items - tree_items:
        try:
            get_subtree(tree, item_name)
        except ValueError:
            pass
        else:
            non_class_or_func |= {item_name}
    missing_implementation = stubtree_items - tree_items - non_class_or_func
    if missing_implementation and ~ignore & MISSING_IMPL:
        print(f'{path}: {missing_implementation} in stubs and not source')
        ret |= MISSING_IMPL
        count += 1
    for item_name in tree_items & stubtree_items:
        item = get_subtree(tree, item_name)
        stubitem = get_subtree(stubtree, item_name)
        if isinstance(item, ast.FunctionDef) and isinstance(stubitem, ast.FunctionDef):
            (err, c) = check_function(item, stubitem, f'{path}::{item_name}', ignore)
            ret |= err
            count += c
        if isinstance(item, ast.ClassDef):
            (err, c) = check_namespace(item, stubitem, f'{path}::{item_name}', ignore | MISSING_STUB | MISSING_IMPL)
            ret |= err
            count += c
    return (ret, count)

def check_function(item, stubitem, path, ignore):
    ret = 0
    count = 0
    overloaded = 'overload' in [i.id for i in stubitem.decorator_list if hasattr(i, 'id')]
    if overloaded:
        return (0, 0)
    item_posargs = [a.arg for a in item.args.posonlyargs]
    stubitem_posargs = [a.arg for a in stubitem.args.posonlyargs]
    if item_posargs != stubitem_posargs and ~ignore & POS_ARGS:
        print(f'{path} {item.name} posargs differ: {item_posargs} vs {stubitem_posargs}')
        ret |= POS_ARGS
        count += 1
    item_args = [a.arg for a in item.args.args]
    stubitem_args = [a.arg for a in stubitem.args.args]
    if item_args != stubitem_args and ~ignore & ARGS:
        print(f'{path} args differ for {item.name}: {item_args} vs {stubitem_args}')
        ret |= ARGS
        count += 1
    item_vararg = item.args.vararg
    stubitem_vararg = stubitem.args.vararg
    if ~ignore & VARARG:
        if (item_vararg is None) ^ (stubitem_vararg is None):
            if item_vararg:
                print(f'{path} {item.name} vararg differ: {item_vararg.arg} vs {stubitem_vararg}')
            else:
                print(f'{path} {item.name} vararg differ: {item_vararg} vs {stubitem_vararg.arg}')
            ret |= VARARG
            count += 1
        elif item_vararg is None:
            pass
        elif item_vararg.arg != stubitem_vararg.arg:
            print(f'{path} {item.name} vararg differ: {item_vararg.arg} vs {stubitem_vararg.arg}')
            ret |= VARARG
            count += 1
    item_kwonlyargs = [a.arg for a in item.args.kwonlyargs]
    stubitem_kwonlyargs = [a.arg for a in stubitem.args.kwonlyargs]
    if item_kwonlyargs != stubitem_kwonlyargs and ~ignore & KWARGS:
        print(f'{path} {item.name} kwonlyargs differ: {item_kwonlyargs} vs {stubitem_kwonlyargs}')
        ret |= KWARGS
        count += 1
    item_kwarg = item.args.kwarg
    stubitem_kwarg = stubitem.args.kwarg
    if ~ignore & VARKWARG:
        if (item_kwarg is None) ^ (stubitem_kwarg is None):
            if item_kwarg:
                print(f'{path} {item.name} varkwarg differ: {item_kwarg.arg} vs {stubitem_kwarg}')
            else:
                print(f'{path} {item.name} varkwarg differ: {item_kwarg} vs {stubitem_kwarg.arg}')
            ret |= VARKWARG
            count += 1
        elif item_kwarg is None:
            pass
        elif item_kwarg.arg != stubitem_kwarg.arg:
            print(f'{path} {item.name} varkwarg differ: {item_kwarg.arg} vs {stubitem_kwarg.arg}')
            ret |= VARKWARG
            count += 1
    return (ret, count)

def get_subtree(tree, name):
    for item in tree.body:
        if isinstance(item, ast.Assign):
            if name in [i.id for i in item.targets if hasattr(i, 'id')]:
                return item
            for target in item.targets:
                if isinstance(target, ast.Tuple):
                    if name in [i.id for i in target.elts]:
                        return item
        if isinstance(item, ast.AnnAssign):
            if name == item.target.id:
                return item
        if not hasattr(item, 'name'):
            continue
        if item.name == name:
            return item
    raise ValueError(f'no such item {name} in tree')
if __name__ == '__main__':
    out = 0
    count = 0
    basedir = pathlib.Path('lib/matplotlib')
    per_file_ignore = {basedir / '__init__.py': MISSING_IMPL, basedir / 'ticker.py': VARKWARG, basedir / 'layout_engine.py': VARKWARG}
    for f in basedir.rglob('**/*.py'):
        (err, c) = check_file(f, ignore=0 | per_file_ignore.get(f, 0))
        out |= err
        count += c
    print('\n')
    print(f'{count} total errors found')
    sys.exit(out)

# File: matplotlib-main/tools/embed_js.py
""""""
from collections import namedtuple
from pathlib import Path
import re
import shutil
import subprocess
import sys
Package = namedtuple('Package', ['name', 'source', 'license'])
JAVASCRIPT_PACKAGES = [Package('@jsxtools/resize-observer', 'index.js', 'LICENSE.md')]
MPLJS_MAGIC_HEADER = '///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n'

def safe_name(name):
    return '_'.join(re.split('[@/-]', name)).upper()

def prep_package(web_backend_path, pkg):
    source = web_backend_path / 'node_modules' / pkg.name / pkg.source
    license = web_backend_path / 'node_modules' / pkg.name / pkg.license
    if not source.exists():
        try:
            subprocess.run(['npm', 'install', '--no-save', pkg.name], cwd=web_backend_path)
        except FileNotFoundError as err:
            raise ValueError(f'npm must be installed to fetch {pkg.name}') from err
    if not source.exists():
        raise ValueError(f'{pkg.name} package is missing source in {pkg.source}')
    elif not license.exists():
        raise ValueError(f'{pkg.name} package is missing license in {pkg.license}')
    return (source, license)

def gen_embedded_lines(pkg, source):
    name = safe_name(pkg.name)
    print('Embedding', source, 'as', name)
    yield '// prettier-ignore\n'
    for line in source.read_text().splitlines():
        yield (line.replace('module.exports=function', f'var {name}=function') + ' // eslint-disable-line\n')

def build_mpljs(web_backend_path, license_path):
    mpljs_path = web_backend_path / 'js/mpl.js'
    mpljs_orig = mpljs_path.read_text().splitlines(keepends=True)
    try:
        mpljs_orig = mpljs_orig[:mpljs_orig.index(MPLJS_MAGIC_HEADER) + 1]
    except IndexError as err:
        raise ValueError(f'The mpl.js file *must* have the exact line: {MPLJS_MAGIC_HEADER}') from err
    with mpljs_path.open('w') as mpljs:
        mpljs.writelines(mpljs_orig)
        for pkg in JAVASCRIPT_PACKAGES:
            (source, license) = prep_package(web_backend_path, pkg)
            mpljs.writelines(gen_embedded_lines(pkg, source))
            shutil.copy(license, license_path / f'LICENSE{safe_name(pkg.name)}')
if __name__ == '__main__':
    if len(sys.argv) > 1:
        web_backend_path = Path(sys.argv[1])
    else:
        web_backend_path = Path(__file__).parent.parent / 'lib/matplotlib/backends/web_backend'
    if len(sys.argv) > 2:
        license_path = Path(sys.argv[2])
    else:
        license_path = Path(__file__).parent.parent / 'LICENSE'
    build_mpljs(web_backend_path, license_path)

# File: matplotlib-main/tools/generate_matplotlibrc.py
""""""
import sys
from pathlib import Path
if len(sys.argv) != 4:
    raise SystemExit('usage: {sys.argv[0]} <input> <output> <backend>')
input = Path(sys.argv[1])
output = Path(sys.argv[2])
backend = sys.argv[3]
template_lines = input.read_text(encoding='utf-8').splitlines(True)
(backend_line_idx,) = (idx for (idx, line) in enumerate(template_lines) if '#backend:' in line)
template_lines[backend_line_idx] = f'#backend: {backend}\n' if backend not in ['', 'auto'] else '##backend: Agg\n'
output.write_text(''.join(template_lines), encoding='utf-8')

# File: matplotlib-main/tools/gh_api.py
""""""
import getpass
import json
import os
import re
import sys
import requests
try:
    import requests_cache
except ImportError:
    print('no cache', file=sys.stderr)
else:
    requests_cache.install_cache('gh_api', expire_after=3600)
fake_username = 'ipython_tools'

class Obj(dict):

    def __getattr__(self, name):
        try:
            return self[name]
        except KeyError as err:
            raise AttributeError(name) from err

    def __setattr__(self, name, val):
        self[name] = val
token = None

def get_auth_token():
    global token
    if token is not None:
        return token
    try:
        with open(os.path.join(os.path.expanduser('~'), '.ghoauth')) as f:
            (token,) = f
            return token
    except Exception:
        pass
    import keyring
    token = keyring.get_password('github', fake_username)
    if token is not None:
        return token
    print('Please enter your github username and password. These are not stored, only used to get an oAuth token. You can revoke this at any time on GitHub.')
    user = input('Username: ')
    pw = getpass.getpass('Password: ')
    auth_request = {'scopes': ['public_repo', 'gist'], 'note': 'IPython tools', 'note_url': 'https://github.com/ipython/ipython/tree/master/tools'}
    response = requests.post('https://api.github.com/authorizations', auth=(user, pw), data=json.dumps(auth_request))
    response.raise_for_status()
    token = json.loads(response.text)['token']
    keyring.set_password('github', fake_username, token)
    return token

def make_auth_header():
    return {'Authorization': 'token ' + get_auth_token().replace('\n', '')}

def post_issue_comment(project, num, body):
    url = f'https://api.github.com/repos/{project}/issues/{num}/comments'
    payload = json.dumps({'body': body})
    requests.post(url, data=payload, headers=make_auth_header())

def post_gist(content, description='', filename='file', auth=False):
    post_data = json.dumps({'description': description, 'public': True, 'files': {filename: {'content': content}}}).encode('utf-8')
    headers = make_auth_header() if auth else {}
    response = requests.post('https://api.github.com/gists', data=post_data, headers=headers)
    response.raise_for_status()
    response_data = json.loads(response.text)
    return response_data['html_url']

def get_pull_request(project, num, auth=False):
    url = f'https://api.github.com/repos/{project}/pulls/{num}'
    if auth:
        header = make_auth_header()
    else:
        header = None
    print('fetching %s' % url, file=sys.stderr)
    response = requests.get(url, headers=header)
    response.raise_for_status()
    return json.loads(response.text, object_hook=Obj)

def get_pull_request_files(project, num, auth=False):
    url = f'https://api.github.com/repos/{project}/pulls/{num}/files'
    if auth:
        header = make_auth_header()
    else:
        header = None
    return get_paged_request(url, headers=header)
element_pat = re.compile('<(.+?)>')
rel_pat = re.compile('rel=[\\\'"](\\w+)[\\\'"]')

def get_paged_request(url, headers=None, **params):
    results = []
    params.setdefault('per_page', 100)
    while True:
        if '?' in url:
            params = None
            print(f'fetching {url}', file=sys.stderr)
        else:
            print(f'fetching {url} with {params}', file=sys.stderr)
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        results.extend(response.json())
        if 'next' in response.links:
            url = response.links['next']['url']
        else:
            break
    return results

def get_pulls_list(project, auth=False, **params):
    params.setdefault('state', 'closed')
    url = f'https://api.github.com/repos/{project}/pulls'
    if auth:
        headers = make_auth_header()
    else:
        headers = None
    pages = get_paged_request(url, headers=headers, **params)
    return pages

def get_issues_list(project, auth=False, **params):
    params.setdefault('state', 'closed')
    url = f'https://api.github.com/repos/{project}/issues'
    if auth:
        headers = make_auth_header()
    else:
        headers = None
    pages = get_paged_request(url, headers=headers, **params)
    return pages

def get_milestones(project, auth=False, **params):
    params.setdefault('state', 'all')
    url = f'https://api.github.com/repos/{project}/milestones'
    if auth:
        headers = make_auth_header()
    else:
        headers = None
    milestones = get_paged_request(url, headers=headers, **params)
    return milestones

def get_milestone_id(project, milestone, auth=False, **params):
    milestones = get_milestones(project, auth=auth, **params)
    for mstone in milestones:
        if mstone['title'] == milestone:
            return mstone['number']
    raise ValueError('milestone %s not found' % milestone)

def is_pull_request(issue):
    return bool(issue.get('pull_request', {}).get('html_url', None))

def get_authors(pr):
    print('getting authors for #%i' % pr['number'], file=sys.stderr)
    h = make_auth_header()
    r = requests.get(pr['commits_url'], headers=h)
    r.raise_for_status()
    commits = r.json()
    authors = []
    for commit in commits:
        author = commit['commit']['author']
        authors.append(f"{author['name']} <{author['email']}>")
    return authors

def iter_fields(fields):
    fields = fields.copy()
    for key in ['key', 'acl', 'Filename', 'success_action_status', 'AWSAccessKeyId', 'Policy', 'Signature', 'Content-Type', 'file']:
        yield (key, fields.pop(key))
    yield from fields.items()

def encode_multipart_formdata(fields, boundary=None):
    from io import BytesIO
    from requests.packages.urllib3.filepost import choose_boundary, writer, b, get_content_type
    body = BytesIO()
    if boundary is None:
        boundary = choose_boundary()
    for (fieldname, value) in iter_fields(fields):
        body.write(b('--%s\r\n' % boundary))
        if isinstance(value, tuple):
            (filename, data) = value
            writer(body).write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (fieldname, filename))
            body.write(b('Content-Type: %s\r\n\r\n' % get_content_type(filename)))
        else:
            data = value
            writer(body).write('Content-Disposition: form-data; name="%s"\r\n' % fieldname)
            body.write(b'Content-Type: text/plain\r\n\r\n')
        if isinstance(data, int):
            data = str(data)
        if isinstance(data, str):
            writer(body).write(data)
        else:
            body.write(data)
        body.write(b'\r\n')
    body.write(b('--%s--\r\n' % boundary))
    content_type = b('multipart/form-data; boundary=%s' % boundary)
    return (body.getvalue(), content_type)

def post_download(project, filename, name=None, description=''):
    if name is None:
        name = os.path.basename(filename)
    with open(filename, 'rb') as f:
        filedata = f.read()
    url = f'https://api.github.com/repos/{project}/downloads'
    payload = json.dumps(dict(name=name, size=len(filedata), description=description))
    response = requests.post(url, data=payload, headers=make_auth_header())
    response.raise_for_status()
    reply = json.loads(response.content)
    s3_url = reply['s3_url']
    fields = dict(key=reply['path'], acl=reply['acl'], success_action_status=201, Filename=reply['name'], AWSAccessKeyId=reply['accesskeyid'], Policy=reply['policy'], Signature=reply['signature'], file=(reply['name'], filedata))
    fields['Content-Type'] = reply['mime_type']
    (data, content_type) = encode_multipart_formdata(fields)
    s3r = requests.post(s3_url, data=data, headers={'Content-Type': content_type})
    return s3r

# File: matplotlib-main/tools/github_stats.py
""""""
import sys
from argparse import ArgumentParser
from datetime import datetime, timedelta
from subprocess import check_output
from gh_api import get_paged_request, make_auth_header, get_pull_request, is_pull_request, get_milestone_id, get_issues_list, get_authors
ISO8601 = '%Y-%m-%dT%H:%M:%SZ'
PER_PAGE = 100
REPORT_TEMPLATE = '.. _github-stats:\n\n{title}\n{title_underline}\n\nGitHub statistics for {since_day} (tag: {tag}) - {today}\n\nThese lists are automatically generated, and may be incomplete or contain duplicates.\n\nWe closed {n_issues} issues and merged {n_pulls} pull requests.\n{milestone}\nThe following {nauthors} authors contributed {ncommits} commits.\n\n{unique_authors}\n{links}\n\nPrevious GitHub statistics\n--------------------------\n\n.. toctree::\n    :maxdepth: 1\n    :glob:\n    :reversed:\n\n    prev_whats_new/github_stats_*'
MILESTONE_TEMPLATE = 'The full list can be seen `on GitHub <https://github.com/{project}/milestone/{milestone_id}?closed=1>`__\n'
LINKS_TEMPLATE = '\nGitHub issues and pull requests:\n\nPull Requests ({n_pulls}):\n\n{pull_request_report}\n\nIssues ({n_issues}):\n\n{issue_report}\n'

def round_hour(dt):
    return dt.replace(minute=0, second=0, microsecond=0)

def _parse_datetime(s):
    return datetime.strptime(s, ISO8601) if s else datetime.fromtimestamp(0)

def issues2dict(issues):
    return {i['number']: i for i in issues}

def split_pulls(all_issues, project='matplotlib/matplotlib'):
    pulls = []
    issues = []
    for i in all_issues:
        if is_pull_request(i):
            pull = get_pull_request(project, i['number'], auth=True)
            pulls.append(pull)
        else:
            issues.append(i)
    return (issues, pulls)

def issues_closed_since(period=timedelta(days=365), project='matplotlib/matplotlib', pulls=False):
    which = 'pulls' if pulls else 'issues'
    if isinstance(period, timedelta):
        since = round_hour(datetime.utcnow() - period)
    else:
        since = period
    url = f'https://api.github.com/repos/{project}/{which}?state=closed&sort=updated&since={since.strftime(ISO8601)}&per_page={PER_PAGE}'
    allclosed = get_paged_request(url, headers=make_auth_header())
    filtered = (i for i in allclosed if _parse_datetime(i['closed_at']) > since)
    if pulls:
        filtered = (i for i in filtered if _parse_datetime(i['merged_at']) > since)
        filtered = (i for i in filtered if i['base']['ref'] == 'main')
    else:
        filtered = (i for i in filtered if not is_pull_request(i))
    return list(filtered)

def sorted_by_field(issues, field='closed_at', reverse=False):
    return sorted(issues, key=lambda i: i[field], reverse=reverse)

def report(issues, show_urls=False):
    lines = []
    if show_urls:
        for i in issues:
            role = 'ghpull' if 'merged_at' in i else 'ghissue'
            number = i['number']
            title = i['title'].replace('`', '``').strip()
            lines.append(f'* :{role}:`{number}`: {title}')
    else:
        for i in issues:
            number = i['number']
            title = i['title'].replace('`', '``').strip()
            lines.append('* {number}: {title}')
    return '\n'.join(lines)
if __name__ == '__main__':
    show_urls = True
    parser = ArgumentParser()
    parser.add_argument('--since-tag', type=str, help='The git tag to use for the starting point (typically the last macro release).')
    parser.add_argument('--milestone', type=str, help='The GitHub milestone to use for filtering issues [optional].')
    parser.add_argument('--days', type=int, help='The number of days of data to summarize (use this or --since-tag).')
    parser.add_argument('--project', type=str, default='matplotlib/matplotlib', help='The project to summarize.')
    parser.add_argument('--links', action='store_true', default=False, help='Include links to all closed Issues and PRs in the output.')
    opts = parser.parse_args()
    tag = opts.since_tag
    if opts.days:
        since = datetime.utcnow() - timedelta(days=opts.days)
    else:
        if not tag:
            tag = check_output(['git', 'describe', '--abbrev=0'], encoding='utf8').strip()
        cmd = ['git', 'log', '-1', '--format=%ai', tag]
        (tagday, tz) = check_output(cmd, encoding='utf8').strip().rsplit(' ', 1)
        since = datetime.strptime(tagday, '%Y-%m-%d %H:%M:%S')
        h = int(tz[1:3])
        m = int(tz[3:])
        td = timedelta(hours=h, minutes=m)
        if tz[0] == '-':
            since += td
        else:
            since -= td
    since = round_hour(since)
    milestone = opts.milestone
    project = opts.project
    print(f'fetching GitHub stats since {since} (tag: {tag}, milestone: {milestone})', file=sys.stderr)
    if milestone:
        milestone_id = get_milestone_id(project=project, milestone=milestone, auth=True)
        issues_and_pulls = get_issues_list(project=project, milestone=milestone_id, state='closed', auth=True)
        (issues, pulls) = split_pulls(issues_and_pulls, project=project)
    else:
        issues = issues_closed_since(since, project=project, pulls=False)
        pulls = issues_closed_since(since, project=project, pulls=True)
    issues = sorted_by_field(issues, reverse=True)
    pulls = sorted_by_field(pulls, reverse=True)
    (n_issues, n_pulls) = map(len, (issues, pulls))
    n_total = n_issues + n_pulls
    since_day = since.strftime('%Y/%m/%d')
    today = datetime.today()
    title = f"GitHub statistics for {milestone.lstrip('v')} {today.strftime('(%b %d, %Y)')}"
    ncommits = 0
    all_authors = []
    if tag:
        since_tag = f'{tag}..'
        cmd = ['git', 'log', '--oneline', since_tag]
        ncommits += len(check_output(cmd).splitlines())
        author_cmd = ['git', 'log', '--use-mailmap', '--format=* %aN', since_tag]
        all_authors.extend(check_output(author_cmd, encoding='utf-8', errors='replace').splitlines())
    pr_authors = []
    for pr in pulls:
        pr_authors.extend(get_authors(pr))
    ncommits = len(pr_authors) + ncommits - len(pulls)
    author_cmd = ['git', 'check-mailmap'] + pr_authors
    with_email = check_output(author_cmd, encoding='utf-8', errors='replace').splitlines()
    all_authors.extend(['* ' + a.split(' <')[0] for a in with_email])
    unique_authors = sorted(set(all_authors), key=lambda s: s.lower())
    if milestone:
        milestone_str = MILESTONE_TEMPLATE.format(project=project, milestone_id=milestone_id)
    else:
        milestone_str = ''
    if opts.links:
        links = LINKS_TEMPLATE.format(n_pulls=n_pulls, pull_request_report=report(pulls, show_urls), n_issues=n_issues, issue_report=report(issues, show_urls))
    else:
        links = ''
    print(REPORT_TEMPLATE.format(title=title, title_underline='=' * len(title), since_day=since_day, tag=tag, today=today.strftime('%Y/%m/%d'), n_issues=n_issues, n_pulls=n_pulls, milestone=milestone_str, nauthors=len(unique_authors), ncommits=ncommits, unique_authors='\n'.join(unique_authors), links=links))

# File: matplotlib-main/tools/make_icons.py
""""""
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from io import BytesIO
from pathlib import Path
import tarfile
import urllib.request
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
plt.rcdefaults()
plt.rcParams['svg.fonttype'] = 'path'
plt.rcParams['pdf.fonttype'] = 3
plt.rcParams['pdf.compression'] = 9

def get_fontawesome():
    cached_path = Path(mpl.get_cachedir(), 'FontAwesome.otf')
    if not cached_path.exists():
        with urllib.request.urlopen('https://github.com/FortAwesome/Font-Awesome/archive/v4.7.0.tar.gz') as req, tarfile.open(fileobj=BytesIO(req.read()), mode='r:gz') as tf:
            cached_path.write_bytes(tf.extractfile(tf.getmember('Font-Awesome-4.7.0/fonts/FontAwesome.otf')).read())
    return cached_path

def save_icon(fig, dest_dir, name, add_black_fg_color):
    if add_black_fg_color:
        svg_bytes_io = BytesIO()
        fig.savefig(svg_bytes_io, format='svg')
        svg = svg_bytes_io.getvalue()
        (before, sep, after) = svg.rpartition(b'\nz\n"')
        svg = before + sep + b' style="fill:black;"' + after
        (dest_dir / (name + '.svg')).write_bytes(svg)
    else:
        fig.savefig(dest_dir / (name + '.svg'))
    fig.savefig(dest_dir / (name + '.pdf'))
    for (dpi, suffix) in [(24, ''), (48, '_large')]:
        fig.savefig(dest_dir / (name + suffix + '.png'), dpi=dpi)

def make_icon(font_path, ccode):
    fig = plt.figure(figsize=(1, 1))
    fig.patch.set_alpha(0.0)
    fig.text(0.5, 0.48, chr(ccode), ha='center', va='center', font=font_path, fontsize=68)
    return fig

def make_matplotlib_icon():
    fig = plt.figure(figsize=(1, 1))
    fig.patch.set_alpha(0.0)
    ax = fig.add_axes([0.025, 0.025, 0.95, 0.95], projection='polar')
    ax.set_axisbelow(True)
    N = 7
    arc = 2 * np.pi
    theta = np.arange(0, arc, arc / N)
    radii = 10 * np.array([0.2, 0.6, 0.8, 0.7, 0.4, 0.5, 0.8])
    width = np.pi / 4 * np.array([0.4, 0.4, 0.6, 0.8, 0.2, 0.5, 0.3])
    bars = ax.bar(theta, radii, width=width, bottom=0.0, linewidth=1, edgecolor='k')
    for (r, bar) in zip(radii, bars):
        bar.set_facecolor(mpl.cm.jet(r / 10))
    ax.tick_params(labelleft=False, labelright=False, labelbottom=False, labeltop=False)
    ax.grid(lw=0.0)
    ax.set_yticks(np.arange(1, 9, 2))
    ax.set_rmax(9)
    return fig
icon_defs = [('home', 61461), ('back', 61536), ('forward', 61537), ('zoom_to_rect', 61442), ('move', 61511), ('filesave', 61639), ('subplots', 61918), ('qt4_editor_options', 61953), ('help', 61736)]

def make_icons():
    parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
    parser.add_argument('-d', '--dest-dir', type=Path, default=Path(__file__).parent / '../lib/matplotlib/mpl-data/images', help='Directory where to store the images.')
    args = parser.parse_args()
    font_path = get_fontawesome()
    for (name, ccode) in icon_defs:
        fig = make_icon(font_path, ccode)
        save_icon(fig, args.dest_dir, name, True)
    fig = make_matplotlib_icon()
    save_icon(fig, args.dest_dir, 'matplotlib', False)
if __name__ == '__main__':
    make_icons()

# File: matplotlib-main/tools/memleak.py
import gc
from io import BytesIO
import tracemalloc
try:
    import psutil
except ImportError as err:
    raise ImportError('This script requires psutil') from err
import numpy as np

def run_memleak_test(bench, iterations, report):
    tracemalloc.start()
    starti = min(50, iterations // 2)
    endi = iterations
    malloc_arr = np.empty(endi, dtype=np.int64)
    rss_arr = np.empty(endi, dtype=np.int64)
    rss_peaks = np.empty(endi, dtype=np.int64)
    nobjs_arr = np.empty(endi, dtype=np.int64)
    garbage_arr = np.empty(endi, dtype=np.int64)
    open_files_arr = np.empty(endi, dtype=np.int64)
    rss_peak = 0
    p = psutil.Process()
    for i in range(endi):
        bench()
        gc.collect()
        rss = p.memory_info().rss
        (malloc, peak) = tracemalloc.get_traced_memory()
        nobjs = len(gc.get_objects())
        garbage = len(gc.garbage)
        open_files = len(p.open_files())
        print(f'{i: 4d}: pymalloc {malloc: 10d}, rss {rss: 10d}, nobjs {nobjs: 10d}, garbage {garbage: 4d}, files: {open_files: 4d}')
        if i == starti:
            print(f"{' warmup done ':-^86s}")
        malloc_arr[i] = malloc
        rss_arr[i] = rss
        if rss > rss_peak:
            rss_peak = rss
        rss_peaks[i] = rss_peak
        nobjs_arr[i] = nobjs
        garbage_arr[i] = garbage
        open_files_arr[i] = open_files
    print('Average memory consumed per loop: {:1.4f} bytes\n'.format(np.sum(rss_peaks[starti + 1:] - rss_peaks[starti:-1]) / (endi - starti)))
    from matplotlib import pyplot as plt
    from matplotlib.ticker import EngFormatter
    bytes_formatter = EngFormatter(unit='B')
    (fig, (ax1, ax2, ax3)) = plt.subplots(3)
    for ax in (ax1, ax2, ax3):
        ax.axvline(starti, linestyle='--', color='k')
    ax1b = ax1.twinx()
    ax1b.yaxis.set_major_formatter(bytes_formatter)
    ax1.plot(malloc_arr, 'C0')
    ax1b.plot(rss_arr, 'C1', label='rss')
    ax1b.plot(rss_peaks, 'C1', linestyle='--', label='rss max')
    ax1.set_ylabel('pymalloc', color='C0')
    ax1b.set_ylabel('rss', color='C1')
    ax1b.legend()
    ax2b = ax2.twinx()
    ax2.plot(nobjs_arr, 'C0')
    ax2b.plot(garbage_arr, 'C1')
    ax2.set_ylabel('total objects', color='C0')
    ax2b.set_ylabel('garbage objects', color='C1')
    ax3.plot(open_files_arr)
    ax3.set_ylabel('open file handles')
    if not report.endswith('.pdf'):
        report = report + '.pdf'
    fig.tight_layout()
    fig.savefig(report, format='pdf')

class MemleakTest:

    def __init__(self, empty):
        self.empty = empty

    def __call__(self):
        import matplotlib.pyplot as plt
        fig = plt.figure(1)
        if not self.empty:
            t1 = np.arange(0.0, 2.0, 0.01)
            y1 = np.sin(2 * np.pi * t1)
            y2 = np.random.rand(len(t1))
            X = np.random.rand(50, 50)
            ax = fig.add_subplot(221)
            ax.plot(t1, y1, '-')
            ax.plot(t1, y2, 's')
            ax = fig.add_subplot(222)
            ax.imshow(X)
            ax = fig.add_subplot(223)
            ax.scatter(np.random.rand(50), np.random.rand(50), s=100 * np.random.rand(50), c=np.random.rand(50))
            ax = fig.add_subplot(224)
            ax.pcolor(10 * np.random.rand(50, 50))
        fig.savefig(BytesIO(), dpi=75)
        fig.canvas.flush_events()
        plt.close(1)
if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser('Run memory leak tests')
    parser.add_argument('backend', type=str, nargs=1, help='backend to test')
    parser.add_argument('iterations', type=int, nargs=1, help='number of iterations')
    parser.add_argument('report', type=str, nargs=1, help='filename to save report')
    parser.add_argument('--empty', action='store_true', help="Don't plot any content, just test creating and destroying figures")
    parser.add_argument('--interactive', action='store_true', help='Turn on interactive mode to actually open windows.  Only works with some GUI backends.')
    args = parser.parse_args()
    import matplotlib
    matplotlib.use(args.backend[0])
    if args.interactive:
        import matplotlib.pyplot as plt
        plt.ion()
    run_memleak_test(MemleakTest(args.empty), args.iterations[0], args.report[0])

# File: matplotlib-main/tools/run_examples.py
""""""
from argparse import ArgumentParser
from contextlib import ExitStack
import os
from pathlib import Path
import subprocess
import sys
from tempfile import TemporaryDirectory
import time
import tokenize
_preamble = 'from matplotlib import pyplot as plt\n\ndef pseudo_show(block=True):\n    for num in plt.get_fignums():\n        plt.figure(num).savefig(f"{num}")\n\nplt.show = pseudo_show\n\n'

class RunInfo:

    def __init__(self, backend, elapsed, failed):
        self.backend = backend
        self.elapsed = elapsed
        self.failed = failed

    def __str__(self):
        s = ''
        if self.backend:
            s += f'{self.backend}: '
        s += f'{self.elapsed}ms'
        if self.failed:
            s += ' (failed!)'
        return s

def main():
    parser = ArgumentParser(description=__doc__)
    parser.add_argument('--backend', action='append', help='backend to test; can be passed multiple times; defaults to the default backend')
    parser.add_argument('--include-sgskip', action='store_true', help='do not filter out *_sgskip.py examples')
    parser.add_argument('--rundir', type=Path, help='directory from where the tests are run; defaults to a temporary directory')
    parser.add_argument('paths', nargs='*', type=Path, help='examples to run; defaults to all examples (except *_sgskip.py)')
    args = parser.parse_args()
    root = Path(__file__).resolve().parent.parent / 'examples'
    paths = args.paths if args.paths else sorted(root.glob('**/*.py'))
    if not args.include_sgskip:
        paths = [path for path in paths if not path.stem.endswith('sgskip')]
    relpaths = [path.resolve().relative_to(root) for path in paths]
    width = max((len(str(relpath)) for relpath in relpaths))
    for relpath in relpaths:
        print(str(relpath).ljust(width + 1), end='', flush=True)
        runinfos = []
        with ExitStack() as stack:
            if args.rundir:
                cwd = args.rundir / relpath.with_suffix('')
                cwd.mkdir(parents=True)
            else:
                cwd = stack.enter_context(TemporaryDirectory())
            with tokenize.open(root / relpath) as src:
                Path(cwd, relpath.name).write_text(_preamble + src.read(), encoding='utf-8')
            for backend in args.backend or [None]:
                env = {**os.environ}
                if backend is not None:
                    env['MPLBACKEND'] = backend
                start = time.perf_counter()
                proc = subprocess.run([sys.executable, relpath.name], cwd=cwd, env=env)
                elapsed = round(1000 * (time.perf_counter() - start))
                runinfos.append(RunInfo(backend, elapsed, proc.returncode))
        print('\t'.join(map(str, runinfos)))
if __name__ == '__main__':
    main()

# File: matplotlib-main/tools/subset.py
import getopt
import os
import struct
import subprocess
import sys
import fontforge

def log_namelist(name, unicode):
    if name and isinstance(unicode, int):
        print(f'0x{unicode:04X}', fontforge.nameeFromUnicode(unicode), file=name)

def select_with_refs(font, unicode, newfont, pe=None, name=None):
    newfont.selection.select(('more', 'unicode'), unicode)
    log_namelist(name, unicode)
    if pe:
        print(f'SelectMore({unicode})', file=pe)
    try:
        for ref in font[unicode].references:
            newfont.selection.select(('more',), ref[0])
            log_namelist(name, ref[0])
            if pe:
                print(f'SelectMore("{ref[0]}")', file=pe)
    except Exception:
        print(f'Resolving references on u+{unicode:04x} failed')

def subset_font_raw(font_in, font_out, unicodes, opts):
    if '--namelist' in opts:
        name_fn = f'{font_out}.name'
        name = open(name_fn, 'w')
    else:
        name = None
    if '--script' in opts:
        pe_fn = '/tmp/script.pe'
        pe = open(pe_fn, 'w')
    else:
        pe = None
    font = fontforge.open(font_in)
    if pe:
        print(f'Open("{font_in}")', file=pe)
        extract_vert_to_script(font_in, pe)
    for i in unicodes:
        select_with_refs(font, i, font, pe, name)
    addl_glyphs = []
    if '--nmr' in opts:
        addl_glyphs.append('nonmarkingreturn')
    if '--null' in opts:
        addl_glyphs.append('.null')
    if '--nd' in opts:
        addl_glyphs.append('.notdef')
    for glyph in addl_glyphs:
        font.selection.select(('more',), glyph)
        if name:
            print(f'0x{fontforge.unicodeFromName(glyph):0.4X}', glyph, file=name)
        if pe:
            print(f'SelectMore("{glyph}")', file=pe)
    flags = ()
    if '--opentype-features' in opts:
        flags += ('opentype',)
    if '--simplify' in opts:
        font.simplify()
        font.round()
        flags += ('omit-instructions',)
    if '--strip_names' in opts:
        font.sfnt_names = ()
    if '--new' in opts:
        font.copy()
        new = fontforge.font()
        new.encoding = font.encoding
        new.em = font.em
        new.layers['Fore'].is_quadratic = font.layers['Fore'].is_quadratic
        for i in unicodes:
            select_with_refs(font, i, new, pe, name)
        new.paste()
        font.selection.select('space')
        font.copy()
        new.selection.select('space')
        new.paste()
        new.sfnt_names = font.sfnt_names
        font = new
    else:
        font.selection.invert()
        print('SelectInvert()', file=pe)
        font.cut()
        print('Clear()', file=pe)
    if '--move-display' in opts:
        print('Moving display glyphs into Unicode ranges...')
        font.familyname += ' Display'
        font.fullname += ' Display'
        font.fontname += 'Display'
        font.appendSFNTName('English (US)', 'Family', font.familyname)
        font.appendSFNTName('English (US)', 16, font.familyname)
        font.appendSFNTName('English (US)', 17, 'Display')
        font.appendSFNTName('English (US)', 'Fullname', font.fullname)
        for glname in unicodes:
            font.selection.none()
            if isinstance(glname, str):
                if glname.endswith('.display'):
                    font.selection.select(glname)
                    font.copy()
                    font.selection.none()
                    newgl = glname.replace('.display', '')
                    font.selection.select(newgl)
                    font.paste()
                font.selection.select(glname)
                font.cut()
    if name:
        print('Writing NameList', end='')
        name.close()
    if pe:
        print(f'Generate("{font_out}")', file=pe)
        pe.close()
        subprocess.call(['fontforge', '-script', pe_fn])
    else:
        font.generate(font_out, flags=flags)
    font.close()
    if '--roundtrip' in opts:
        font2 = fontforge.open(font_out)
        font2.generate(font_out, flags=flags)

def subset_font(font_in, font_out, unicodes, opts):
    font_out_raw = font_out
    if not font_out_raw.endswith('.ttf'):
        font_out_raw += '.ttf'
    subset_font_raw(font_in, font_out_raw, unicodes, opts)
    if font_out != font_out_raw:
        os.rename(font_out_raw, font_out)

def getsubset(subset, font_in):
    subsets = subset.split('+')
    quotes = [8211, 8212, 8216, 8217, 8218, 8220, 8221, 8222, 8226, 8249, 8250]
    latin = [*range(32, 127), *range(160, 256), 8364, 338, 339, 59, 183, 305, 710, 730, 732, 8308, 8725, 8260, 57599, 61437, 61440]
    result = quotes
    if 'menu' in subsets:
        font = fontforge.open(font_in)
        result = [*map(ord, font.familyname), 32]
    if 'latin' in subsets:
        result += latin
    if 'latin-ext' in subsets:
        result += [*range(256, 880), *range(7424, 7840), *range(7922, 7936), *range(8304, 8400), *range(11360, 11392), *range(42752, 43008)]
    if 'vietnamese' in subsets:
        result += [192, 193, 194, 195, 200, 201, 202, 204, 205, 210, 211, 212, 213, 217, 218, 221, 224, 225, 226, 227, 232, 233, 234, 236, 237, 242, 243, 244, 245, 249, 250, 253, 258, 259, 272, 273, 296, 297, 360, 361, 416, 417, 431, 432, 8363, *range(7840, 7930)]
    if 'greek' in subsets:
        result += [*range(880, 1024)]
    if 'greek-ext' in subsets:
        result += [*range(880, 1024), *range(7936, 8192)]
    if 'cyrillic' in subsets:
        result += [*range(1024, 1120), 1168, 1169, 1200, 1201, 8470]
    if 'cyrillic-ext' in subsets:
        result += [*range(1024, 1328), 8372, 8470, *range(11744, 11776), *range(42560, 42656)]
    if 'arabic' in subsets:
        result += [13, 32, 1569, 1575, 1581, 1583, 1585, 1587, 1589, 1591, 1593, 1603, 1604, 1605, 1607, 1608, 1609, 1600, 1646, 1647, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1780, 1781, 1782, 1726, 1746, 1705, 1711, 1722, 1642, 1567, 1548, 1563, 1643, 1644, 1645, 1611, 1613, 1614, 1615, 1612, 1616, 1617, 1618, 1619, 1620, 1621, 1648, 1622, 1557, 1670, 1571, 1573, 1570, 1649, 1576, 1662, 1578, 1579, 1657, 1577, 1580, 1582, 1584, 1672, 1586, 1681, 1688, 1588, 1590, 1592, 1594, 1601, 1602, 1606, 1749, 1728, 1572, 1610, 1740, 1747, 1574, 1730, 1729, 1731, 1776, 1777, 1778, 1779, 1785, 1783, 1784, 64611, 1650, 1651, 1653, 1654, 1655, 1656, 1658, 1659, 1660, 1661, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1671, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1682, 1683, 1684, 1685, 1686, 1687, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1701, 1702, 1703, 1704, 1706, 1707, 1708, 1709, 1710, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1723, 1724, 1725, 1727, 1732, 1733, 1741, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1759, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1770, 1771, 1773, 1787, 1788, 1789, 1790, 1536, 1537, 1538, 1539, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1623, 1624, 1774, 1775, 1791, 1547, 1566, 1625, 1626, 1627, 1628, 1629, 1630, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1700, 1734, 1735, 1736, 1737, 1738, 1739, 1743, 1742, 1744, 1745, 1748, 1786, 1757, 1758, 1760, 1769, 1549, 64830, 64831, 9676, 1595, 1596, 1597, 1598, 1599, 1568, 1652, 1652, 1772]
    if 'dejavu-ext' in subsets:
        font = fontforge.open(font_in)
        for glyph in font.glyphs():
            if glyph.glyphname.endswith('.display'):
                result.append(glyph.glyphname)
    return result

class Sfnt:

    def __init__(self, data):
        (_, numTables, _, _, _) = struct.unpack('>IHHHH', data[:12])
        self.tables = {}
        for i in range(numTables):
            (tag, _, offset, length) = struct.unpack('>4sIII', data[12 + 16 * i:28 + 16 * i])
            self.tables[tag] = data[offset:offset + length]

    def hhea(self):
        r = {}
        d = self.tables['hhea']
        (r['Ascender'], r['Descender'], r['LineGap']) = struct.unpack('>hhh', d[4:10])
        return r

    def os2(self):
        r = {}
        d = self.tables['OS/2']
        (r['fsSelection'],) = struct.unpack('>H', d[62:64])
        (r['sTypoAscender'], r['sTypoDescender'], r['sTypoLineGap']) = struct.unpack('>hhh', d[68:74])
        (r['usWinAscender'], r['usWinDescender']) = struct.unpack('>HH', d[74:78])
        return r

def set_os2(pe, name, val):
    print(f'SetOS2Value("{name}", {val:d})', file=pe)

def set_os2_vert(pe, name, val):
    set_os2(pe, name + 'IsOffset', 0)
    set_os2(pe, name, val)

def extract_vert_to_script(font_in, pe):
    with open(font_in, 'rb') as in_file:
        data = in_file.read()
    sfnt = Sfnt(data)
    hhea = sfnt.hhea()
    os2 = sfnt.os2()
    set_os2_vert(pe, 'WinAscent', os2['usWinAscender'])
    set_os2_vert(pe, 'WinDescent', os2['usWinDescender'])
    set_os2_vert(pe, 'TypoAscent', os2['sTypoAscender'])
    set_os2_vert(pe, 'TypoDescent', os2['sTypoDescender'])
    set_os2_vert(pe, 'HHeadAscent', hhea['Ascender'])
    set_os2_vert(pe, 'HHeadDescent', hhea['Descender'])

def main(argv):
    (optlist, args) = getopt.gnu_getopt(argv, '', ['string=', 'strip_names', 'opentype-features', 'simplify', 'new', 'script', 'nmr', 'roundtrip', 'subset=', 'namelist', 'null', 'nd', 'move-display'])
    (font_in, font_out) = args
    opts = dict(optlist)
    if '--string' in opts:
        subset = map(ord, opts['--string'])
    else:
        subset = getsubset(opts.get('--subset', 'latin'), font_in)
    subset_font(font_in, font_out, subset, opts)
if __name__ == '__main__':
    main(sys.argv[1:])