Add files using upload-large-folder tool

llava_video/lib/python3.10/site-packages/matplotlib/_fontconfig_pattern.py

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

llava_video/lib/python3.10/site-packages/matplotlib/font_manager.pyi

@@ -0,0 +1,136 @@
+from dataclasses import dataclass
+import os
+
+from matplotlib._afm import AFM
+from matplotlib import ft2font
+
+from pathlib import Path
+
+from collections.abc import Iterable
+from typing import Any, Literal
+
+font_scalings: dict[str | None, float]
+stretch_dict: dict[str, int]
+weight_dict: dict[str, int]
+font_family_aliases: set[str]
+MSFolders: str
+MSFontDirectories: list[str]
+MSUserFontDirectories: list[str]
+X11FontDirectories: list[str]
+OSXFontDirectories: list[str]
+
+def get_fontext_synonyms(fontext: str) -> list[str]: ...
+def list_fonts(directory: str, extensions: Iterable[str]) -> list[str]: ...
+def win32FontDirectory() -> str: ...
+def _get_fontconfig_fonts() -> list[Path]: ...
+def findSystemFonts(
+    fontpaths: Iterable[str | os.PathLike | Path] | None = ..., fontext: str = ...
+) -> list[str]: ...
+@dataclass
+class FontEntry:
+    fname: str = ...
+    name: str = ...
+    style: str = ...
+    variant: str = ...
+    weight: str | int = ...
+    stretch: str = ...
+    size: str = ...
+    def _repr_html_(self) -> str: ...
+    def _repr_png_(self) -> bytes: ...
+
+def ttfFontProperty(font: ft2font.FT2Font) -> FontEntry: ...
+def afmFontProperty(fontpath: str, font: AFM) -> FontEntry: ...
+
+class FontProperties:
+    def __init__(
+        self,
+        family: str | Iterable[str] | None = ...,
+        style: Literal["normal", "italic", "oblique"] | None = ...,
+        variant: Literal["normal", "small-caps"] | None = ...,
+        weight: int | str | None = ...,
+        stretch: int | str | None = ...,
+        size: float | str | None = ...,
+        fname: str | os.PathLike | Path | None = ...,
+        math_fontfamily: str | None = ...,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def get_family(self) -> list[str]: ...
+    def get_name(self) -> str: ...
+    def get_style(self) -> Literal["normal", "italic", "oblique"]: ...
+    def get_variant(self) -> Literal["normal", "small-caps"]: ...
+    def get_weight(self) -> int | str: ...
+    def get_stretch(self) -> int | str: ...
+    def get_size(self) -> float: ...
+    def get_file(self) -> str | bytes | None: ...
+    def get_fontconfig_pattern(self) -> dict[str, list[Any]]: ...
+    def set_family(self, family: str | Iterable[str] | None) -> None: ...
+    def set_style(
+        self, style: Literal["normal", "italic", "oblique"] | None
+    ) -> None: ...
+    def set_variant(self, variant: Literal["normal", "small-caps"] | None) -> None: ...
+    def set_weight(self, weight: int | str | None) -> None: ...
+    def set_stretch(self, stretch: int | str | None) -> None: ...
+    def set_size(self, size: float | str | None) -> None: ...
+    def set_file(self, file: str | os.PathLike | Path | None) -> None: ...
+    def set_fontconfig_pattern(self, pattern: str) -> None: ...
+    def get_math_fontfamily(self) -> str: ...
+    def set_math_fontfamily(self, fontfamily: str | None) -> None: ...
+    def copy(self) -> FontProperties: ...
+    # Aliases
+    set_name = set_family
+    get_slant = get_style
+    set_slant = set_style
+    get_size_in_points = get_size
+
+def json_dump(data: FontManager, filename: str | Path | os.PathLike) -> None: ...
+def json_load(filename: str | Path | os.PathLike) -> FontManager: ...
+
+class FontManager:
+    __version__: int
+    default_size: float | None
+    defaultFamily: dict[str, str]
+    afmlist: list[FontEntry]
+    ttflist: list[FontEntry]
+    def __init__(self, size: float | None = ..., weight: str = ...) -> None: ...
+    def addfont(self, path: str | Path | os.PathLike) -> None: ...
+    @property
+    def defaultFont(self) -> dict[str, str]: ...
+    def get_default_weight(self) -> str: ...
+    @staticmethod
+    def get_default_size() -> float: ...
+    def set_default_weight(self, weight: str) -> None: ...
+    def score_family(
+        self, families: str | list[str] | tuple[str], family2: str
+    ) -> float: ...
+    def score_style(self, style1: str, style2: str) -> float: ...
+    def score_variant(self, variant1: str, variant2: str) -> float: ...
+    def score_stretch(self, stretch1: str | int, stretch2: str | int) -> float: ...
+    def score_weight(self, weight1: str | float, weight2: str | float) -> float: ...
+    def score_size(self, size1: str | float, size2: str | float) -> float: ...
+    def findfont(
+        self,
+        prop: str | FontProperties,
+        fontext: Literal["ttf", "afm"] = ...,
+        directory: str | None = ...,
+        fallback_to_default: bool = ...,
+        rebuild_if_missing: bool = ...,
+    ) -> str: ...
+    def get_font_names(self) -> list[str]: ...
+
+def is_opentype_cff_font(filename: str) -> bool: ...
+def get_font(
+    font_filepaths: Iterable[str | Path | bytes] | str | Path | bytes,
+    hinting_factor: int | None = ...,
+) -> ft2font.FT2Font: ...
+
+fontManager: FontManager
+
+def findfont(
+    prop: str | FontProperties,
+    fontext: Literal["ttf", "afm"] = ...,
+    directory: str | None = ...,
+    fallback_to_default: bool = ...,
+    rebuild_if_missing: bool = ...,
+) -> str: ...
+def get_font_names() -> list[str]: ...

llava_video/lib/python3.10/site-packages/matplotlib/hatch.py

@@ -0,0 +1,225 @@
+"""Contains classes for generating hatch patterns."""
+
+import numpy as np
+
+from matplotlib import _api
+from matplotlib.path import Path
+
+
+class HatchPatternBase:
+    """The base class for a hatch pattern."""
+    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.
+        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.
+        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(  # Forward, then backward.
+                [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(r'-+|/\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',  # one release after custom hatches (#20690)
+                message=f'hatch must consist of a string of "{valid}" or '
+                        'None, but found the following invalid values '
+                        f'"{invalids}". Passing invalid values is deprecated '
+                        'since %(since)s and will become an error in %(removal)s.'
+            )
+
+
+def get_path(hatchpattern, density=6):
+    """
+    Given a hatch specifier, *hatchpattern*, generates Path to render
+    the hatch in a unit square.  *density* is the number of lines per
+    unit square.
+    """
+    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)

llava_video/lib/python3.10/site-packages/matplotlib/legend_handler.py

@@ -0,0 +1,813 @@
+"""
+Default legend handlers.
+
+.. important::
+
+    This is a low-level legend API, which most end users do not need.
+
+    We recommend that you are familiar with the :ref:`legend guide
+    <legend_guide>` before reading this documentation.
+
+Legend handlers are expected to be a callable object with a following
+signature::
+
+    legend_handler(legend, orig_handle, fontsize, handlebox)
+
+Where *legend* is the legend itself, *orig_handle* is the original
+plot, *fontsize* is the fontsize in pixels, and *handlebox* is an
+`.OffsetBox` instance. Within the call, you should create relevant
+artists (using relevant properties from the *legend* and/or
+*orig_handle*) and add them into the *handlebox*. The artists need to
+be scaled according to the *fontsize* (note that the size is in pixels,
+i.e., this is dpi-scaled value).
+
+This module includes definition of several legend handler classes
+derived from the base class (HandlerBase) with the following method::
+
+    def legend_artist(self, legend, orig_handle, fontsize, handlebox)
+"""
+
+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:
+    """
+    A base class for default legend handlers.
+
+    The derived classes are meant to override *create_artists* method, which
+    has the following signature::
+
+      def create_artists(self, legend, orig_handle,
+                         xdescent, ydescent, width, height, fontsize,
+                         trans):
+
+    The overridden method needs to create artists of the given
+    transform that fits in the given dimension (xdescent, ydescent,
+    width, height) that are scaled by fontsize if necessary.
+
+    """
+    def __init__(self, xpad=0., ypad=0., update_func=None):
+        """
+        Parameters
+        ----------
+        xpad : float, optional
+            Padding in x-direction.
+        ypad : float, optional
+            Padding in y-direction.
+        update_func : callable, optional
+            Function for updating the legend handler properties from another
+            legend handler, used by `~HandlerBase.update_prop`.
+        """
+        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):
+        """
+        Return the artist that this HandlerBase generates for the given
+        original artist/handle.
+
+        Parameters
+        ----------
+        legend : `~matplotlib.legend.Legend`
+            The legend for which these legend artists are being created.
+        orig_handle : :class:`matplotlib.artist.Artist` or similar
+            The object for which these legend artists are being created.
+        fontsize : int
+            The fontsize in pixels. The artists being created should
+            be scaled according to the given fontsize.
+        handlebox : `~matplotlib.offsetbox.OffsetBox`
+            The box which has been created to hold this legend entry's
+            artists. Artists created in the `legend_artist` method must
+            be added to this handlebox inside this method.
+
+        """
+        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())
+
+        # create_artists will return a list of artists.
+        for a in artists:
+            handlebox.add_artist(a)
+
+        # we only return the first artist
+        return artists[0]
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        """
+        Return the legend artists generated.
+
+        Parameters
+        ----------
+        legend : `~matplotlib.legend.Legend`
+            The legend for which these legend artists are being created.
+        orig_handle : `~matplotlib.artist.Artist` or similar
+            The object for which these legend artists are being created.
+        xdescent, ydescent, width, height : int
+            The rectangle (*xdescent*, *ydescent*, *width*, *height*) that the
+            legend artists being created should fit within.
+        fontsize : int
+            The fontsize in pixels. The legend artists being created should
+            be scaled according to the given fontsize.
+        trans : `~matplotlib.transforms.Transform`
+            The transform that is applied to the legend artists being created.
+            Typically from unit coordinates in the handler box to screen
+            coordinates.
+        """
+        raise NotImplementedError('Derived must override')
+
+
+class HandlerNpoints(HandlerBase):
+    """
+    A legend handler that shows *numpoints* points in the legend entry.
+    """
+
+    def __init__(self, marker_pad=0.3, numpoints=None, **kwargs):
+        """
+        Parameters
+        ----------
+        marker_pad : float
+            Padding between points in legend entry.
+        numpoints : int
+            Number of points to show in legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        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:
+            # we put some pad here to compensate the size of the marker
+            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):
+    """
+    A legend handler that shows *numpoints* in the legend, and allows them to
+    be individually offset in the y-direction.
+    """
+
+    def __init__(self, numpoints=None, yoffsets=None, **kwargs):
+        """
+        Parameters
+        ----------
+        numpoints : int
+            Number of points to show in legend entry.
+        yoffsets : array of floats
+            Length *numpoints* list of y offsets for each point in
+            legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerNpoints`.
+        """
+        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):
+    """
+    Original handler for `.Line2D` instances, that relies on combining
+    a line-only with a marker-only artist.  May be deprecated in the future.
+    """
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        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)
+        # we don't want to add this to the return list because
+        # the texts and handles are assumed to be in one-to-one
+        # correspondence.
+        legline._legmarker = legline_marker
+
+        legline.set_transform(trans)
+        legline_marker.set_transform(trans)
+
+        return [legline, legline_marker]
+
+
+class HandlerLine2D(HandlerNpoints):
+    """
+    Handler for `.Line2D` instances.
+
+    See Also
+    --------
+    HandlerLine2DCompound : An earlier handler implementation, which used one
+                            artist for the line and another for the marker(s).
+    """
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        xdata, xdata_marker = self.get_xdata(legend, xdescent, ydescent,
+                                             width, height, fontsize)
+
+        markevery = None
+        if self.get_numpoints(legend) == 1:
+            # Special case: one wants a single marker in the center
+            # and a line that extends on both sides. One will use a
+            # 3 points line, but only mark the #1 (i.e. middle) point.
+            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):
+    """
+    Handler for `.Patch` instances.
+    """
+
+    def __init__(self, patch_func=None, **kwargs):
+        """
+        Parameters
+        ----------
+        patch_func : callable, optional
+            The function that creates the legend key artist.
+            *patch_func* should have the signature::
+
+                def patch_func(legend=legend, orig_handle=orig_handle,
+                               xdescent=xdescent, ydescent=ydescent,
+                               width=width, height=height, fontsize=fontsize)
+
+            Subsequently, the created artist will have its ``update_prop``
+            method called and the appropriate transform will be applied.
+
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        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):
+        # docstring inherited
+        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):
+    """
+    Handler for `~.matplotlib.patches.StepPatch` instances.
+    """
+
+    @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):
+        # Unfilled StepPatch should show as a line
+        legline = Line2D([0, width], [height/2, height/2],
+                         color=orig_handle.get_edgecolor(),
+                         linestyle=orig_handle.get_linestyle(),
+                         linewidth=orig_handle.get_linewidth(),
+                         )
+
+        # Overwrite manually because patch and line properties don't mix
+        legline.set_drawstyle('default')
+        legline.set_marker("")
+        return legline
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        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):
+    """
+    Handler for `.LineCollection` instances.
+    """
+    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):
+        # docstring inherited
+        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):
+    r"""Handler for `.RegularPolyCollection`\s."""
+
+    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 = [.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._set_artist_props(legend_handle)
+        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):
+        # docstring inherited
+        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):
+    r"""Handler for `.PathCollection`\s, which are used by `~.Axes.scatter`."""
+
+    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):
+    r"""Handler for `.CircleCollection`\s."""
+
+    def create_collection(self, orig_handle, sizes, offsets, offset_transform):
+        return type(orig_handle)(
+            sizes, offsets=offsets, offset_transform=offset_transform)
+
+
+class HandlerErrorbar(HandlerLine2D):
+    """Handler for Errorbars."""
+
+    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):
+        # docstring inherited
+        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)
+
+        # when plotlines are None (only errorbars are drawn), we just
+        # make legline invisible.
+        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):
+    """
+    Handler for plots produced by `~.Axes.stem`.
+    """
+
+    def __init__(self, marker_pad=0.3, numpoints=None,
+                 bottom=None, yoffsets=None, **kwargs):
+        """
+        Parameters
+        ----------
+        marker_pad : float, default: 0.3
+            Padding between points in legend entry.
+        numpoints : int, optional
+            Number of points to show in legend entry.
+        bottom : float, optional
+
+        yoffsets : array of floats, optional
+            Length *numpoints* list of y offsets for each point in
+            legend entry.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerNpointsYoffsets`.
+        """
+        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):
+        # docstring inherited
+        markerline, stemlines, baseline = orig_handle
+        # Check to see if the stemcontainer is storing lines as a list or a
+        # LineCollection. Eventually using a list will be removed, and this
+        # logic can also be removed.
+        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.
+        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:
+            # change the function used by update_prop() from the default
+            # to one that handles LineCollection
+            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):
+        """
+        Copy properties from the `.LineCollection` *orig_handle* to the
+        `.Line2D` *legend_handle*.
+        """
+        legend_handle.set_color(orig_handle.get_color()[0])
+        legend_handle.set_linestyle(orig_handle.get_linestyle()[0])
+
+
+class HandlerTuple(HandlerBase):
+    """
+    Handler for Tuple.
+    """
+
+    def __init__(self, ndivide=1, pad=None, **kwargs):
+        """
+        Parameters
+        ----------
+        ndivide : int or None, default: 1
+            The number of sections to divide the legend area into.  If None,
+            use the length of the input tuple.
+        pad : float, default: :rc:`legend.borderpad`
+            Padding in units of fraction of font size.
+        **kwargs
+            Keyword arguments forwarded to `.HandlerBase`.
+        """
+        self._ndivide = ndivide
+        self._pad = pad
+        super().__init__(**kwargs)
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize,
+                       trans):
+        # docstring inherited
+        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):
+    """
+    Handler for `.PolyCollection` used in `~.Axes.fill_between` and
+    `~.Axes.stackplot`.
+    """
+    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
+
+        # orig_handle is a PolyCollection and legend_handle is a Patch.
+        # Directly set Patch color attributes (must be RGBA tuples).
+        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()
+        # Hatch color is anomalous in having no getters and setters.
+        legend_handle._hatch_color = orig_handle._hatch_color
+        # Setters are fine for the remaining attributes.
+        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())
+        # Alpha is already taken into account by the color attributes.
+
+    def create_artists(self, legend, orig_handle,
+                       xdescent, ydescent, width, height, fontsize, trans):
+        # docstring inherited
+        p = Rectangle(xy=(-xdescent, -ydescent),
+                      width=width, height=height)
+        self.update_prop(p, orig_handle, legend)
+        p.set_transform(trans)
+        return [p]

llava_video/lib/python3.10/site-packages/matplotlib/rcsetup.pyi

@@ -0,0 +1,159 @@
+from cycler import Cycler
+
+from collections.abc import Callable, Iterable
+from typing import Any, Literal, TypeVar
+from matplotlib.typing import ColorType, LineStyleType, MarkEveryType
+
+interactive_bk: list[str]
+non_interactive_bk: list[str]
+all_backends: list[str]
+
+_T = TypeVar("_T")
+
+def _listify_validator(s: Callable[[Any], _T]) -> Callable[[Any], list[_T]]: ...
+
+class ValidateInStrings:
+    key: str
+    ignorecase: bool
+    valid: dict[str, str]
+    def __init__(
+        self,
+        key: str,
+        valid: Iterable[str],
+        ignorecase: bool = ...,
+        *,
+        _deprecated_since: str | None = ...
+    ) -> None: ...
+    def __call__(self, s: Any) -> str: ...
+
+def validate_any(s: Any) -> Any: ...
+def validate_anylist(s: Any) -> list[Any]: ...
+def validate_bool(b: Any) -> bool: ...
+def validate_axisbelow(s: Any) -> bool | Literal["line"]: ...
+def validate_dpi(s: Any) -> Literal["figure"] | float: ...
+def validate_string(s: Any) -> str: ...
+def validate_string_or_None(s: Any) -> str | None: ...
+def validate_stringlist(s: Any) -> list[str]: ...
+def validate_int(s: Any) -> int: ...
+def validate_int_or_None(s: Any) -> int | None: ...
+def validate_float(s: Any) -> float: ...
+def validate_float_or_None(s: Any) -> float | None: ...
+def validate_floatlist(s: Any) -> list[float]: ...
+def _validate_marker(s: Any) -> int | str: ...
+def _validate_markerlist(s: Any) -> list[int | str]: ...
+def validate_fonttype(s: Any) -> int: ...
+
+_auto_backend_sentinel: object
+
+def validate_backend(s: Any) -> str: ...
+def validate_color_or_inherit(s: Any) -> Literal["inherit"] | ColorType: ...
+def validate_color_or_auto(s: Any) -> ColorType | Literal["auto"]: ...
+def validate_color_for_prop_cycle(s: Any) -> ColorType: ...
+def validate_color(s: Any) -> ColorType: ...
+def validate_colorlist(s: Any) -> list[ColorType]: ...
+def _validate_color_or_linecolor(
+    s: Any,
+) -> ColorType | Literal["linecolor", "markerfacecolor", "markeredgecolor"] | None: ...
+def validate_aspect(s: Any) -> Literal["auto", "equal"] | float: ...
+def validate_fontsize_None(
+    s: Any,
+) -> Literal[
+    "xx-small",
+    "x-small",
+    "small",
+    "medium",
+    "large",
+    "x-large",
+    "xx-large",
+    "smaller",
+    "larger",
+] | float | None: ...
+def validate_fontsize(
+    s: Any,
+) -> Literal[
+    "xx-small",
+    "x-small",
+    "small",
+    "medium",
+    "large",
+    "x-large",
+    "xx-large",
+    "smaller",
+    "larger",
+] | float: ...
+def validate_fontsizelist(
+    s: Any,
+) -> list[
+    Literal[
+        "xx-small",
+        "x-small",
+        "small",
+        "medium",
+        "large",
+        "x-large",
+        "xx-large",
+        "smaller",
+        "larger",
+    ]
+    | float
+]: ...
+def validate_fontweight(
+    s: Any,
+) -> Literal[
+    "ultralight",
+    "light",
+    "normal",
+    "regular",
+    "book",
+    "medium",
+    "roman",
+    "semibold",
+    "demibold",
+    "demi",
+    "bold",
+    "heavy",
+    "extra bold",
+    "black",
+] | int: ...
+def validate_fontstretch(
+    s: Any,
+) -> Literal[
+    "ultra-condensed",
+    "extra-condensed",
+    "condensed",
+    "semi-condensed",
+    "normal",
+    "semi-expanded",
+    "expanded",
+    "extra-expanded",
+    "ultra-expanded",
+] | int: ...
+def validate_font_properties(s: Any) -> dict[str, Any]: ...
+def validate_whiskers(s: Any) -> list[float] | float: ...
+def validate_ps_distiller(s: Any) -> None | Literal["ghostscript", "xpdf"]: ...
+
+validate_fillstyle: ValidateInStrings
+
+def validate_fillstylelist(
+    s: Any,
+) -> list[Literal["full", "left", "right", "bottom", "top", "none"]]: ...
+def validate_markevery(s: Any) -> MarkEveryType: ...
+def _validate_linestyle(s: Any) -> LineStyleType: ...
+def validate_markeverylist(s: Any) -> list[MarkEveryType]: ...
+def validate_bbox(s: Any) -> Literal["tight", "standard"] | None: ...
+def validate_sketch(s: Any) -> None | tuple[float, float, float]: ...
+def validate_hatch(s: Any) -> str: ...
+def validate_hatchlist(s: Any) -> list[str]: ...
+def validate_dashlist(s: Any) -> list[list[float]]: ...
+
+# TODO: copy cycler overloads?
+def cycler(*args, **kwargs) -> Cycler: ...
+def validate_cycler(s: Any) -> Cycler: ...
+def validate_hist_bins(
+    s: Any,
+) -> Literal["auto", "sturges", "fd", "doane", "scott", "rice", "sqrt"] | int | list[
+    float
+]: ...
+
+# At runtime is added in __init__.py
+defaultParams: dict[str, Any]

llava_video/lib/python3.10/site-packages/matplotlib/widgets.pyi

@@ -0,0 +1,488 @@
+from .artist import Artist
+from .axes import Axes
+from .backend_bases import FigureCanvasBase, Event, MouseEvent, MouseButton
+from .collections import LineCollection
+from .figure import Figure
+from .lines import Line2D
+from .patches import Polygon, Rectangle
+from .text import Text
+
+import PIL.Image
+
+from collections.abc import Callable, Collection, Iterable, Sequence
+from typing import Any, Literal
+from numpy.typing import ArrayLike
+from .typing import ColorType
+import numpy as np
+
+class LockDraw:
+    def __init__(self) -> None: ...
+    def __call__(self, o: Any) -> None: ...
+    def release(self, o: Any) -> None: ...
+    def available(self, o: Any) -> bool: ...
+    def isowner(self, o: Any) -> bool: ...
+    def locked(self) -> bool: ...
+
+class Widget:
+    drawon: bool
+    eventson: bool
+    active: bool
+    def set_active(self, active: bool) -> None: ...
+    def get_active(self) -> None: ...
+    def ignore(self, event) -> bool: ...
+
+class AxesWidget(Widget):
+    ax: Axes
+    def __init__(self, ax: Axes) -> None: ...
+    @property
+    def canvas(self) -> FigureCanvasBase | None: ...
+    def connect_event(self, event: Event, callback: Callable) -> None: ...
+    def disconnect_events(self) -> None: ...
+
+class Button(AxesWidget):
+    label: Text
+    color: ColorType
+    hovercolor: ColorType
+    def __init__(
+        self,
+        ax: Axes,
+        label: str,
+        image: ArrayLike | PIL.Image.Image | None = ...,
+        color: ColorType = ...,
+        hovercolor: ColorType = ...,
+        *,
+        useblit: bool = ...
+    ) -> None: ...
+    def on_clicked(self, func: Callable[[Event], Any]) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+
+class SliderBase(AxesWidget):
+    orientation: Literal["horizontal", "vertical"]
+    closedmin: bool
+    closedmax: bool
+    valmin: float
+    valmax: float
+    valstep: float | ArrayLike | None
+    drag_active: bool
+    valfmt: str
+    def __init__(
+        self,
+        ax: Axes,
+        orientation: Literal["horizontal", "vertical"],
+        closedmin: bool,
+        closedmax: bool,
+        valmin: float,
+        valmax: float,
+        valfmt: str,
+        dragging: Slider | None,
+        valstep: float | ArrayLike | None,
+    ) -> None: ...
+    def disconnect(self, cid: int) -> None: ...
+    def reset(self) -> None: ...
+
+class Slider(SliderBase):
+    slidermin: Slider | None
+    slidermax: Slider | None
+    val: float
+    valinit: float
+    track: Rectangle
+    poly: Polygon
+    hline: Line2D
+    vline: Line2D
+    label: Text
+    valtext: Text
+    def __init__(
+        self,
+        ax: Axes,
+        label: str,
+        valmin: float,
+        valmax: float,
+        *,
+        valinit: float = ...,
+        valfmt: str | None = ...,
+        closedmin: bool = ...,
+        closedmax: bool = ...,
+        slidermin: Slider | None = ...,
+        slidermax: Slider | None = ...,
+        dragging: bool = ...,
+        valstep: float | ArrayLike | None = ...,
+        orientation: Literal["horizontal", "vertical"] = ...,
+        initcolor: ColorType = ...,
+        track_color: ColorType = ...,
+        handle_style: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_val(self, val: float) -> None: ...
+    def on_changed(self, func: Callable[[float], Any]) -> int: ...
+
+class RangeSlider(SliderBase):
+    val: tuple[float, float]
+    valinit: tuple[float, float]
+    track: Rectangle
+    poly: Polygon
+    label: Text
+    valtext: Text
+    def __init__(
+        self,
+        ax: Axes,
+        label: str,
+        valmin: float,
+        valmax: float,
+        *,
+        valinit: tuple[float, float] | None = ...,
+        valfmt: str | None = ...,
+        closedmin: bool = ...,
+        closedmax: bool = ...,
+        dragging: bool = ...,
+        valstep: float | ArrayLike | None = ...,
+        orientation: Literal["horizontal", "vertical"] = ...,
+        track_color: ColorType = ...,
+        handle_style: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> None: ...
+    def set_min(self, min: float) -> None: ...
+    def set_max(self, max: float) -> None: ...
+    def set_val(self, val: ArrayLike) -> None: ...
+    def on_changed(self, func: Callable[[tuple[float, float]], Any]) -> int: ...
+
+class CheckButtons(AxesWidget):
+    labels: list[Text]
+    def __init__(
+        self,
+        ax: Axes,
+        labels: Sequence[str],
+        actives: Iterable[bool] | None = ...,
+        *,
+        useblit: bool = ...,
+        label_props: dict[str, Any] | None = ...,
+        frame_props: dict[str, Any] | None = ...,
+        check_props: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def set_label_props(self, props: dict[str, Any]) -> None: ...
+    def set_frame_props(self, props: dict[str, Any]) -> None: ...
+    def set_check_props(self, props: dict[str, Any]) -> None: ...
+    def set_active(self, index: int, state: bool | None = ...) -> None: ...  # type: ignore[override]
+    def clear(self) -> None: ...
+    def get_status(self) -> list[bool]: ...
+    def get_checked_labels(self) -> list[str]: ...
+    def on_clicked(self, func: Callable[[str | None], Any]) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+
+class TextBox(AxesWidget):
+    label: Text
+    text_disp: Text
+    cursor_index: int
+    cursor: LineCollection
+    color: ColorType
+    hovercolor: ColorType
+    capturekeystrokes: bool
+    def __init__(
+        self,
+        ax: Axes,
+        label: str,
+        initial: str = ...,
+        *,
+        color: ColorType = ...,
+        hovercolor: ColorType = ...,
+        label_pad: float = ...,
+        textalignment: Literal["left", "center", "right"] = ...,
+    ) -> None: ...
+    @property
+    def text(self) -> str: ...
+    def set_val(self, val: str) -> None: ...
+    def begin_typing(self) -> None: ...
+    def stop_typing(self) -> None: ...
+    def on_text_change(self, func: Callable[[str], Any]) -> int: ...
+    def on_submit(self, func: Callable[[str], Any]) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+
+class RadioButtons(AxesWidget):
+    activecolor: ColorType
+    value_selected: str
+    labels: list[Text]
+    def __init__(
+        self,
+        ax: Axes,
+        labels: Iterable[str],
+        active: int = ...,
+        activecolor: ColorType | None = ...,
+        *,
+        useblit: bool = ...,
+        label_props: dict[str, Any] | Sequence[dict[str, Any]] | None = ...,
+        radio_props: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def set_label_props(self, props: dict[str, Any]) -> None: ...
+    def set_radio_props(self, props: dict[str, Any]) -> None: ...
+    def set_active(self, index: int) -> None: ...
+    def clear(self) -> None: ...
+    def on_clicked(self, func: Callable[[str | None], Any]) -> int: ...
+    def disconnect(self, cid: int) -> None: ...
+
+class SubplotTool(Widget):
+    figure: Figure
+    targetfig: Figure
+    buttonreset: Button
+    def __init__(self, targetfig: Figure, toolfig: Figure) -> None: ...
+
+class Cursor(AxesWidget):
+    visible: bool
+    horizOn: bool
+    vertOn: bool
+    useblit: bool
+    lineh: Line2D
+    linev: Line2D
+    background: Any
+    needclear: bool
+    def __init__(
+        self,
+        ax: Axes,
+        *,
+        horizOn: bool = ...,
+        vertOn: bool = ...,
+        useblit: bool = ...,
+        **lineprops
+    ) -> None: ...
+    def clear(self, event: Event) -> None: ...
+    def onmove(self, event: Event) -> None: ...
+
+class MultiCursor(Widget):
+    axes: Sequence[Axes]
+    horizOn: bool
+    vertOn: bool
+    visible: bool
+    useblit: bool
+    vlines: list[Line2D]
+    hlines: list[Line2D]
+    def __init__(
+        self,
+        canvas: Any,
+        axes: Sequence[Axes],
+        *,
+        useblit: bool = ...,
+        horizOn: bool = ...,
+        vertOn: bool = ...,
+        **lineprops
+    ) -> None: ...
+    def connect(self) -> None: ...
+    def disconnect(self) -> None: ...
+    def clear(self, event: Event) -> None: ...
+    def onmove(self, event: Event) -> None: ...
+
+class _SelectorWidget(AxesWidget):
+    onselect: Callable[[float, float], Any]
+    useblit: bool
+    background: Any
+    validButtons: list[MouseButton]
+    def __init__(
+        self,
+        ax: Axes,
+        onselect: Callable[[float, float], Any] | None = ...,
+        useblit: bool = ...,
+        button: MouseButton | Collection[MouseButton] | None = ...,
+        state_modifier_keys: dict[str, str] | None = ...,
+        use_data_coordinates: bool = ...,
+    ) -> None: ...
+    def update_background(self, event: Event) -> None: ...
+    def connect_default_events(self) -> None: ...
+    def ignore(self, event: Event) -> bool: ...
+    def update(self) -> None: ...
+    def press(self, event: Event) -> bool: ...
+    def release(self, event: Event) -> bool: ...
+    def onmove(self, event: Event) -> bool: ...
+    def on_scroll(self, event: Event) -> None: ...
+    def on_key_press(self, event: Event) -> None: ...
+    def on_key_release(self, event: Event) -> None: ...
+    def set_visible(self, visible: bool) -> None: ...
+    def get_visible(self) -> bool: ...
+    def clear(self) -> None: ...
+    @property
+    def artists(self) -> tuple[Artist]: ...
+    def set_props(self, **props) -> None: ...
+    def set_handle_props(self, **handle_props) -> None: ...
+    def add_state(self, state: str) -> None: ...
+    def remove_state(self, state: str) -> None: ...
+
+class SpanSelector(_SelectorWidget):
+    snap_values: ArrayLike | None
+    onmove_callback: Callable[[float, float], Any]
+    minspan: float
+    grab_range: float
+    drag_from_anywhere: bool
+    ignore_event_outside: bool
+    def __init__(
+        self,
+        ax: Axes,
+        onselect: Callable[[float, float], Any],
+        direction: Literal["horizontal", "vertical"],
+        *,
+        minspan: float = ...,
+        useblit: bool = ...,
+        props: dict[str, Any] | None = ...,
+        onmove_callback: Callable[[float, float], Any] | None = ...,
+        interactive: bool = ...,
+        button: MouseButton | Collection[MouseButton] | None = ...,
+        handle_props: dict[str, Any] | None = ...,
+        grab_range: float = ...,
+        state_modifier_keys: dict[str, str] | None = ...,
+        drag_from_anywhere: bool = ...,
+        ignore_event_outside: bool = ...,
+        snap_values: ArrayLike | None = ...,
+    ) -> None: ...
+    def new_axes(
+        self,
+        ax: Axes,
+        *,
+        _props: dict[str, Any] | None = ...,
+        _init: bool = ...,
+    ) -> None: ...
+    def connect_default_events(self) -> None: ...
+    @property
+    def direction(self) -> Literal["horizontal", "vertical"]: ...
+    @direction.setter
+    def direction(self, direction: Literal["horizontal", "vertical"]) -> None: ...
+    @property
+    def extents(self) -> tuple[float, float]: ...
+    @extents.setter
+    def extents(self, extents: tuple[float, float]) -> None: ...
+
+class ToolLineHandles:
+    ax: Axes
+    def __init__(
+        self,
+        ax: Axes,
+        positions: ArrayLike,
+        direction: Literal["horizontal", "vertical"],
+        *,
+        line_props: dict[str, Any] | None = ...,
+        useblit: bool = ...,
+    ) -> None: ...
+    @property
+    def artists(self) -> tuple[Line2D]: ...
+    @property
+    def positions(self) -> list[float]: ...
+    @property
+    def direction(self) -> Literal["horizontal", "vertical"]: ...
+    def set_data(self, positions: ArrayLike) -> None: ...
+    def set_visible(self, value: bool) -> None: ...
+    def set_animated(self, value: bool) -> None: ...
+    def remove(self) -> None: ...
+    def closest(self, x: float, y: float) -> tuple[int, float]: ...
+
+class ToolHandles:
+    ax: Axes
+    def __init__(
+        self,
+        ax: Axes,
+        x: ArrayLike,
+        y: ArrayLike,
+        *,
+        marker: str = ...,
+        marker_props: dict[str, Any] | None = ...,
+        useblit: bool = ...,
+    ) -> None: ...
+    @property
+    def x(self) -> ArrayLike: ...
+    @property
+    def y(self) -> ArrayLike: ...
+    @property
+    def artists(self) -> tuple[Line2D]: ...
+    def set_data(self, pts: ArrayLike, y: ArrayLike | None = ...) -> None: ...
+    def set_visible(self, val: bool) -> None: ...
+    def set_animated(self, val: bool) -> None: ...
+    def closest(self, x: float, y: float) -> tuple[int, float]: ...
+
+class RectangleSelector(_SelectorWidget):
+    drag_from_anywhere: bool
+    ignore_event_outside: bool
+    minspanx: float
+    minspany: float
+    spancoords: Literal["data", "pixels"]
+    grab_range: float
+    def __init__(
+        self,
+        ax: Axes,
+        onselect: Callable[[MouseEvent, MouseEvent], Any] | None = ...,
+        *,
+        minspanx: float = ...,
+        minspany: float = ...,
+        useblit: bool = ...,
+        props: dict[str, Any] | None = ...,
+        spancoords: Literal["data", "pixels"] = ...,
+        button: MouseButton | Collection[MouseButton] | None = ...,
+        grab_range: float = ...,
+        handle_props: dict[str, Any] | None = ...,
+        interactive: bool = ...,
+        state_modifier_keys: dict[str, str] | None = ...,
+        drag_from_anywhere: bool = ...,
+        ignore_event_outside: bool = ...,
+        use_data_coordinates: bool = ...,
+    ) -> None: ...
+    @property
+    def corners(self) -> tuple[np.ndarray, np.ndarray]: ...
+    @property
+    def edge_centers(self) -> tuple[np.ndarray, np.ndarray]: ...
+    @property
+    def center(self) -> tuple[float, float]: ...
+    @property
+    def extents(self) -> tuple[float, float, float, float]: ...
+    @extents.setter
+    def extents(self, extents: tuple[float, float, float, float]) -> None: ...
+    @property
+    def rotation(self) -> float: ...
+    @rotation.setter
+    def rotation(self, value: float) -> None: ...
+    @property
+    def geometry(self) -> np.ndarray: ...
+
+class EllipseSelector(RectangleSelector): ...
+
+class LassoSelector(_SelectorWidget):
+    verts: None | list[tuple[float, float]]
+    def __init__(
+        self,
+        ax: Axes,
+        onselect: Callable[[list[tuple[float, float]]], Any] | None = ...,
+        *,
+        useblit: bool = ...,
+        props: dict[str, Any] | None = ...,
+        button: MouseButton | Collection[MouseButton] | None = ...,
+    ) -> None: ...
+
+class PolygonSelector(_SelectorWidget):
+    grab_range: float
+    def __init__(
+        self,
+        ax: Axes,
+        onselect: Callable[[ArrayLike, ArrayLike], Any] | None = ...,
+        *,
+        useblit: bool = ...,
+        props: dict[str, Any] | None = ...,
+        handle_props: dict[str, Any] | None = ...,
+        grab_range: float = ...,
+        draw_bounding_box: bool = ...,
+        box_handle_props: dict[str, Any] | None = ...,
+        box_props: dict[str, Any] | None = ...
+    ) -> None: ...
+    def onmove(self, event: Event) -> bool: ...
+    @property
+    def verts(self) -> list[tuple[float, float]]: ...
+    @verts.setter
+    def verts(self, xys: Sequence[tuple[float, float]]) -> None: ...
+
+class Lasso(AxesWidget):
+    useblit: bool
+    background: Any
+    verts: list[tuple[float, float]] | None
+    line: Line2D
+    callback: Callable[[list[tuple[float, float]]], Any]
+    def __init__(
+        self,
+        ax: Axes,
+        xy: tuple[float, float],
+        callback: Callable[[list[tuple[float, float]]], Any],
+        *,
+        useblit: bool = ...,
+        props: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def onrelease(self, event: Event) -> None: ...
+    def onmove(self, event: Event) -> None: ...

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_amp_update_scale_meta_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor & _amp_update_scale_(at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval);
+
+} // namespace meta
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_batch_norm_no_update_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _batch_norm_no_update {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double, double);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_batch_norm_no_update")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_batch_norm_no_update(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, float momentum, float eps) -> (Tensor, Tensor, Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps);
+};
+
+struct TORCH_API _batch_norm_no_update_out {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double, double, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_batch_norm_no_update")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_batch_norm_no_update.out(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, float momentum, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!))")
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3);
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_backward.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/_cdist_backward_ops.h>
+
+namespace at {
+
+
+// aten::_cdist_backward(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist) -> Tensor
+inline at::Tensor _cdist_backward(const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist) {
+    return at::_ops::_cdist_backward::call(grad, x1, x2, p, cdist);
+}
+
+// aten::_cdist_backward.out(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _cdist_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist) {
+    return at::_ops::_cdist_backward_out::call(grad, x1, x2, p, cdist, out);
+}
+// aten::_cdist_backward.out(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _cdist_backward_outf(const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist, at::Tensor & out) {
+    return at::_ops::_cdist_backward_out::call(grad, x1, x2, p, cdist, out);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_conj_copy.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/_conj_copy_ops.h>
+
+namespace at {
+
+
+// aten::_conj_copy(Tensor self) -> Tensor
+inline at::Tensor _conj_copy(const at::Tensor & self) {
+    return at::_ops::_conj_copy::call(self);
+}
+
+// aten::_conj_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _conj_copy_out(at::Tensor & out, const at::Tensor & self) {
+    return at::_ops::_conj_copy_out::call(self, out);
+}
+// aten::_conj_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _conj_copy_outf(const at::Tensor & self, at::Tensor & out) {
+    return at::_ops::_conj_copy_out::call(self, out);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_convert_indices_from_coo_to_csr_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured__convert_indices_from_coo_to_csr : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & self, int64_t size, bool out_int32);
+};
+
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_efficient_attention_backward_cuda_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> _efficient_attention_backward(const at::Tensor & grad_out_, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional<at::Tensor> & bias, const at::Tensor & out, const ::std::optional<at::Tensor> & cu_seqlens_q, const ::std::optional<at::Tensor> & cu_seqlens_k, int64_t max_seqlen_q, int64_t max_seqlen_k, const at::Tensor & logsumexp, double dropout_p, const at::Tensor & philox_seed, const at::Tensor & philox_offset, int64_t custom_mask_type, bool bias_requires_grad, ::std::optional<double> scale=::std::nullopt, ::std::optional<int64_t> num_splits_key=::std::nullopt, ::std::optional<int64_t> window_size=::std::nullopt, bool shared_storage_dqdkdv=false);
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> _efficient_attention_backward_symint(const at::Tensor & grad_out_, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional<at::Tensor> & bias, const at::Tensor & out, const ::std::optional<at::Tensor> & cu_seqlens_q, const ::std::optional<at::Tensor> & cu_seqlens_k, c10::SymInt max_seqlen_q, c10::SymInt max_seqlen_k, const at::Tensor & logsumexp, double dropout_p, const at::Tensor & philox_seed, const at::Tensor & philox_offset, int64_t custom_mask_type, bool bias_requires_grad, ::std::optional<double> scale=::std::nullopt, ::std::optional<int64_t> num_splits_key=::std::nullopt, ::std::optional<int64_t> window_size=::std::nullopt, bool shared_storage_dqdkdv=false);
+
+} // namespace cuda
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_log1p_cuda_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API ::std::vector<at::Tensor> _foreach_log1p(at::TensorList self);
+TORCH_API void _foreach_log1p_(at::TensorList self);
+
+} // namespace cuda
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_mul.h

@@ -0,0 +1,101 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/_foreach_mul_ops.h>
+
+namespace at {
+
+
+// aten::_foreach_mul.Scalar(Tensor[] self, Scalar scalar) -> Tensor[]
+inline ::std::vector<at::Tensor> _foreach_mul(at::TensorList self, const at::Scalar & scalar) {
+    return at::_ops::_foreach_mul_Scalar::call(self, scalar);
+}
+
+// aten::_foreach_mul_.Scalar(Tensor(a!)[] self, Scalar scalar) -> ()
+inline void _foreach_mul_(at::TensorList self, const at::Scalar & scalar) {
+    return at::_ops::_foreach_mul__Scalar::call(self, scalar);
+}
+
+// aten::_foreach_mul.List(Tensor[] self, Tensor[] other) -> Tensor[]
+inline ::std::vector<at::Tensor> _foreach_mul(at::TensorList self, at::TensorList other) {
+    return at::_ops::_foreach_mul_List::call(self, other);
+}
+
+// aten::_foreach_mul_.List(Tensor(a!)[] self, Tensor[] other) -> ()
+inline void _foreach_mul_(at::TensorList self, at::TensorList other) {
+    return at::_ops::_foreach_mul__List::call(self, other);
+}
+
+// aten::_foreach_mul.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[]
+inline ::std::vector<at::Tensor> _foreach_mul(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
+    return at::_ops::_foreach_mul_ScalarList::call(self, scalars);
+}
+
+// aten::_foreach_mul_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> ()
+inline void _foreach_mul_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
+    return at::_ops::_foreach_mul__ScalarList::call(self, scalars);
+}
+
+// aten::_foreach_mul.Tensor(Tensor[] self, Tensor other) -> Tensor[]
+inline ::std::vector<at::Tensor> _foreach_mul(at::TensorList self, const at::Tensor & other) {
+    return at::_ops::_foreach_mul_Tensor::call(self, other);
+}
+
+// aten::_foreach_mul_.Tensor(Tensor(a!)[] self, Tensor other) -> ()
+inline void _foreach_mul_(at::TensorList self, const at::Tensor & other) {
+    return at::_ops::_foreach_mul__Tensor::call(self, other);
+}
+
+// aten::_foreach_mul.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
+    return at::_ops::_foreach_mul_Scalar_out::call(self, scalar, out);
+}
+// aten::_foreach_mul.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
+    return at::_ops::_foreach_mul_Scalar_out::call(self, scalar, out);
+}
+
+// aten::_foreach_mul.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_out(at::TensorList out, at::TensorList self, at::TensorList other) {
+    return at::_ops::_foreach_mul_List_out::call(self, other, out);
+}
+// aten::_foreach_mul.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
+    return at::_ops::_foreach_mul_List_out::call(self, other, out);
+}
+
+// aten::_foreach_mul.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
+    return at::_ops::_foreach_mul_ScalarList_out::call(self, scalars, out);
+}
+// aten::_foreach_mul.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
+    return at::_ops::_foreach_mul_ScalarList_out::call(self, scalars, out);
+}
+
+// aten::_foreach_mul.Tensor_out(Tensor[] self, Tensor other, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_out(at::TensorList out, at::TensorList self, const at::Tensor & other) {
+    return at::_ops::_foreach_mul_Tensor_out::call(self, other, out);
+}
+// aten::_foreach_mul.Tensor_out(Tensor[] self, Tensor other, *, Tensor(a!)[] out) -> ()
+inline void _foreach_mul_outf(at::TensorList self, const at::Tensor & other, at::TensorList out) {
+    return at::_ops::_foreach_mul_Tensor_out::call(self, other, out);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_check_errors_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API void _linalg_check_errors(const at::Tensor & info, c10::string_view api_name, bool is_matrix);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_make_dual_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor _make_dual(const at::Tensor & primal, const at::Tensor & tangent, int64_t level);
+
+} // namespace compositeexplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_native_batch_norm_legit_ops.h

@@ -0,0 +1,72 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _native_batch_norm_legit {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, at::Tensor &, at::Tensor &, bool, double, double);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps);
+};
+
+struct TORCH_API _native_batch_norm_legit_out {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, at::Tensor &, at::Tensor &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!))")
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd);
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd);
+};
+
+struct TORCH_API _native_batch_norm_legit_no_stats {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, bool, double, double);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "no_stats")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit.no_stats(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, bool training, double momentum, double eps);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, bool training, double momentum, double eps);
+};
+
+struct TORCH_API _native_batch_norm_legit_no_stats_out {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "no_stats_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!))")
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd);
+  static ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd);
+};
+
+struct TORCH_API _native_batch_norm_legit_functional {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const at::Tensor &, const at::Tensor &, bool, double, double);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_native_batch_norm_legit_functional")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_native_batch_norm_legit_functional(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor, Tensor running_mean_out, Tensor running_var_out)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_view_from_buffer_copy.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/_nested_view_from_buffer_copy_ops.h>
+
+namespace at {
+
+
+// aten::_nested_view_from_buffer_copy(Tensor self, Tensor nested_size, Tensor nested_strides, Tensor offsets) -> Tensor
+inline at::Tensor _nested_view_from_buffer_copy(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets) {
+    return at::_ops::_nested_view_from_buffer_copy::call(self, nested_size, nested_strides, offsets);
+}
+
+// aten::_nested_view_from_buffer_copy.out(Tensor self, Tensor nested_size, Tensor nested_strides, Tensor offsets, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _nested_view_from_buffer_copy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets) {
+    return at::_ops::_nested_view_from_buffer_copy_out::call(self, nested_size, nested_strides, offsets, out);
+}
+// aten::_nested_view_from_buffer_copy.out(Tensor self, Tensor nested_size, Tensor nested_strides, Tensor offsets, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _nested_view_from_buffer_copy_outf(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets, at::Tensor & out) {
+    return at::_ops::_nested_view_from_buffer_copy_out::call(self, nested_size, nested_strides, offsets, out);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_pad_packed_sequence_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> _pad_packed_sequence(const at::Tensor & data, const at::Tensor & batch_sizes, bool batch_first, const at::Scalar & padding_value, int64_t total_length);
+
+} // namespace compositeimplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_prelu_kernel_cpu_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor _prelu_kernel(const at::Tensor & self, const at::Tensor & weight);
+
+} // namespace cpu
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_print_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _print {
+  using schema = void (c10::string_view);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_print")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_print(str s) -> ()")
+  static void call(c10::string_view s);
+  static void redispatch(c10::DispatchKeySet dispatchKeySet, c10::string_view s);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_fused_attention_overrideable_backward_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _scaled_dot_product_fused_attention_overrideable_backward {
+  using schema = ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array<bool,4>, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::SymInt, c10::SymInt, double, bool, const at::Tensor &, const at::Tensor &, ::std::optional<double>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_scaled_dot_product_fused_attention_overrideable_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_scaled_dot_product_fused_attention_overrideable_backward(Tensor grad_out, Tensor query, Tensor key, Tensor value, Tensor attn_bias, bool[4] grad_input_mask, Tensor out, Tensor logsumexp, Tensor cum_seq_q, Tensor cum_seq_k, SymInt max_q, SymInt max_k, float dropout_p, bool is_causal, Tensor philox_seed, Tensor philox_offset, *, float? scale=None) -> (Tensor grad_query, Tensor grad_key, Tensor grad_value, Tensor grad_attn_bias)")
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> call(const at::Tensor & grad_out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const at::Tensor & attn_bias, ::std::array<bool,4> grad_input_mask, const at::Tensor & out, const at::Tensor & logsumexp, const at::Tensor & cum_seq_q, const at::Tensor & cum_seq_k, c10::SymInt max_q, c10::SymInt max_k, double dropout_p, bool is_causal, const at::Tensor & philox_seed, const at::Tensor & philox_offset, ::std::optional<double> scale);
+  static ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const at::Tensor & attn_bias, ::std::array<bool,4> grad_input_mask, const at::Tensor & out, const at::Tensor & logsumexp, const at::Tensor & cum_seq_q, const at::Tensor & cum_seq_k, c10::SymInt max_q, c10::SymInt max_k, double dropout_p, bool is_causal, const at::Tensor & philox_seed, const at::Tensor & philox_offset, ::std::optional<double> scale);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_sobol_engine_ff_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor & _sobol_engine_ff_(at::Tensor & self, int64_t n, const at::Tensor & sobolstate, int64_t dimension, int64_t num_generated);
+
+} // namespace compositeimplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_bsr_tensor_unsafe_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _sparse_bsr_tensor_unsafe {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, ::std::optional<at::ScalarType>, ::std::optional<at::Layout>, ::std::optional<at::Device>, ::std::optional<bool>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_bsr_tensor_unsafe")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_bsr_tensor_unsafe(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor")
+  static at::Tensor call(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_semi_structured_linear_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor _sparse_semi_structured_linear(const at::Tensor & input, const at::Tensor & weight, const at::Tensor & meta, const ::std::optional<at::Tensor> & bias={}, ::std::optional<c10::string_view> activation=::std::nullopt, ::std::optional<at::ScalarType> out_dtype=::std::nullopt);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_test_check_tensor_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor _test_check_tensor(const at::Tensor & self);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact1d_backward_meta_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor _upsample_nearest_exact1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional<double> scales=::std::nullopt);
+TORCH_API at::Tensor _upsample_nearest_exact1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional<double> scales=::std::nullopt);
+TORCH_API at::Tensor & _upsample_nearest_exact1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional<double> scales=::std::nullopt);
+TORCH_API at::Tensor & _upsample_nearest_exact1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional<double> scales, at::Tensor & grad_input);
+TORCH_API at::Tensor & _upsample_nearest_exact1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional<double> scales=::std::nullopt);
+TORCH_API at::Tensor & _upsample_nearest_exact1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional<double> scales, at::Tensor & grad_input);
+
+} // namespace meta
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/acos_meta_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor acos(const at::Tensor & self);
+TORCH_API at::Tensor & acos_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & acos_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & acos_(at::Tensor & self);
+
+} // namespace meta
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/align_as_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor align_as(const at::Tensor & self, const at::Tensor & other);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/align_tensors_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API ::std::vector<at::Tensor> align_tensors(at::TensorList tensors);
+
+} // namespace compositeimplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/asin.h

@@ -0,0 +1,44 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/asin_ops.h>
+
+namespace at {
+
+
+// aten::asin(Tensor self) -> Tensor
+inline at::Tensor asin(const at::Tensor & self) {
+    return at::_ops::asin::call(self);
+}
+
+// aten::asin_(Tensor(a!) self) -> Tensor(a!)
+inline at::Tensor & asin_(at::Tensor & self) {
+    return at::_ops::asin_::call(self);
+}
+
+// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & asin_out(at::Tensor & out, const at::Tensor & self) {
+    return at::_ops::asin_out::call(self, out);
+}
+// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & asin_outf(const at::Tensor & self, at::Tensor & out) {
+    return at::_ops::asin_out::call(self, out);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/batch_norm_backward_elemt_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & batch_norm_backward_elemt_out(at::Tensor & out, const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, const at::Tensor & sum_dy, const at::Tensor & sum_dy_xmu, const at::Tensor & count);
+TORCH_API at::Tensor & batch_norm_backward_elemt_outf(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, const at::Tensor & sum_dy, const at::Tensor & sum_dy_xmu, const at::Tensor & count, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_or_native.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/bitwise_or_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_bitwise_or_out : public at::meta::structured_bitwise_or_Tensor {
+void impl(const at::Tensor & self, const at::Tensor & other, const at::Tensor & out);
+};
+TORCH_API at::Tensor bitwise_or(const at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor & bitwise_or_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+TORCH_API at::Tensor & bitwise_or_(at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor bitwise_or(const at::Scalar & self, const at::Tensor & other);
+TORCH_API at::Tensor & bitwise_or_Scalar_Tensor_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/complex_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor complex(const at::Tensor & real, const at::Tensor & imag);
+TORCH_API at::Tensor & complex_out(const at::Tensor & real, const at::Tensor & imag, at::Tensor & out);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/concatenate_native.h

@@ -0,0 +1,24 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor concatenate(at::TensorList tensors, int64_t dim=0);
+TORCH_API at::Tensor & concatenate_out(at::TensorList tensors, int64_t dim, at::Tensor & out);
+TORCH_API at::Tensor concatenate(at::TensorList tensors, at::Dimname dim);
+TORCH_API at::Tensor & concatenate_out(at::TensorList tensors, at::Dimname dim, at::Tensor & out);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_convolution_transpose.h

@@ -0,0 +1,91 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/cudnn_convolution_transpose_ops.h>
+
+namespace at {
+
+
+// aten::cudnn_convolution_transpose(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
+inline at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32);
+  }
+}
+
+// aten::cudnn_convolution_transpose(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor
+inline at::Tensor cudnn_convolution_transpose_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor cudnn_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32);
+  }
+}
+
+// aten::cudnn_convolution_transpose.out(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & cudnn_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & cudnn_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
+  }
+}
+
+// aten::cudnn_convolution_transpose.out(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & cudnn_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & cudnn_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
+  }
+}
+
+// aten::cudnn_convolution_transpose.out(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & cudnn_convolution_transpose_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & cudnn_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
+  }
+}
+
+// aten::cudnn_convolution_transpose.out(Tensor self, Tensor weight, SymInt[] padding, SymInt[] output_padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & cudnn_convolution_transpose_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & cudnn_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
+    return at::_ops::cudnn_convolution_transpose_out::call(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
+  }
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/eq_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor eq(const at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor & eq_(at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor eq(const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & eq_(at::Tensor & self, const at::Tensor & other);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/exp_cuda_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor exp(const at::Tensor & self);
+TORCH_API at::Tensor & exp_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & exp_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & exp_(at::Tensor & self);
+
+} // namespace cuda
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/fill_ops.h

@@ -0,0 +1,83 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API fill_Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill.Scalar(Tensor self, Scalar value) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & value);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & value);
+};
+
+struct TORCH_API fill_Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill.Tensor(Tensor self, Tensor value) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & value);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & value);
+};
+
+struct TORCH_API fill__Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill_.Scalar(Tensor(a!) self, Scalar value) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & value);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & value);
+};
+
+struct TORCH_API fill__Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill_.Tensor(Tensor(a!) self, Tensor value) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & value);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & value);
+};
+
+struct TORCH_API fill_Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill.Scalar_out(Tensor self, Scalar value, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & value, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & value, at::Tensor & out);
+};
+
+struct TORCH_API fill_Tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fill")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fill.Tensor_out(Tensor self, Tensor value, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & value, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & value, at::Tensor & out);
+};
+
+}} // namespace at::_ops

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/flatten_dense_tensors_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor flatten_dense_tensors(at::TensorList tensors);
+
+} // namespace compositeimplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/from_file_cpu_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor from_file(c10::string_view filename, ::std::optional<bool> shared=::std::nullopt, ::std::optional<int64_t> size=0, at::TensorOptions options={});
+TORCH_API at::Tensor from_file(c10::string_view filename, ::std::optional<bool> shared, ::std::optional<int64_t> size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory);
+
+} // namespace cpu
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/glu.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/glu_ops.h>
+
+namespace at {
+
+
+// aten::glu.out(Tensor self, int dim=-1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & glu_out(at::Tensor & out, const at::Tensor & self, int64_t dim=-1) {
+    return at::_ops::glu_out::call(self, dim, out);
+}
+// aten::glu.out(Tensor self, int dim=-1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & glu_outf(const at::Tensor & self, int64_t dim, at::Tensor & out) {
+    return at::_ops::glu_out::call(self, dim, out);
+}
+
+// aten::glu(Tensor self, int dim=-1) -> Tensor
+inline at::Tensor glu(const at::Tensor & self, int64_t dim=-1) {
+    return at::_ops::glu::call(self, dim);
+}
+
+}

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/infinitely_differentiable_gelu_backward_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor infinitely_differentiable_gelu_backward(const at::Tensor & grad, const at::Tensor & self);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/is_nonzero_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API bool is_nonzero(const at::Tensor & self);
+} // namespace native
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/isneginf_meta_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace meta {
+
+TORCH_API at::Tensor isneginf(const at::Tensor & self);
+TORCH_API at::Tensor & isneginf_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & isneginf_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace meta
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_cross_cuda_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor linalg_cross(const at::Tensor & self, const at::Tensor & other, int64_t dim=-1);
+TORCH_API at::Tensor & linalg_cross_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, int64_t dim=-1);
+TORCH_API at::Tensor & linalg_cross_outf(const at::Tensor & self, const at::Tensor & other, int64_t dim, at::Tensor & out);
+
+} // namespace cuda
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_householder_product_cpu_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor linalg_householder_product(const at::Tensor & input, const at::Tensor & tau);
+TORCH_API at::Tensor & linalg_householder_product_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & tau);
+TORCH_API at::Tensor & linalg_householder_product_outf(const at::Tensor & input, const at::Tensor & tau, at::Tensor & out);
+
+} // namespace cpu
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_lstsq_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> linalg_lstsq(const at::Tensor & self, const at::Tensor & b, ::std::optional<double> rcond=::std::nullopt, ::std::optional<c10::string_view> driver=::std::nullopt);
+
+} // namespace compositeexplicitautograd
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_lu_cpu_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor> linalg_lu(const at::Tensor & A, bool pivot=true);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linalg_lu_out(at::Tensor & P, at::Tensor & L, at::Tensor & U, const at::Tensor & A, bool pivot=true);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linalg_lu_outf(const at::Tensor & A, bool pivot, at::Tensor & P, at::Tensor & L, at::Tensor & U);
+
+} // namespace cpu
+} // namespace at

pllava/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_solve_triangular_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API linalg_solve_triangular_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_solve_triangular")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_solve_triangular.out(Tensor self, Tensor B, *, bool upper, bool left=True, bool unitriangular=False, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & B, bool upper, bool left, bool unitriangular, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & B, bool upper, bool left, bool unitriangular, at::Tensor & out);
+};
+
+struct TORCH_API linalg_solve_triangular {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_solve_triangular")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_solve_triangular(Tensor self, Tensor B, *, bool upper, bool left=True, bool unitriangular=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & B, bool upper, bool left, bool unitriangular);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & B, bool upper, bool left, bool unitriangular);
+};
+
+}} // namespace at::_ops