diff --git a/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg.pt b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg.pt new file mode 100644 index 0000000000000000000000000000000000000000..f2506e45d875e6caa3b99833d0d6be2a6e57907f --- /dev/null +++ b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd020cdba0aff64a2ab3594d2f02763129a007684b091faed3a088b8bb3cc512 +size 9372 diff --git a/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg_sq.pt b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg_sq.pt new file mode 100644 index 0000000000000000000000000000000000000000..ddfd33c4fd23298561751af1d429ac66a63177c9 --- /dev/null +++ b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/exp_avg_sq.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0bc23d848c48fdc034293d76e4208207949b26de202fb8479afa8aab3f24428 +size 9387 diff --git a/ckpts/universal/global_step40/zero/10.input_layernorm.weight/fp32.pt b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/fp32.pt new file mode 100644 index 0000000000000000000000000000000000000000..10513153ba5fa89e717f7f045d1ad3a742dbd6b8 --- /dev/null +++ b/ckpts/universal/global_step40/zero/10.input_layernorm.weight/fp32.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4a9c33b9930618976f39e7edf08775a631ad6a1222ff04e5ccfb880f3c76d7c +size 9293 diff --git a/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt new file mode 100644 index 0000000000000000000000000000000000000000..0998b69aff30911d45a591a2ec4498b2b5d2bc5a --- /dev/null +++ b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d61a43e101f8e63358ac76813ed5213ac8e6399e93cc664c05612bd60d4f1f8 +size 33555612 diff --git a/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt new file mode 100644 index 0000000000000000000000000000000000000000..e4104dd49ab32df8d5d0ad47d87ece0a8777ac83 --- /dev/null +++ b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0cff1249cbc12e3f523940b2b9419fecf310ebe3f6fa37b0caefa1f6b77280f7 +size 33555627 diff --git a/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/fp32.pt b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/fp32.pt new file mode 100644 index 0000000000000000000000000000000000000000..0a49f4f555c39f69da3d95b4693e3789150245b2 --- /dev/null +++ b/ckpts/universal/global_step40/zero/16.mlp.dense_h_to_4h_swiglu.weight/fp32.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a040fd8170ddbe4c33dba439cf75bbf764ed6a76f7531062dc0ab77b7485656 +size 33555533 diff --git a/ckpts/universal/global_step40/zero/18.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt b/ckpts/universal/global_step40/zero/18.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt new file mode 100644 index 0000000000000000000000000000000000000000..82f2d8b5652cd54a81496d75c28a15a45e8ea951 --- /dev/null +++ b/ckpts/universal/global_step40/zero/18.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a718064fe35999845107350bfdfe50385bb2709221a33378a657315479dfad9b +size 33555612 diff --git a/ckpts/universal/global_step40/zero/8.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt b/ckpts/universal/global_step40/zero/8.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt new file mode 100644 index 0000000000000000000000000000000000000000..e4a1fc4a07cf52d08a4b0982b08af0fb74566825 --- /dev/null +++ b/ckpts/universal/global_step40/zero/8.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53611bb07b98fc18be95fe0a04287e88363a16dc0552e2edb01f61803c8faeba +size 33555612 diff --git a/venv/lib/python3.10/site-packages/aiohttp/_helpers.pyi b/venv/lib/python3.10/site-packages/aiohttp/_helpers.pyi new file mode 100644 index 0000000000000000000000000000000000000000..1e358937024ac1b9d19cf714fc12087688c6fb95 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/_helpers.pyi @@ -0,0 +1,6 @@ +from typing import Any + +class reify: + def __init__(self, wrapped: Any) -> None: ... + def __get__(self, inst: Any, owner: Any) -> Any: ... + def __set__(self, inst: Any, value: Any) -> None: ... diff --git a/venv/lib/python3.10/site-packages/aiohttp/compression_utils.py b/venv/lib/python3.10/site-packages/aiohttp/compression_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9631d377e9a52b07c3d239fa140f328cea7172bd --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/compression_utils.py @@ -0,0 +1,157 @@ +import asyncio +import zlib +from concurrent.futures import Executor +from typing import Optional, cast + +try: + try: + import brotlicffi as brotli + except ImportError: + import brotli + + HAS_BROTLI = True +except ImportError: # pragma: no cover + HAS_BROTLI = False + +MAX_SYNC_CHUNK_SIZE = 1024 + + +def encoding_to_mode( + encoding: Optional[str] = None, + suppress_deflate_header: bool = False, +) -> int: + if encoding == "gzip": + return 16 + zlib.MAX_WBITS + + return -zlib.MAX_WBITS if suppress_deflate_header else zlib.MAX_WBITS + + +class ZlibBaseHandler: + def __init__( + self, + mode: int, + executor: Optional[Executor] = None, + max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE, + ): + self._mode = mode + self._executor = executor + self._max_sync_chunk_size = max_sync_chunk_size + + +class ZLibCompressor(ZlibBaseHandler): + def __init__( + self, + encoding: Optional[str] = None, + suppress_deflate_header: bool = False, + level: Optional[int] = None, + wbits: Optional[int] = None, + strategy: int = zlib.Z_DEFAULT_STRATEGY, + executor: Optional[Executor] = None, + max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE, + ): + super().__init__( + mode=encoding_to_mode(encoding, suppress_deflate_header) + if wbits is None + else wbits, + executor=executor, + max_sync_chunk_size=max_sync_chunk_size, + ) + if level is None: + self._compressor = zlib.compressobj(wbits=self._mode, strategy=strategy) + else: + self._compressor = zlib.compressobj( + wbits=self._mode, strategy=strategy, level=level + ) + self._compress_lock = asyncio.Lock() + + def compress_sync(self, data: bytes) -> bytes: + return self._compressor.compress(data) + + async def compress(self, data: bytes) -> bytes: + async with self._compress_lock: + # To ensure the stream is consistent in the event + # there are multiple writers, we need to lock + # the compressor so that only one writer can + # compress at a time. + if ( + self._max_sync_chunk_size is not None + and len(data) > self._max_sync_chunk_size + ): + return await asyncio.get_event_loop().run_in_executor( + self._executor, self.compress_sync, data + ) + return self.compress_sync(data) + + def flush(self, mode: int = zlib.Z_FINISH) -> bytes: + return self._compressor.flush(mode) + + +class ZLibDecompressor(ZlibBaseHandler): + def __init__( + self, + encoding: Optional[str] = None, + suppress_deflate_header: bool = False, + executor: Optional[Executor] = None, + max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE, + ): + super().__init__( + mode=encoding_to_mode(encoding, suppress_deflate_header), + executor=executor, + max_sync_chunk_size=max_sync_chunk_size, + ) + self._decompressor = zlib.decompressobj(wbits=self._mode) + + def decompress_sync(self, data: bytes, max_length: int = 0) -> bytes: + return self._decompressor.decompress(data, max_length) + + async def decompress(self, data: bytes, max_length: int = 0) -> bytes: + if ( + self._max_sync_chunk_size is not None + and len(data) > self._max_sync_chunk_size + ): + return await asyncio.get_event_loop().run_in_executor( + self._executor, self.decompress_sync, data, max_length + ) + return self.decompress_sync(data, max_length) + + def flush(self, length: int = 0) -> bytes: + return ( + self._decompressor.flush(length) + if length > 0 + else self._decompressor.flush() + ) + + @property + def eof(self) -> bool: + return self._decompressor.eof + + @property + def unconsumed_tail(self) -> bytes: + return self._decompressor.unconsumed_tail + + @property + def unused_data(self) -> bytes: + return self._decompressor.unused_data + + +class BrotliDecompressor: + # Supports both 'brotlipy' and 'Brotli' packages + # since they share an import name. The top branches + # are for 'brotlipy' and bottom branches for 'Brotli' + def __init__(self) -> None: + if not HAS_BROTLI: + raise RuntimeError( + "The brotli decompression is not available. " + "Please install `Brotli` module" + ) + self._obj = brotli.Decompressor() + + def decompress_sync(self, data: bytes) -> bytes: + if hasattr(self._obj, "decompress"): + return cast(bytes, self._obj.decompress(data)) + return cast(bytes, self._obj.process(data)) + + def flush(self) -> bytes: + if hasattr(self._obj, "flush"): + return cast(bytes, self._obj.flush()) + return b"" diff --git a/venv/lib/python3.10/site-packages/aiohttp/connector.py b/venv/lib/python3.10/site-packages/aiohttp/connector.py new file mode 100644 index 0000000000000000000000000000000000000000..f95ebe84c66c34bd78042b6fcea42bfb28b35d53 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/connector.py @@ -0,0 +1,1511 @@ +import asyncio +import functools +import random +import sys +import traceback +import warnings +from collections import defaultdict, deque +from contextlib import suppress +from http import HTTPStatus +from http.cookies import SimpleCookie +from itertools import cycle, islice +from time import monotonic +from types import TracebackType +from typing import ( + TYPE_CHECKING, + Any, + Awaitable, + Callable, + DefaultDict, + Dict, + Iterator, + List, + Literal, + Optional, + Set, + Tuple, + Type, + Union, + cast, +) + +import attr + +from . import hdrs, helpers +from .abc import AbstractResolver +from .client_exceptions import ( + ClientConnectionError, + ClientConnectorCertificateError, + ClientConnectorError, + ClientConnectorSSLError, + ClientHttpProxyError, + ClientProxyConnectionError, + ServerFingerprintMismatch, + UnixClientConnectorError, + cert_errors, + ssl_errors, +) +from .client_proto import ResponseHandler +from .client_reqrep import ClientRequest, Fingerprint, _merge_ssl_params +from .helpers import ceil_timeout, get_running_loop, is_ip_address, noop, sentinel +from .locks import EventResultOrError +from .resolver import DefaultResolver + +try: + import ssl + + SSLContext = ssl.SSLContext +except ImportError: # pragma: no cover + ssl = None # type: ignore[assignment] + SSLContext = object # type: ignore[misc,assignment] + + +__all__ = ("BaseConnector", "TCPConnector", "UnixConnector", "NamedPipeConnector") + + +if TYPE_CHECKING: + from .client import ClientTimeout + from .client_reqrep import ConnectionKey + from .tracing import Trace + + +class _DeprecationWaiter: + __slots__ = ("_awaitable", "_awaited") + + def __init__(self, awaitable: Awaitable[Any]) -> None: + self._awaitable = awaitable + self._awaited = False + + def __await__(self) -> Any: + self._awaited = True + return self._awaitable.__await__() + + def __del__(self) -> None: + if not self._awaited: + warnings.warn( + "Connector.close() is a coroutine, " + "please use await connector.close()", + DeprecationWarning, + ) + + +class Connection: + + _source_traceback = None + _transport = None + + def __init__( + self, + connector: "BaseConnector", + key: "ConnectionKey", + protocol: ResponseHandler, + loop: asyncio.AbstractEventLoop, + ) -> None: + self._key = key + self._connector = connector + self._loop = loop + self._protocol: Optional[ResponseHandler] = protocol + self._callbacks: List[Callable[[], None]] = [] + + if loop.get_debug(): + self._source_traceback = traceback.extract_stack(sys._getframe(1)) + + def __repr__(self) -> str: + return f"Connection<{self._key}>" + + def __del__(self, _warnings: Any = warnings) -> None: + if self._protocol is not None: + kwargs = {"source": self} + _warnings.warn(f"Unclosed connection {self!r}", ResourceWarning, **kwargs) + if self._loop.is_closed(): + return + + self._connector._release(self._key, self._protocol, should_close=True) + + context = {"client_connection": self, "message": "Unclosed connection"} + if self._source_traceback is not None: + context["source_traceback"] = self._source_traceback + self._loop.call_exception_handler(context) + + def __bool__(self) -> Literal[True]: + """Force subclasses to not be falsy, to make checks simpler.""" + return True + + @property + def loop(self) -> asyncio.AbstractEventLoop: + warnings.warn( + "connector.loop property is deprecated", DeprecationWarning, stacklevel=2 + ) + return self._loop + + @property + def transport(self) -> Optional[asyncio.Transport]: + if self._protocol is None: + return None + return self._protocol.transport + + @property + def protocol(self) -> Optional[ResponseHandler]: + return self._protocol + + def add_callback(self, callback: Callable[[], None]) -> None: + if callback is not None: + self._callbacks.append(callback) + + def _notify_release(self) -> None: + callbacks, self._callbacks = self._callbacks[:], [] + + for cb in callbacks: + with suppress(Exception): + cb() + + def close(self) -> None: + self._notify_release() + + if self._protocol is not None: + self._connector._release(self._key, self._protocol, should_close=True) + self._protocol = None + + def release(self) -> None: + self._notify_release() + + if self._protocol is not None: + self._connector._release( + self._key, self._protocol, should_close=self._protocol.should_close + ) + self._protocol = None + + @property + def closed(self) -> bool: + return self._protocol is None or not self._protocol.is_connected() + + +class _TransportPlaceholder: + """placeholder for BaseConnector.connect function""" + + def close(self) -> None: + pass + + +class BaseConnector: + """Base connector class. + + keepalive_timeout - (optional) Keep-alive timeout. + force_close - Set to True to force close and do reconnect + after each request (and between redirects). + limit - The total number of simultaneous connections. + limit_per_host - Number of simultaneous connections to one host. + enable_cleanup_closed - Enables clean-up closed ssl transports. + Disabled by default. + timeout_ceil_threshold - Trigger ceiling of timeout values when + it's above timeout_ceil_threshold. + loop - Optional event loop. + """ + + _closed = True # prevent AttributeError in __del__ if ctor was failed + _source_traceback = None + + # abort transport after 2 seconds (cleanup broken connections) + _cleanup_closed_period = 2.0 + + def __init__( + self, + *, + keepalive_timeout: Union[object, None, float] = sentinel, + force_close: bool = False, + limit: int = 100, + limit_per_host: int = 0, + enable_cleanup_closed: bool = False, + loop: Optional[asyncio.AbstractEventLoop] = None, + timeout_ceil_threshold: float = 5, + ) -> None: + + if force_close: + if keepalive_timeout is not None and keepalive_timeout is not sentinel: + raise ValueError( + "keepalive_timeout cannot " "be set if force_close is True" + ) + else: + if keepalive_timeout is sentinel: + keepalive_timeout = 15.0 + + loop = get_running_loop(loop) + self._timeout_ceil_threshold = timeout_ceil_threshold + + self._closed = False + if loop.get_debug(): + self._source_traceback = traceback.extract_stack(sys._getframe(1)) + + self._conns: Dict[ConnectionKey, List[Tuple[ResponseHandler, float]]] = {} + self._limit = limit + self._limit_per_host = limit_per_host + self._acquired: Set[ResponseHandler] = set() + self._acquired_per_host: DefaultDict[ + ConnectionKey, Set[ResponseHandler] + ] = defaultdict(set) + self._keepalive_timeout = cast(float, keepalive_timeout) + self._force_close = force_close + + # {host_key: FIFO list of waiters} + self._waiters = defaultdict(deque) # type: ignore[var-annotated] + + self._loop = loop + self._factory = functools.partial(ResponseHandler, loop=loop) + + self.cookies = SimpleCookie() + + # start keep-alive connection cleanup task + self._cleanup_handle: Optional[asyncio.TimerHandle] = None + + # start cleanup closed transports task + self._cleanup_closed_handle: Optional[asyncio.TimerHandle] = None + self._cleanup_closed_disabled = not enable_cleanup_closed + self._cleanup_closed_transports: List[Optional[asyncio.Transport]] = [] + self._cleanup_closed() + + def __del__(self, _warnings: Any = warnings) -> None: + if self._closed: + return + if not self._conns: + return + + conns = [repr(c) for c in self._conns.values()] + + self._close() + + kwargs = {"source": self} + _warnings.warn(f"Unclosed connector {self!r}", ResourceWarning, **kwargs) + context = { + "connector": self, + "connections": conns, + "message": "Unclosed connector", + } + if self._source_traceback is not None: + context["source_traceback"] = self._source_traceback + self._loop.call_exception_handler(context) + + def __enter__(self) -> "BaseConnector": + warnings.warn( + '"with Connector():" is deprecated, ' + 'use "async with Connector():" instead', + DeprecationWarning, + ) + return self + + def __exit__(self, *exc: Any) -> None: + self._close() + + async def __aenter__(self) -> "BaseConnector": + return self + + async def __aexit__( + self, + exc_type: Optional[Type[BaseException]] = None, + exc_value: Optional[BaseException] = None, + exc_traceback: Optional[TracebackType] = None, + ) -> None: + await self.close() + + @property + def force_close(self) -> bool: + """Ultimately close connection on releasing if True.""" + return self._force_close + + @property + def limit(self) -> int: + """The total number for simultaneous connections. + + If limit is 0 the connector has no limit. + The default limit size is 100. + """ + return self._limit + + @property + def limit_per_host(self) -> int: + """The limit for simultaneous connections to the same endpoint. + + Endpoints are the same if they are have equal + (host, port, is_ssl) triple. + """ + return self._limit_per_host + + def _cleanup(self) -> None: + """Cleanup unused transports.""" + if self._cleanup_handle: + self._cleanup_handle.cancel() + # _cleanup_handle should be unset, otherwise _release() will not + # recreate it ever! + self._cleanup_handle = None + + now = self._loop.time() + timeout = self._keepalive_timeout + + if self._conns: + connections = {} + deadline = now - timeout + for key, conns in self._conns.items(): + alive = [] + for proto, use_time in conns: + if proto.is_connected(): + if use_time - deadline < 0: + transport = proto.transport + proto.close() + if key.is_ssl and not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transport) + else: + alive.append((proto, use_time)) + else: + transport = proto.transport + proto.close() + if key.is_ssl and not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transport) + + if alive: + connections[key] = alive + + self._conns = connections + + if self._conns: + self._cleanup_handle = helpers.weakref_handle( + self, + "_cleanup", + timeout, + self._loop, + timeout_ceil_threshold=self._timeout_ceil_threshold, + ) + + def _drop_acquired_per_host( + self, key: "ConnectionKey", val: ResponseHandler + ) -> None: + acquired_per_host = self._acquired_per_host + if key not in acquired_per_host: + return + conns = acquired_per_host[key] + conns.remove(val) + if not conns: + del self._acquired_per_host[key] + + def _cleanup_closed(self) -> None: + """Double confirmation for transport close. + + Some broken ssl servers may leave socket open without proper close. + """ + if self._cleanup_closed_handle: + self._cleanup_closed_handle.cancel() + + for transport in self._cleanup_closed_transports: + if transport is not None: + transport.abort() + + self._cleanup_closed_transports = [] + + if not self._cleanup_closed_disabled: + self._cleanup_closed_handle = helpers.weakref_handle( + self, + "_cleanup_closed", + self._cleanup_closed_period, + self._loop, + timeout_ceil_threshold=self._timeout_ceil_threshold, + ) + + def close(self) -> Awaitable[None]: + """Close all opened transports.""" + self._close() + return _DeprecationWaiter(noop()) + + def _close(self) -> None: + if self._closed: + return + + self._closed = True + + try: + if self._loop.is_closed(): + return + + # cancel cleanup task + if self._cleanup_handle: + self._cleanup_handle.cancel() + + # cancel cleanup close task + if self._cleanup_closed_handle: + self._cleanup_closed_handle.cancel() + + for data in self._conns.values(): + for proto, t0 in data: + proto.close() + + for proto in self._acquired: + proto.close() + + for transport in self._cleanup_closed_transports: + if transport is not None: + transport.abort() + + finally: + self._conns.clear() + self._acquired.clear() + self._waiters.clear() + self._cleanup_handle = None + self._cleanup_closed_transports.clear() + self._cleanup_closed_handle = None + + @property + def closed(self) -> bool: + """Is connector closed. + + A readonly property. + """ + return self._closed + + def _available_connections(self, key: "ConnectionKey") -> int: + """ + Return number of available connections. + + The limit, limit_per_host and the connection key are taken into account. + + If it returns less than 1 means that there are no connections + available. + """ + if self._limit: + # total calc available connections + available = self._limit - len(self._acquired) + + # check limit per host + if ( + self._limit_per_host + and available > 0 + and key in self._acquired_per_host + ): + acquired = self._acquired_per_host.get(key) + assert acquired is not None + available = self._limit_per_host - len(acquired) + + elif self._limit_per_host and key in self._acquired_per_host: + # check limit per host + acquired = self._acquired_per_host.get(key) + assert acquired is not None + available = self._limit_per_host - len(acquired) + else: + available = 1 + + return available + + async def connect( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> Connection: + """Get from pool or create new connection.""" + key = req.connection_key + available = self._available_connections(key) + + # Wait if there are no available connections or if there are/were + # waiters (i.e. don't steal connection from a waiter about to wake up) + if available <= 0 or key in self._waiters: + fut = self._loop.create_future() + + # This connection will now count towards the limit. + self._waiters[key].append(fut) + + if traces: + for trace in traces: + await trace.send_connection_queued_start() + + try: + await fut + except BaseException as e: + if key in self._waiters: + # remove a waiter even if it was cancelled, normally it's + # removed when it's notified + try: + self._waiters[key].remove(fut) + except ValueError: # fut may no longer be in list + pass + + raise e + finally: + if key in self._waiters and not self._waiters[key]: + del self._waiters[key] + + if traces: + for trace in traces: + await trace.send_connection_queued_end() + + proto = self._get(key) + if proto is None: + placeholder = cast(ResponseHandler, _TransportPlaceholder()) + self._acquired.add(placeholder) + self._acquired_per_host[key].add(placeholder) + + if traces: + for trace in traces: + await trace.send_connection_create_start() + + try: + proto = await self._create_connection(req, traces, timeout) + if self._closed: + proto.close() + raise ClientConnectionError("Connector is closed.") + except BaseException: + if not self._closed: + self._acquired.remove(placeholder) + self._drop_acquired_per_host(key, placeholder) + self._release_waiter() + raise + else: + if not self._closed: + self._acquired.remove(placeholder) + self._drop_acquired_per_host(key, placeholder) + + if traces: + for trace in traces: + await trace.send_connection_create_end() + else: + if traces: + # Acquire the connection to prevent race conditions with limits + placeholder = cast(ResponseHandler, _TransportPlaceholder()) + self._acquired.add(placeholder) + self._acquired_per_host[key].add(placeholder) + for trace in traces: + await trace.send_connection_reuseconn() + self._acquired.remove(placeholder) + self._drop_acquired_per_host(key, placeholder) + + self._acquired.add(proto) + self._acquired_per_host[key].add(proto) + return Connection(self, key, proto, self._loop) + + def _get(self, key: "ConnectionKey") -> Optional[ResponseHandler]: + try: + conns = self._conns[key] + except KeyError: + return None + + t1 = self._loop.time() + while conns: + proto, t0 = conns.pop() + if proto.is_connected(): + if t1 - t0 > self._keepalive_timeout: + transport = proto.transport + proto.close() + # only for SSL transports + if key.is_ssl and not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transport) + else: + if not conns: + # The very last connection was reclaimed: drop the key + del self._conns[key] + return proto + else: + transport = proto.transport + proto.close() + if key.is_ssl and not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transport) + + # No more connections: drop the key + del self._conns[key] + return None + + def _release_waiter(self) -> None: + """ + Iterates over all waiters until one to be released is found. + + The one to be released is not finished and + belongs to a host that has available connections. + """ + if not self._waiters: + return + + # Having the dict keys ordered this avoids to iterate + # at the same order at each call. + queues = list(self._waiters.keys()) + random.shuffle(queues) + + for key in queues: + if self._available_connections(key) < 1: + continue + + waiters = self._waiters[key] + while waiters: + waiter = waiters.popleft() + if not waiter.done(): + waiter.set_result(None) + return + + def _release_acquired(self, key: "ConnectionKey", proto: ResponseHandler) -> None: + if self._closed: + # acquired connection is already released on connector closing + return + + try: + self._acquired.remove(proto) + self._drop_acquired_per_host(key, proto) + except KeyError: # pragma: no cover + # this may be result of undetermenistic order of objects + # finalization due garbage collection. + pass + else: + self._release_waiter() + + def _release( + self, + key: "ConnectionKey", + protocol: ResponseHandler, + *, + should_close: bool = False, + ) -> None: + if self._closed: + # acquired connection is already released on connector closing + return + + self._release_acquired(key, protocol) + + if self._force_close: + should_close = True + + if should_close or protocol.should_close: + transport = protocol.transport + protocol.close() + + if key.is_ssl and not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transport) + else: + conns = self._conns.get(key) + if conns is None: + conns = self._conns[key] = [] + conns.append((protocol, self._loop.time())) + + if self._cleanup_handle is None: + self._cleanup_handle = helpers.weakref_handle( + self, + "_cleanup", + self._keepalive_timeout, + self._loop, + timeout_ceil_threshold=self._timeout_ceil_threshold, + ) + + async def _create_connection( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> ResponseHandler: + raise NotImplementedError() + + +class _DNSCacheTable: + def __init__(self, ttl: Optional[float] = None) -> None: + self._addrs_rr: Dict[Tuple[str, int], Tuple[Iterator[Dict[str, Any]], int]] = {} + self._timestamps: Dict[Tuple[str, int], float] = {} + self._ttl = ttl + + def __contains__(self, host: object) -> bool: + return host in self._addrs_rr + + def add(self, key: Tuple[str, int], addrs: List[Dict[str, Any]]) -> None: + self._addrs_rr[key] = (cycle(addrs), len(addrs)) + + if self._ttl is not None: + self._timestamps[key] = monotonic() + + def remove(self, key: Tuple[str, int]) -> None: + self._addrs_rr.pop(key, None) + + if self._ttl is not None: + self._timestamps.pop(key, None) + + def clear(self) -> None: + self._addrs_rr.clear() + self._timestamps.clear() + + def next_addrs(self, key: Tuple[str, int]) -> List[Dict[str, Any]]: + loop, length = self._addrs_rr[key] + addrs = list(islice(loop, length)) + # Consume one more element to shift internal state of `cycle` + next(loop) + return addrs + + def expired(self, key: Tuple[str, int]) -> bool: + if self._ttl is None: + return False + + return self._timestamps[key] + self._ttl < monotonic() + + +class TCPConnector(BaseConnector): + """TCP connector. + + verify_ssl - Set to True to check ssl certifications. + fingerprint - Pass the binary sha256 + digest of the expected certificate in DER format to verify + that the certificate the server presents matches. See also + https://en.wikipedia.org/wiki/Transport_Layer_Security#Certificate_pinning + resolver - Enable DNS lookups and use this + resolver + use_dns_cache - Use memory cache for DNS lookups. + ttl_dns_cache - Max seconds having cached a DNS entry, None forever. + family - socket address family + local_addr - local tuple of (host, port) to bind socket to + + keepalive_timeout - (optional) Keep-alive timeout. + force_close - Set to True to force close and do reconnect + after each request (and between redirects). + limit - The total number of simultaneous connections. + limit_per_host - Number of simultaneous connections to one host. + enable_cleanup_closed - Enables clean-up closed ssl transports. + Disabled by default. + loop - Optional event loop. + """ + + def __init__( + self, + *, + verify_ssl: bool = True, + fingerprint: Optional[bytes] = None, + use_dns_cache: bool = True, + ttl_dns_cache: Optional[int] = 10, + family: int = 0, + ssl_context: Optional[SSLContext] = None, + ssl: Union[bool, Fingerprint, SSLContext] = True, + local_addr: Optional[Tuple[str, int]] = None, + resolver: Optional[AbstractResolver] = None, + keepalive_timeout: Union[None, float, object] = sentinel, + force_close: bool = False, + limit: int = 100, + limit_per_host: int = 0, + enable_cleanup_closed: bool = False, + loop: Optional[asyncio.AbstractEventLoop] = None, + timeout_ceil_threshold: float = 5, + ): + super().__init__( + keepalive_timeout=keepalive_timeout, + force_close=force_close, + limit=limit, + limit_per_host=limit_per_host, + enable_cleanup_closed=enable_cleanup_closed, + loop=loop, + timeout_ceil_threshold=timeout_ceil_threshold, + ) + + self._ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint) + if resolver is None: + resolver = DefaultResolver(loop=self._loop) + self._resolver = resolver + + self._use_dns_cache = use_dns_cache + self._cached_hosts = _DNSCacheTable(ttl=ttl_dns_cache) + self._throttle_dns_events: Dict[Tuple[str, int], EventResultOrError] = {} + self._family = family + self._local_addr = local_addr + + def close(self) -> Awaitable[None]: + """Close all ongoing DNS calls.""" + for ev in self._throttle_dns_events.values(): + ev.cancel() + + return super().close() + + @property + def family(self) -> int: + """Socket family like AF_INET.""" + return self._family + + @property + def use_dns_cache(self) -> bool: + """True if local DNS caching is enabled.""" + return self._use_dns_cache + + def clear_dns_cache( + self, host: Optional[str] = None, port: Optional[int] = None + ) -> None: + """Remove specified host/port or clear all dns local cache.""" + if host is not None and port is not None: + self._cached_hosts.remove((host, port)) + elif host is not None or port is not None: + raise ValueError("either both host and port " "or none of them are allowed") + else: + self._cached_hosts.clear() + + async def _resolve_host( + self, host: str, port: int, traces: Optional[List["Trace"]] = None + ) -> List[Dict[str, Any]]: + """Resolve host and return list of addresses.""" + if is_ip_address(host): + return [ + { + "hostname": host, + "host": host, + "port": port, + "family": self._family, + "proto": 0, + "flags": 0, + } + ] + + if not self._use_dns_cache: + + if traces: + for trace in traces: + await trace.send_dns_resolvehost_start(host) + + res = await self._resolver.resolve(host, port, family=self._family) + + if traces: + for trace in traces: + await trace.send_dns_resolvehost_end(host) + + return res + + key = (host, port) + if key in self._cached_hosts and not self._cached_hosts.expired(key): + # get result early, before any await (#4014) + result = self._cached_hosts.next_addrs(key) + + if traces: + for trace in traces: + await trace.send_dns_cache_hit(host) + return result + + # + # If multiple connectors are resolving the same host, we wait + # for the first one to resolve and then use the result for all of them. + # We use a throttle event to ensure that we only resolve the host once + # and then use the result for all the waiters. + # + # In this case we need to create a task to ensure that we can shield + # the task from cancellation as cancelling this lookup should not cancel + # the underlying lookup or else the cancel event will get broadcast to + # all the waiters across all connections. + # + resolved_host_task = asyncio.create_task( + self._resolve_host_with_throttle(key, host, port, traces) + ) + try: + return await asyncio.shield(resolved_host_task) + except asyncio.CancelledError: + + def drop_exception(fut: "asyncio.Future[List[Dict[str, Any]]]") -> None: + with suppress(Exception, asyncio.CancelledError): + fut.result() + + resolved_host_task.add_done_callback(drop_exception) + raise + + async def _resolve_host_with_throttle( + self, + key: Tuple[str, int], + host: str, + port: int, + traces: Optional[List["Trace"]], + ) -> List[Dict[str, Any]]: + """Resolve host with a dns events throttle.""" + if key in self._throttle_dns_events: + # get event early, before any await (#4014) + event = self._throttle_dns_events[key] + if traces: + for trace in traces: + await trace.send_dns_cache_hit(host) + await event.wait() + else: + # update dict early, before any await (#4014) + self._throttle_dns_events[key] = EventResultOrError(self._loop) + if traces: + for trace in traces: + await trace.send_dns_cache_miss(host) + try: + + if traces: + for trace in traces: + await trace.send_dns_resolvehost_start(host) + + addrs = await self._resolver.resolve(host, port, family=self._family) + if traces: + for trace in traces: + await trace.send_dns_resolvehost_end(host) + + self._cached_hosts.add(key, addrs) + self._throttle_dns_events[key].set() + except BaseException as e: + # any DNS exception, independently of the implementation + # is set for the waiters to raise the same exception. + self._throttle_dns_events[key].set(exc=e) + raise + finally: + self._throttle_dns_events.pop(key) + + return self._cached_hosts.next_addrs(key) + + async def _create_connection( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> ResponseHandler: + """Create connection. + + Has same keyword arguments as BaseEventLoop.create_connection. + """ + if req.proxy: + _, proto = await self._create_proxy_connection(req, traces, timeout) + else: + _, proto = await self._create_direct_connection(req, traces, timeout) + + return proto + + @staticmethod + @functools.lru_cache(None) + def _make_ssl_context(verified: bool) -> SSLContext: + if verified: + return ssl.create_default_context() + else: + sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) + sslcontext.options |= ssl.OP_NO_SSLv2 + sslcontext.options |= ssl.OP_NO_SSLv3 + sslcontext.check_hostname = False + sslcontext.verify_mode = ssl.CERT_NONE + try: + sslcontext.options |= ssl.OP_NO_COMPRESSION + except AttributeError as attr_err: + warnings.warn( + "{!s}: The Python interpreter is compiled " + "against OpenSSL < 1.0.0. Ref: " + "https://docs.python.org/3/library/ssl.html" + "#ssl.OP_NO_COMPRESSION".format(attr_err), + ) + sslcontext.set_default_verify_paths() + return sslcontext + + def _get_ssl_context(self, req: ClientRequest) -> Optional[SSLContext]: + """Logic to get the correct SSL context + + 0. if req.ssl is false, return None + + 1. if ssl_context is specified in req, use it + 2. if _ssl_context is specified in self, use it + 3. otherwise: + 1. if verify_ssl is not specified in req, use self.ssl_context + (will generate a default context according to self.verify_ssl) + 2. if verify_ssl is True in req, generate a default SSL context + 3. if verify_ssl is False in req, generate a SSL context that + won't verify + """ + if req.is_ssl(): + if ssl is None: # pragma: no cover + raise RuntimeError("SSL is not supported.") + sslcontext = req.ssl + if isinstance(sslcontext, ssl.SSLContext): + return sslcontext + if sslcontext is not True: + # not verified or fingerprinted + return self._make_ssl_context(False) + sslcontext = self._ssl + if isinstance(sslcontext, ssl.SSLContext): + return sslcontext + if sslcontext is not True: + # not verified or fingerprinted + return self._make_ssl_context(False) + return self._make_ssl_context(True) + else: + return None + + def _get_fingerprint(self, req: ClientRequest) -> Optional["Fingerprint"]: + ret = req.ssl + if isinstance(ret, Fingerprint): + return ret + ret = self._ssl + if isinstance(ret, Fingerprint): + return ret + return None + + async def _wrap_create_connection( + self, + *args: Any, + req: ClientRequest, + timeout: "ClientTimeout", + client_error: Type[Exception] = ClientConnectorError, + **kwargs: Any, + ) -> Tuple[asyncio.Transport, ResponseHandler]: + try: + async with ceil_timeout( + timeout.sock_connect, ceil_threshold=timeout.ceil_threshold + ): + return await self._loop.create_connection(*args, **kwargs) + except cert_errors as exc: + raise ClientConnectorCertificateError(req.connection_key, exc) from exc + except ssl_errors as exc: + raise ClientConnectorSSLError(req.connection_key, exc) from exc + except OSError as exc: + if exc.errno is None and isinstance(exc, asyncio.TimeoutError): + raise + raise client_error(req.connection_key, exc) from exc + + def _fail_on_no_start_tls(self, req: "ClientRequest") -> None: + """Raise a :py:exc:`RuntimeError` on missing ``start_tls()``. + + It is necessary for TLS-in-TLS so that it is possible to + send HTTPS queries through HTTPS proxies. + + This doesn't affect regular HTTP requests, though. + """ + if not req.is_ssl(): + return + + proxy_url = req.proxy + assert proxy_url is not None + if proxy_url.scheme != "https": + return + + self._check_loop_for_start_tls() + + def _check_loop_for_start_tls(self) -> None: + try: + self._loop.start_tls + except AttributeError as attr_exc: + raise RuntimeError( + "An HTTPS request is being sent through an HTTPS proxy. " + "This needs support for TLS in TLS but it is not implemented " + "in your runtime for the stdlib asyncio.\n\n" + "Please upgrade to Python 3.11 or higher. For more details, " + "please see:\n" + "* https://bugs.python.org/issue37179\n" + "* https://github.com/python/cpython/pull/28073\n" + "* https://docs.aiohttp.org/en/stable/" + "client_advanced.html#proxy-support\n" + "* https://github.com/aio-libs/aiohttp/discussions/6044\n", + ) from attr_exc + + def _loop_supports_start_tls(self) -> bool: + try: + self._check_loop_for_start_tls() + except RuntimeError: + return False + else: + return True + + def _warn_about_tls_in_tls( + self, + underlying_transport: asyncio.Transport, + req: ClientRequest, + ) -> None: + """Issue a warning if the requested URL has HTTPS scheme.""" + if req.request_info.url.scheme != "https": + return + + asyncio_supports_tls_in_tls = getattr( + underlying_transport, + "_start_tls_compatible", + False, + ) + + if asyncio_supports_tls_in_tls: + return + + warnings.warn( + "An HTTPS request is being sent through an HTTPS proxy. " + "This support for TLS in TLS is known to be disabled " + "in the stdlib asyncio (Python <3.11). This is why you'll probably see " + "an error in the log below.\n\n" + "It is possible to enable it via monkeypatching. " + "For more details, see:\n" + "* https://bugs.python.org/issue37179\n" + "* https://github.com/python/cpython/pull/28073\n\n" + "You can temporarily patch this as follows:\n" + "* https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support\n" + "* https://github.com/aio-libs/aiohttp/discussions/6044\n", + RuntimeWarning, + source=self, + # Why `4`? At least 3 of the calls in the stack originate + # from the methods in this class. + stacklevel=3, + ) + + async def _start_tls_connection( + self, + underlying_transport: asyncio.Transport, + req: ClientRequest, + timeout: "ClientTimeout", + client_error: Type[Exception] = ClientConnectorError, + ) -> Tuple[asyncio.BaseTransport, ResponseHandler]: + """Wrap the raw TCP transport with TLS.""" + tls_proto = self._factory() # Create a brand new proto for TLS + + # Safety of the `cast()` call here is based on the fact that + # internally `_get_ssl_context()` only returns `None` when + # `req.is_ssl()` evaluates to `False` which is never gonna happen + # in this code path. Of course, it's rather fragile + # maintainability-wise but this is to be solved separately. + sslcontext = cast(ssl.SSLContext, self._get_ssl_context(req)) + + try: + async with ceil_timeout( + timeout.sock_connect, ceil_threshold=timeout.ceil_threshold + ): + try: + tls_transport = await self._loop.start_tls( + underlying_transport, + tls_proto, + sslcontext, + server_hostname=req.server_hostname or req.host, + ssl_handshake_timeout=timeout.total, + ) + except BaseException: + # We need to close the underlying transport since + # `start_tls()` probably failed before it had a + # chance to do this: + underlying_transport.close() + raise + except cert_errors as exc: + raise ClientConnectorCertificateError(req.connection_key, exc) from exc + except ssl_errors as exc: + raise ClientConnectorSSLError(req.connection_key, exc) from exc + except OSError as exc: + if exc.errno is None and isinstance(exc, asyncio.TimeoutError): + raise + raise client_error(req.connection_key, exc) from exc + except TypeError as type_err: + # Example cause looks like this: + # TypeError: transport is not supported by start_tls() + + raise ClientConnectionError( + "Cannot initialize a TLS-in-TLS connection to host " + f"{req.host!s}:{req.port:d} through an underlying connection " + f"to an HTTPS proxy {req.proxy!s} ssl:{req.ssl or 'default'} " + f"[{type_err!s}]" + ) from type_err + else: + if tls_transport is None: + msg = "Failed to start TLS (possibly caused by closing transport)" + raise client_error(req.connection_key, OSError(msg)) + tls_proto.connection_made( + tls_transport + ) # Kick the state machine of the new TLS protocol + + return tls_transport, tls_proto + + async def _create_direct_connection( + self, + req: ClientRequest, + traces: List["Trace"], + timeout: "ClientTimeout", + *, + client_error: Type[Exception] = ClientConnectorError, + ) -> Tuple[asyncio.Transport, ResponseHandler]: + sslcontext = self._get_ssl_context(req) + fingerprint = self._get_fingerprint(req) + + host = req.url.raw_host + assert host is not None + # Replace multiple trailing dots with a single one. + # A trailing dot is only present for fully-qualified domain names. + # See https://github.com/aio-libs/aiohttp/pull/7364. + if host.endswith(".."): + host = host.rstrip(".") + "." + port = req.port + assert port is not None + try: + # Cancelling this lookup should not cancel the underlying lookup + # or else the cancel event will get broadcast to all the waiters + # across all connections. + hosts = await self._resolve_host(host, port, traces=traces) + except OSError as exc: + if exc.errno is None and isinstance(exc, asyncio.TimeoutError): + raise + # in case of proxy it is not ClientProxyConnectionError + # it is problem of resolving proxy ip itself + raise ClientConnectorError(req.connection_key, exc) from exc + + last_exc: Optional[Exception] = None + + for hinfo in hosts: + host = hinfo["host"] + port = hinfo["port"] + + # Strip trailing dots, certificates contain FQDN without dots. + # See https://github.com/aio-libs/aiohttp/issues/3636 + server_hostname = ( + (req.server_hostname or hinfo["hostname"]).rstrip(".") + if sslcontext + else None + ) + + try: + transp, proto = await self._wrap_create_connection( + self._factory, + host, + port, + timeout=timeout, + ssl=sslcontext, + family=hinfo["family"], + proto=hinfo["proto"], + flags=hinfo["flags"], + server_hostname=server_hostname, + local_addr=self._local_addr, + req=req, + client_error=client_error, + ) + except ClientConnectorError as exc: + last_exc = exc + continue + + if req.is_ssl() and fingerprint: + try: + fingerprint.check(transp) + except ServerFingerprintMismatch as exc: + transp.close() + if not self._cleanup_closed_disabled: + self._cleanup_closed_transports.append(transp) + last_exc = exc + continue + + return transp, proto + else: + assert last_exc is not None + raise last_exc + + async def _create_proxy_connection( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> Tuple[asyncio.BaseTransport, ResponseHandler]: + self._fail_on_no_start_tls(req) + runtime_has_start_tls = self._loop_supports_start_tls() + + headers: Dict[str, str] = {} + if req.proxy_headers is not None: + headers = req.proxy_headers # type: ignore[assignment] + headers[hdrs.HOST] = req.headers[hdrs.HOST] + + url = req.proxy + assert url is not None + proxy_req = ClientRequest( + hdrs.METH_GET, + url, + headers=headers, + auth=req.proxy_auth, + loop=self._loop, + ssl=req.ssl, + ) + + # create connection to proxy server + transport, proto = await self._create_direct_connection( + proxy_req, [], timeout, client_error=ClientProxyConnectionError + ) + + # Many HTTP proxies has buggy keepalive support. Let's not + # reuse connection but close it after processing every + # response. + proto.force_close() + + auth = proxy_req.headers.pop(hdrs.AUTHORIZATION, None) + if auth is not None: + if not req.is_ssl(): + req.headers[hdrs.PROXY_AUTHORIZATION] = auth + else: + proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth + + if req.is_ssl(): + if runtime_has_start_tls: + self._warn_about_tls_in_tls(transport, req) + + # For HTTPS requests over HTTP proxy + # we must notify proxy to tunnel connection + # so we send CONNECT command: + # CONNECT www.python.org:443 HTTP/1.1 + # Host: www.python.org + # + # next we must do TLS handshake and so on + # to do this we must wrap raw socket into secure one + # asyncio handles this perfectly + proxy_req.method = hdrs.METH_CONNECT + proxy_req.url = req.url + key = attr.evolve( + req.connection_key, proxy=None, proxy_auth=None, proxy_headers_hash=None + ) + conn = Connection(self, key, proto, self._loop) + proxy_resp = await proxy_req.send(conn) + try: + protocol = conn._protocol + assert protocol is not None + + # read_until_eof=True will ensure the connection isn't closed + # once the response is received and processed allowing + # START_TLS to work on the connection below. + protocol.set_response_params( + read_until_eof=runtime_has_start_tls, + timeout_ceil_threshold=self._timeout_ceil_threshold, + ) + resp = await proxy_resp.start(conn) + except BaseException: + proxy_resp.close() + conn.close() + raise + else: + conn._protocol = None + conn._transport = None + try: + if resp.status != 200: + message = resp.reason + if message is None: + message = HTTPStatus(resp.status).phrase + raise ClientHttpProxyError( + proxy_resp.request_info, + resp.history, + status=resp.status, + message=message, + headers=resp.headers, + ) + if not runtime_has_start_tls: + rawsock = transport.get_extra_info("socket", default=None) + if rawsock is None: + raise RuntimeError( + "Transport does not expose socket instance" + ) + # Duplicate the socket, so now we can close proxy transport + rawsock = rawsock.dup() + except BaseException: + # It shouldn't be closed in `finally` because it's fed to + # `loop.start_tls()` and the docs say not to touch it after + # passing there. + transport.close() + raise + finally: + if not runtime_has_start_tls: + transport.close() + + if not runtime_has_start_tls: + # HTTP proxy with support for upgrade to HTTPS + sslcontext = self._get_ssl_context(req) + return await self._wrap_create_connection( + self._factory, + timeout=timeout, + ssl=sslcontext, + sock=rawsock, + server_hostname=req.host, + req=req, + ) + + return await self._start_tls_connection( + # Access the old transport for the last time before it's + # closed and forgotten forever: + transport, + req=req, + timeout=timeout, + ) + finally: + proxy_resp.close() + + return transport, proto + + +class UnixConnector(BaseConnector): + """Unix socket connector. + + path - Unix socket path. + keepalive_timeout - (optional) Keep-alive timeout. + force_close - Set to True to force close and do reconnect + after each request (and between redirects). + limit - The total number of simultaneous connections. + limit_per_host - Number of simultaneous connections to one host. + loop - Optional event loop. + """ + + def __init__( + self, + path: str, + force_close: bool = False, + keepalive_timeout: Union[object, float, None] = sentinel, + limit: int = 100, + limit_per_host: int = 0, + loop: Optional[asyncio.AbstractEventLoop] = None, + ) -> None: + super().__init__( + force_close=force_close, + keepalive_timeout=keepalive_timeout, + limit=limit, + limit_per_host=limit_per_host, + loop=loop, + ) + self._path = path + + @property + def path(self) -> str: + """Path to unix socket.""" + return self._path + + async def _create_connection( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> ResponseHandler: + try: + async with ceil_timeout( + timeout.sock_connect, ceil_threshold=timeout.ceil_threshold + ): + _, proto = await self._loop.create_unix_connection( + self._factory, self._path + ) + except OSError as exc: + if exc.errno is None and isinstance(exc, asyncio.TimeoutError): + raise + raise UnixClientConnectorError(self.path, req.connection_key, exc) from exc + + return proto + + +class NamedPipeConnector(BaseConnector): + """Named pipe connector. + + Only supported by the proactor event loop. + See also: https://docs.python.org/3/library/asyncio-eventloop.html + + path - Windows named pipe path. + keepalive_timeout - (optional) Keep-alive timeout. + force_close - Set to True to force close and do reconnect + after each request (and between redirects). + limit - The total number of simultaneous connections. + limit_per_host - Number of simultaneous connections to one host. + loop - Optional event loop. + """ + + def __init__( + self, + path: str, + force_close: bool = False, + keepalive_timeout: Union[object, float, None] = sentinel, + limit: int = 100, + limit_per_host: int = 0, + loop: Optional[asyncio.AbstractEventLoop] = None, + ) -> None: + super().__init__( + force_close=force_close, + keepalive_timeout=keepalive_timeout, + limit=limit, + limit_per_host=limit_per_host, + loop=loop, + ) + if not isinstance( + self._loop, asyncio.ProactorEventLoop # type: ignore[attr-defined] + ): + raise RuntimeError( + "Named Pipes only available in proactor " "loop under windows" + ) + self._path = path + + @property + def path(self) -> str: + """Path to the named pipe.""" + return self._path + + async def _create_connection( + self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout" + ) -> ResponseHandler: + try: + async with ceil_timeout( + timeout.sock_connect, ceil_threshold=timeout.ceil_threshold + ): + _, proto = await self._loop.create_pipe_connection( # type: ignore[attr-defined] + self._factory, self._path + ) + # the drain is required so that the connection_made is called + # and transport is set otherwise it is not set before the + # `assert conn.transport is not None` + # in client.py's _request method + await asyncio.sleep(0) + # other option is to manually set transport like + # `proto.transport = trans` + except OSError as exc: + if exc.errno is None and isinstance(exc, asyncio.TimeoutError): + raise + raise ClientConnectorError(req.connection_key, exc) from exc + + return cast(ResponseHandler, proto) diff --git a/venv/lib/python3.10/site-packages/aiohttp/formdata.py b/venv/lib/python3.10/site-packages/aiohttp/formdata.py new file mode 100644 index 0000000000000000000000000000000000000000..2b75b3de72c218a7941e942cf28577c9f917276c --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/formdata.py @@ -0,0 +1,182 @@ +import io +import warnings +from typing import Any, Iterable, List, Optional +from urllib.parse import urlencode + +from multidict import MultiDict, MultiDictProxy + +from . import hdrs, multipart, payload +from .helpers import guess_filename +from .payload import Payload + +__all__ = ("FormData",) + + +class FormData: + """Helper class for form body generation. + + Supports multipart/form-data and application/x-www-form-urlencoded. + """ + + def __init__( + self, + fields: Iterable[Any] = (), + quote_fields: bool = True, + charset: Optional[str] = None, + ) -> None: + self._writer = multipart.MultipartWriter("form-data") + self._fields: List[Any] = [] + self._is_multipart = False + self._is_processed = False + self._quote_fields = quote_fields + self._charset = charset + + if isinstance(fields, dict): + fields = list(fields.items()) + elif not isinstance(fields, (list, tuple)): + fields = (fields,) + self.add_fields(*fields) + + @property + def is_multipart(self) -> bool: + return self._is_multipart + + def add_field( + self, + name: str, + value: Any, + *, + content_type: Optional[str] = None, + filename: Optional[str] = None, + content_transfer_encoding: Optional[str] = None, + ) -> None: + + if isinstance(value, io.IOBase): + self._is_multipart = True + elif isinstance(value, (bytes, bytearray, memoryview)): + msg = ( + "In v4, passing bytes will no longer create a file field. " + "Please explicitly use the filename parameter or pass a BytesIO object." + ) + if filename is None and content_transfer_encoding is None: + warnings.warn(msg, DeprecationWarning) + filename = name + + type_options: MultiDict[str] = MultiDict({"name": name}) + if filename is not None and not isinstance(filename, str): + raise TypeError( + "filename must be an instance of str. " "Got: %s" % filename + ) + if filename is None and isinstance(value, io.IOBase): + filename = guess_filename(value, name) + if filename is not None: + type_options["filename"] = filename + self._is_multipart = True + + headers = {} + if content_type is not None: + if not isinstance(content_type, str): + raise TypeError( + "content_type must be an instance of str. " "Got: %s" % content_type + ) + headers[hdrs.CONTENT_TYPE] = content_type + self._is_multipart = True + if content_transfer_encoding is not None: + if not isinstance(content_transfer_encoding, str): + raise TypeError( + "content_transfer_encoding must be an instance" + " of str. Got: %s" % content_transfer_encoding + ) + msg = ( + "content_transfer_encoding is deprecated. " + "To maintain compatibility with v4 please pass a BytesPayload." + ) + warnings.warn(msg, DeprecationWarning) + self._is_multipart = True + + self._fields.append((type_options, headers, value)) + + def add_fields(self, *fields: Any) -> None: + to_add = list(fields) + + while to_add: + rec = to_add.pop(0) + + if isinstance(rec, io.IOBase): + k = guess_filename(rec, "unknown") + self.add_field(k, rec) # type: ignore[arg-type] + + elif isinstance(rec, (MultiDictProxy, MultiDict)): + to_add.extend(rec.items()) + + elif isinstance(rec, (list, tuple)) and len(rec) == 2: + k, fp = rec + self.add_field(k, fp) # type: ignore[arg-type] + + else: + raise TypeError( + "Only io.IOBase, multidict and (name, file) " + "pairs allowed, use .add_field() for passing " + "more complex parameters, got {!r}".format(rec) + ) + + def _gen_form_urlencoded(self) -> payload.BytesPayload: + # form data (x-www-form-urlencoded) + data = [] + for type_options, _, value in self._fields: + data.append((type_options["name"], value)) + + charset = self._charset if self._charset is not None else "utf-8" + + if charset == "utf-8": + content_type = "application/x-www-form-urlencoded" + else: + content_type = "application/x-www-form-urlencoded; " "charset=%s" % charset + + return payload.BytesPayload( + urlencode(data, doseq=True, encoding=charset).encode(), + content_type=content_type, + ) + + def _gen_form_data(self) -> multipart.MultipartWriter: + """Encode a list of fields using the multipart/form-data MIME format""" + if self._is_processed: + raise RuntimeError("Form data has been processed already") + for dispparams, headers, value in self._fields: + try: + if hdrs.CONTENT_TYPE in headers: + part = payload.get_payload( + value, + content_type=headers[hdrs.CONTENT_TYPE], + headers=headers, + encoding=self._charset, + ) + else: + part = payload.get_payload( + value, headers=headers, encoding=self._charset + ) + except Exception as exc: + raise TypeError( + "Can not serialize value type: %r\n " + "headers: %r\n value: %r" % (type(value), headers, value) + ) from exc + + if dispparams: + part.set_content_disposition( + "form-data", quote_fields=self._quote_fields, **dispparams + ) + # FIXME cgi.FieldStorage doesn't likes body parts with + # Content-Length which were sent via chunked transfer encoding + assert part.headers is not None + part.headers.popall(hdrs.CONTENT_LENGTH, None) + + self._writer.append_payload(part) + + self._is_processed = True + return self._writer + + def __call__(self) -> Payload: + if self._is_multipart: + return self._gen_form_data() + else: + return self._gen_form_urlencoded() diff --git a/venv/lib/python3.10/site-packages/aiohttp/http_exceptions.py b/venv/lib/python3.10/site-packages/aiohttp/http_exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..72eac3a3cac41385c3b1435124ecbc68aba0fec6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/http_exceptions.py @@ -0,0 +1,106 @@ +"""Low-level http related exceptions.""" + + +from textwrap import indent +from typing import Optional, Union + +from .typedefs import _CIMultiDict + +__all__ = ("HttpProcessingError",) + + +class HttpProcessingError(Exception): + """HTTP error. + + Shortcut for raising HTTP errors with custom code, message and headers. + + code: HTTP Error code. + message: (optional) Error message. + headers: (optional) Headers to be sent in response, a list of pairs + """ + + code = 0 + message = "" + headers = None + + def __init__( + self, + *, + code: Optional[int] = None, + message: str = "", + headers: Optional[_CIMultiDict] = None, + ) -> None: + if code is not None: + self.code = code + self.headers = headers + self.message = message + + def __str__(self) -> str: + msg = indent(self.message, " ") + return f"{self.code}, message:\n{msg}" + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}: {self.code}, message={self.message!r}>" + + +class BadHttpMessage(HttpProcessingError): + + code = 400 + message = "Bad Request" + + def __init__(self, message: str, *, headers: Optional[_CIMultiDict] = None) -> None: + super().__init__(message=message, headers=headers) + self.args = (message,) + + +class HttpBadRequest(BadHttpMessage): + + code = 400 + message = "Bad Request" + + +class PayloadEncodingError(BadHttpMessage): + """Base class for payload errors""" + + +class ContentEncodingError(PayloadEncodingError): + """Content encoding error.""" + + +class TransferEncodingError(PayloadEncodingError): + """transfer encoding error.""" + + +class ContentLengthError(PayloadEncodingError): + """Not enough data for satisfy content length header.""" + + +class LineTooLong(BadHttpMessage): + def __init__( + self, line: str, limit: str = "Unknown", actual_size: str = "Unknown" + ) -> None: + super().__init__( + f"Got more than {limit} bytes ({actual_size}) when reading {line}." + ) + self.args = (line, limit, actual_size) + + +class InvalidHeader(BadHttpMessage): + def __init__(self, hdr: Union[bytes, str]) -> None: + hdr_s = hdr.decode(errors="backslashreplace") if isinstance(hdr, bytes) else hdr + super().__init__(f"Invalid HTTP header: {hdr!r}") + self.hdr = hdr_s + self.args = (hdr,) + + +class BadStatusLine(BadHttpMessage): + def __init__(self, line: str = "", error: Optional[str] = None) -> None: + if not isinstance(line, str): + line = repr(line) + super().__init__(error or f"Bad status line {line!r}") + self.args = (line,) + self.line = line + + +class InvalidURLError(BadHttpMessage): + pass diff --git a/venv/lib/python3.10/site-packages/aiohttp/payload.py b/venv/lib/python3.10/site-packages/aiohttp/payload.py new file mode 100644 index 0000000000000000000000000000000000000000..6593b05c6f7b835de1d5b0925f77306db183340e --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/payload.py @@ -0,0 +1,463 @@ +import asyncio +import enum +import io +import json +import mimetypes +import os +import warnings +from abc import ABC, abstractmethod +from itertools import chain +from typing import ( + IO, + TYPE_CHECKING, + Any, + ByteString, + Dict, + Final, + Iterable, + Optional, + TextIO, + Tuple, + Type, + Union, +) + +from multidict import CIMultiDict + +from . import hdrs +from .abc import AbstractStreamWriter +from .helpers import ( + _SENTINEL, + content_disposition_header, + guess_filename, + parse_mimetype, + sentinel, +) +from .streams import StreamReader +from .typedefs import JSONEncoder, _CIMultiDict + +__all__ = ( + "PAYLOAD_REGISTRY", + "get_payload", + "payload_type", + "Payload", + "BytesPayload", + "StringPayload", + "IOBasePayload", + "BytesIOPayload", + "BufferedReaderPayload", + "TextIOPayload", + "StringIOPayload", + "JsonPayload", + "AsyncIterablePayload", +) + +TOO_LARGE_BYTES_BODY: Final[int] = 2**20 # 1 MB + +if TYPE_CHECKING: + from typing import List + + +class LookupError(Exception): + pass + + +class Order(str, enum.Enum): + normal = "normal" + try_first = "try_first" + try_last = "try_last" + + +def get_payload(data: Any, *args: Any, **kwargs: Any) -> "Payload": + return PAYLOAD_REGISTRY.get(data, *args, **kwargs) + + +def register_payload( + factory: Type["Payload"], type: Any, *, order: Order = Order.normal +) -> None: + PAYLOAD_REGISTRY.register(factory, type, order=order) + + +class payload_type: + def __init__(self, type: Any, *, order: Order = Order.normal) -> None: + self.type = type + self.order = order + + def __call__(self, factory: Type["Payload"]) -> Type["Payload"]: + register_payload(factory, self.type, order=self.order) + return factory + + +PayloadType = Type["Payload"] +_PayloadRegistryItem = Tuple[PayloadType, Any] + + +class PayloadRegistry: + """Payload registry. + + note: we need zope.interface for more efficient adapter search + """ + + def __init__(self) -> None: + self._first: List[_PayloadRegistryItem] = [] + self._normal: List[_PayloadRegistryItem] = [] + self._last: List[_PayloadRegistryItem] = [] + + def get( + self, + data: Any, + *args: Any, + _CHAIN: "Type[chain[_PayloadRegistryItem]]" = chain, + **kwargs: Any, + ) -> "Payload": + if isinstance(data, Payload): + return data + for factory, type in _CHAIN(self._first, self._normal, self._last): + if isinstance(data, type): + return factory(data, *args, **kwargs) + + raise LookupError() + + def register( + self, factory: PayloadType, type: Any, *, order: Order = Order.normal + ) -> None: + if order is Order.try_first: + self._first.append((factory, type)) + elif order is Order.normal: + self._normal.append((factory, type)) + elif order is Order.try_last: + self._last.append((factory, type)) + else: + raise ValueError(f"Unsupported order {order!r}") + + +class Payload(ABC): + + _default_content_type: str = "application/octet-stream" + _size: Optional[int] = None + + def __init__( + self, + value: Any, + headers: Optional[ + Union[_CIMultiDict, Dict[str, str], Iterable[Tuple[str, str]]] + ] = None, + content_type: Union[str, None, _SENTINEL] = sentinel, + filename: Optional[str] = None, + encoding: Optional[str] = None, + **kwargs: Any, + ) -> None: + self._encoding = encoding + self._filename = filename + self._headers: _CIMultiDict = CIMultiDict() + self._value = value + if content_type is not sentinel and content_type is not None: + self._headers[hdrs.CONTENT_TYPE] = content_type + elif self._filename is not None: + content_type = mimetypes.guess_type(self._filename)[0] + if content_type is None: + content_type = self._default_content_type + self._headers[hdrs.CONTENT_TYPE] = content_type + else: + self._headers[hdrs.CONTENT_TYPE] = self._default_content_type + self._headers.update(headers or {}) + + @property + def size(self) -> Optional[int]: + """Size of the payload.""" + return self._size + + @property + def filename(self) -> Optional[str]: + """Filename of the payload.""" + return self._filename + + @property + def headers(self) -> _CIMultiDict: + """Custom item headers""" + return self._headers + + @property + def _binary_headers(self) -> bytes: + return ( + "".join([k + ": " + v + "\r\n" for k, v in self.headers.items()]).encode( + "utf-8" + ) + + b"\r\n" + ) + + @property + def encoding(self) -> Optional[str]: + """Payload encoding""" + return self._encoding + + @property + def content_type(self) -> str: + """Content type""" + return self._headers[hdrs.CONTENT_TYPE] + + def set_content_disposition( + self, + disptype: str, + quote_fields: bool = True, + _charset: str = "utf-8", + **params: Any, + ) -> None: + """Sets ``Content-Disposition`` header.""" + self._headers[hdrs.CONTENT_DISPOSITION] = content_disposition_header( + disptype, quote_fields=quote_fields, _charset=_charset, **params + ) + + @abstractmethod + async def write(self, writer: AbstractStreamWriter) -> None: + """Write payload. + + writer is an AbstractStreamWriter instance: + """ + + +class BytesPayload(Payload): + def __init__(self, value: ByteString, *args: Any, **kwargs: Any) -> None: + if not isinstance(value, (bytes, bytearray, memoryview)): + raise TypeError(f"value argument must be byte-ish, not {type(value)!r}") + + if "content_type" not in kwargs: + kwargs["content_type"] = "application/octet-stream" + + super().__init__(value, *args, **kwargs) + + if isinstance(value, memoryview): + self._size = value.nbytes + else: + self._size = len(value) + + if self._size > TOO_LARGE_BYTES_BODY: + kwargs = {"source": self} + warnings.warn( + "Sending a large body directly with raw bytes might" + " lock the event loop. You should probably pass an " + "io.BytesIO object instead", + ResourceWarning, + **kwargs, + ) + + async def write(self, writer: AbstractStreamWriter) -> None: + await writer.write(self._value) + + +class StringPayload(BytesPayload): + def __init__( + self, + value: str, + *args: Any, + encoding: Optional[str] = None, + content_type: Optional[str] = None, + **kwargs: Any, + ) -> None: + + if encoding is None: + if content_type is None: + real_encoding = "utf-8" + content_type = "text/plain; charset=utf-8" + else: + mimetype = parse_mimetype(content_type) + real_encoding = mimetype.parameters.get("charset", "utf-8") + else: + if content_type is None: + content_type = "text/plain; charset=%s" % encoding + real_encoding = encoding + + super().__init__( + value.encode(real_encoding), + encoding=real_encoding, + content_type=content_type, + *args, + **kwargs, + ) + + +class StringIOPayload(StringPayload): + def __init__(self, value: IO[str], *args: Any, **kwargs: Any) -> None: + super().__init__(value.read(), *args, **kwargs) + + +class IOBasePayload(Payload): + _value: IO[Any] + + def __init__( + self, value: IO[Any], disposition: str = "attachment", *args: Any, **kwargs: Any + ) -> None: + if "filename" not in kwargs: + kwargs["filename"] = guess_filename(value) + + super().__init__(value, *args, **kwargs) + + if self._filename is not None and disposition is not None: + if hdrs.CONTENT_DISPOSITION not in self.headers: + self.set_content_disposition(disposition, filename=self._filename) + + async def write(self, writer: AbstractStreamWriter) -> None: + loop = asyncio.get_event_loop() + try: + chunk = await loop.run_in_executor(None, self._value.read, 2**16) + while chunk: + await writer.write(chunk) + chunk = await loop.run_in_executor(None, self._value.read, 2**16) + finally: + await loop.run_in_executor(None, self._value.close) + + +class TextIOPayload(IOBasePayload): + _value: TextIO + + def __init__( + self, + value: TextIO, + *args: Any, + encoding: Optional[str] = None, + content_type: Optional[str] = None, + **kwargs: Any, + ) -> None: + + if encoding is None: + if content_type is None: + encoding = "utf-8" + content_type = "text/plain; charset=utf-8" + else: + mimetype = parse_mimetype(content_type) + encoding = mimetype.parameters.get("charset", "utf-8") + else: + if content_type is None: + content_type = "text/plain; charset=%s" % encoding + + super().__init__( + value, + content_type=content_type, + encoding=encoding, + *args, + **kwargs, + ) + + @property + def size(self) -> Optional[int]: + try: + return os.fstat(self._value.fileno()).st_size - self._value.tell() + except OSError: + return None + + async def write(self, writer: AbstractStreamWriter) -> None: + loop = asyncio.get_event_loop() + try: + chunk = await loop.run_in_executor(None, self._value.read, 2**16) + while chunk: + data = ( + chunk.encode(encoding=self._encoding) + if self._encoding + else chunk.encode() + ) + await writer.write(data) + chunk = await loop.run_in_executor(None, self._value.read, 2**16) + finally: + await loop.run_in_executor(None, self._value.close) + + +class BytesIOPayload(IOBasePayload): + @property + def size(self) -> int: + position = self._value.tell() + end = self._value.seek(0, os.SEEK_END) + self._value.seek(position) + return end - position + + +class BufferedReaderPayload(IOBasePayload): + @property + def size(self) -> Optional[int]: + try: + return os.fstat(self._value.fileno()).st_size - self._value.tell() + except OSError: + # data.fileno() is not supported, e.g. + # io.BufferedReader(io.BytesIO(b'data')) + return None + + +class JsonPayload(BytesPayload): + def __init__( + self, + value: Any, + encoding: str = "utf-8", + content_type: str = "application/json", + dumps: JSONEncoder = json.dumps, + *args: Any, + **kwargs: Any, + ) -> None: + + super().__init__( + dumps(value).encode(encoding), + content_type=content_type, + encoding=encoding, + *args, + **kwargs, + ) + + +if TYPE_CHECKING: + from typing import AsyncIterable, AsyncIterator + + _AsyncIterator = AsyncIterator[bytes] + _AsyncIterable = AsyncIterable[bytes] +else: + from collections.abc import AsyncIterable, AsyncIterator + + _AsyncIterator = AsyncIterator + _AsyncIterable = AsyncIterable + + +class AsyncIterablePayload(Payload): + + _iter: Optional[_AsyncIterator] = None + + def __init__(self, value: _AsyncIterable, *args: Any, **kwargs: Any) -> None: + if not isinstance(value, AsyncIterable): + raise TypeError( + "value argument must support " + "collections.abc.AsyncIterable interface, " + "got {!r}".format(type(value)) + ) + + if "content_type" not in kwargs: + kwargs["content_type"] = "application/octet-stream" + + super().__init__(value, *args, **kwargs) + + self._iter = value.__aiter__() + + async def write(self, writer: AbstractStreamWriter) -> None: + if self._iter: + try: + # iter is not None check prevents rare cases + # when the case iterable is used twice + while True: + chunk = await self._iter.__anext__() + await writer.write(chunk) + except StopAsyncIteration: + self._iter = None + + +class StreamReaderPayload(AsyncIterablePayload): + def __init__(self, value: StreamReader, *args: Any, **kwargs: Any) -> None: + super().__init__(value.iter_any(), *args, **kwargs) + + +PAYLOAD_REGISTRY = PayloadRegistry() +PAYLOAD_REGISTRY.register(BytesPayload, (bytes, bytearray, memoryview)) +PAYLOAD_REGISTRY.register(StringPayload, str) +PAYLOAD_REGISTRY.register(StringIOPayload, io.StringIO) +PAYLOAD_REGISTRY.register(TextIOPayload, io.TextIOBase) +PAYLOAD_REGISTRY.register(BytesIOPayload, io.BytesIO) +PAYLOAD_REGISTRY.register(BufferedReaderPayload, (io.BufferedReader, io.BufferedRandom)) +PAYLOAD_REGISTRY.register(IOBasePayload, io.IOBase) +PAYLOAD_REGISTRY.register(StreamReaderPayload, StreamReader) +# try_last for giving a chance to more specialized async interables like +# multidict.BodyPartReaderPayload override the default +PAYLOAD_REGISTRY.register(AsyncIterablePayload, AsyncIterable, order=Order.try_last) diff --git a/venv/lib/python3.10/site-packages/aiohttp/pytest_plugin.py b/venv/lib/python3.10/site-packages/aiohttp/pytest_plugin.py new file mode 100644 index 0000000000000000000000000000000000000000..5754747bf48593d0030159fd6f2830c552b172a8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/pytest_plugin.py @@ -0,0 +1,381 @@ +import asyncio +import contextlib +import warnings +from typing import Any, Awaitable, Callable, Dict, Iterator, Optional, Type, Union + +import pytest + +from aiohttp.helpers import isasyncgenfunction +from aiohttp.web import Application + +from .test_utils import ( + BaseTestServer, + RawTestServer, + TestClient, + TestServer, + loop_context, + setup_test_loop, + teardown_test_loop, + unused_port as _unused_port, +) + +try: + import uvloop +except ImportError: # pragma: no cover + uvloop = None # type: ignore[assignment] + +AiohttpClient = Callable[[Union[Application, BaseTestServer]], Awaitable[TestClient]] +AiohttpRawServer = Callable[[Application], Awaitable[RawTestServer]] +AiohttpServer = Callable[[Application], Awaitable[TestServer]] + + +def pytest_addoption(parser): # type: ignore[no-untyped-def] + parser.addoption( + "--aiohttp-fast", + action="store_true", + default=False, + help="run tests faster by disabling extra checks", + ) + parser.addoption( + "--aiohttp-loop", + action="store", + default="pyloop", + help="run tests with specific loop: pyloop, uvloop or all", + ) + parser.addoption( + "--aiohttp-enable-loop-debug", + action="store_true", + default=False, + help="enable event loop debug mode", + ) + + +def pytest_fixture_setup(fixturedef): # type: ignore[no-untyped-def] + """Set up pytest fixture. + + Allow fixtures to be coroutines. Run coroutine fixtures in an event loop. + """ + func = fixturedef.func + + if isasyncgenfunction(func): + # async generator fixture + is_async_gen = True + elif asyncio.iscoroutinefunction(func): + # regular async fixture + is_async_gen = False + else: + # not an async fixture, nothing to do + return + + strip_request = False + if "request" not in fixturedef.argnames: + fixturedef.argnames += ("request",) + strip_request = True + + def wrapper(*args, **kwargs): # type: ignore[no-untyped-def] + request = kwargs["request"] + if strip_request: + del kwargs["request"] + + # if neither the fixture nor the test use the 'loop' fixture, + # 'getfixturevalue' will fail because the test is not parameterized + # (this can be removed someday if 'loop' is no longer parameterized) + if "loop" not in request.fixturenames: + raise Exception( + "Asynchronous fixtures must depend on the 'loop' fixture or " + "be used in tests depending from it." + ) + + _loop = request.getfixturevalue("loop") + + if is_async_gen: + # for async generators, we need to advance the generator once, + # then advance it again in a finalizer + gen = func(*args, **kwargs) + + def finalizer(): # type: ignore[no-untyped-def] + try: + return _loop.run_until_complete(gen.__anext__()) + except StopAsyncIteration: + pass + + request.addfinalizer(finalizer) + return _loop.run_until_complete(gen.__anext__()) + else: + return _loop.run_until_complete(func(*args, **kwargs)) + + fixturedef.func = wrapper + + +@pytest.fixture +def fast(request): # type: ignore[no-untyped-def] + """--fast config option""" + return request.config.getoption("--aiohttp-fast") + + +@pytest.fixture +def loop_debug(request): # type: ignore[no-untyped-def] + """--enable-loop-debug config option""" + return request.config.getoption("--aiohttp-enable-loop-debug") + + +@contextlib.contextmanager +def _runtime_warning_context(): # type: ignore[no-untyped-def] + """Context manager which checks for RuntimeWarnings. + + This exists specifically to + avoid "coroutine 'X' was never awaited" warnings being missed. + + If RuntimeWarnings occur in the context a RuntimeError is raised. + """ + with warnings.catch_warnings(record=True) as _warnings: + yield + rw = [ + "{w.filename}:{w.lineno}:{w.message}".format(w=w) + for w in _warnings + if w.category == RuntimeWarning + ] + if rw: + raise RuntimeError( + "{} Runtime Warning{},\n{}".format( + len(rw), "" if len(rw) == 1 else "s", "\n".join(rw) + ) + ) + + +@contextlib.contextmanager +def _passthrough_loop_context(loop, fast=False): # type: ignore[no-untyped-def] + """Passthrough loop context. + + Sets up and tears down a loop unless one is passed in via the loop + argument when it's passed straight through. + """ + if loop: + # loop already exists, pass it straight through + yield loop + else: + # this shadows loop_context's standard behavior + loop = setup_test_loop() + yield loop + teardown_test_loop(loop, fast=fast) + + +def pytest_pycollect_makeitem(collector, name, obj): # type: ignore[no-untyped-def] + """Fix pytest collecting for coroutines.""" + if collector.funcnamefilter(name) and asyncio.iscoroutinefunction(obj): + return list(collector._genfunctions(name, obj)) + + +def pytest_pyfunc_call(pyfuncitem): # type: ignore[no-untyped-def] + """Run coroutines in an event loop instead of a normal function call.""" + fast = pyfuncitem.config.getoption("--aiohttp-fast") + if asyncio.iscoroutinefunction(pyfuncitem.function): + existing_loop = pyfuncitem.funcargs.get( + "proactor_loop" + ) or pyfuncitem.funcargs.get("loop", None) + with _runtime_warning_context(): + with _passthrough_loop_context(existing_loop, fast=fast) as _loop: + testargs = { + arg: pyfuncitem.funcargs[arg] + for arg in pyfuncitem._fixtureinfo.argnames + } + _loop.run_until_complete(pyfuncitem.obj(**testargs)) + + return True + + +def pytest_generate_tests(metafunc): # type: ignore[no-untyped-def] + if "loop_factory" not in metafunc.fixturenames: + return + + loops = metafunc.config.option.aiohttp_loop + avail_factories: Dict[str, Type[asyncio.AbstractEventLoopPolicy]] + avail_factories = {"pyloop": asyncio.DefaultEventLoopPolicy} + + if uvloop is not None: # pragma: no cover + avail_factories["uvloop"] = uvloop.EventLoopPolicy + + if loops == "all": + loops = "pyloop,uvloop?" + + factories = {} # type: ignore[var-annotated] + for name in loops.split(","): + required = not name.endswith("?") + name = name.strip(" ?") + if name not in avail_factories: # pragma: no cover + if required: + raise ValueError( + "Unknown loop '%s', available loops: %s" + % (name, list(factories.keys())) + ) + else: + continue + factories[name] = avail_factories[name] + metafunc.parametrize( + "loop_factory", list(factories.values()), ids=list(factories.keys()) + ) + + +@pytest.fixture +def loop(loop_factory, fast, loop_debug): # type: ignore[no-untyped-def] + """Return an instance of the event loop.""" + policy = loop_factory() + asyncio.set_event_loop_policy(policy) + with loop_context(fast=fast) as _loop: + if loop_debug: + _loop.set_debug(True) # pragma: no cover + asyncio.set_event_loop(_loop) + yield _loop + + +@pytest.fixture +def proactor_loop(): # type: ignore[no-untyped-def] + policy = asyncio.WindowsProactorEventLoopPolicy() # type: ignore[attr-defined] + asyncio.set_event_loop_policy(policy) + + with loop_context(policy.new_event_loop) as _loop: + asyncio.set_event_loop(_loop) + yield _loop + + +@pytest.fixture +def unused_port(aiohttp_unused_port: Callable[[], int]) -> Callable[[], int]: + warnings.warn( + "Deprecated, use aiohttp_unused_port fixture instead", + DeprecationWarning, + stacklevel=2, + ) + return aiohttp_unused_port + + +@pytest.fixture +def aiohttp_unused_port() -> Callable[[], int]: + """Return a port that is unused on the current host.""" + return _unused_port + + +@pytest.fixture +def aiohttp_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpServer]: + """Factory to create a TestServer instance, given an app. + + aiohttp_server(app, **kwargs) + """ + servers = [] + + async def go(app, *, port=None, **kwargs): # type: ignore[no-untyped-def] + server = TestServer(app, port=port) + await server.start_server(loop=loop, **kwargs) + servers.append(server) + return server + + yield go + + async def finalize() -> None: + while servers: + await servers.pop().close() + + loop.run_until_complete(finalize()) + + +@pytest.fixture +def test_server(aiohttp_server): # type: ignore[no-untyped-def] # pragma: no cover + warnings.warn( + "Deprecated, use aiohttp_server fixture instead", + DeprecationWarning, + stacklevel=2, + ) + return aiohttp_server + + +@pytest.fixture +def aiohttp_raw_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpRawServer]: + """Factory to create a RawTestServer instance, given a web handler. + + aiohttp_raw_server(handler, **kwargs) + """ + servers = [] + + async def go(handler, *, port=None, **kwargs): # type: ignore[no-untyped-def] + server = RawTestServer(handler, port=port) + await server.start_server(loop=loop, **kwargs) + servers.append(server) + return server + + yield go + + async def finalize() -> None: + while servers: + await servers.pop().close() + + loop.run_until_complete(finalize()) + + +@pytest.fixture +def raw_test_server( # type: ignore[no-untyped-def] # pragma: no cover + aiohttp_raw_server, +): + warnings.warn( + "Deprecated, use aiohttp_raw_server fixture instead", + DeprecationWarning, + stacklevel=2, + ) + return aiohttp_raw_server + + +@pytest.fixture +def aiohttp_client( + loop: asyncio.AbstractEventLoop, +) -> Iterator[AiohttpClient]: + """Factory to create a TestClient instance. + + aiohttp_client(app, **kwargs) + aiohttp_client(server, **kwargs) + aiohttp_client(raw_server, **kwargs) + """ + clients = [] + + async def go( + __param: Union[Application, BaseTestServer], + *args: Any, + server_kwargs: Optional[Dict[str, Any]] = None, + **kwargs: Any + ) -> TestClient: + + if isinstance(__param, Callable) and not isinstance( # type: ignore[arg-type] + __param, (Application, BaseTestServer) + ): + __param = __param(loop, *args, **kwargs) + kwargs = {} + else: + assert not args, "args should be empty" + + if isinstance(__param, Application): + server_kwargs = server_kwargs or {} + server = TestServer(__param, loop=loop, **server_kwargs) + client = TestClient(server, loop=loop, **kwargs) + elif isinstance(__param, BaseTestServer): + client = TestClient(__param, loop=loop, **kwargs) + else: + raise ValueError("Unknown argument type: %r" % type(__param)) + + await client.start_server() + clients.append(client) + return client + + yield go + + async def finalize() -> None: + while clients: + await clients.pop().close() + + loop.run_until_complete(finalize()) + + +@pytest.fixture +def test_client(aiohttp_client): # type: ignore[no-untyped-def] # pragma: no cover + warnings.warn( + "Deprecated, use aiohttp_client fixture instead", + DeprecationWarning, + stacklevel=2, + ) + return aiohttp_client diff --git a/venv/lib/python3.10/site-packages/aiohttp/tcp_helpers.py b/venv/lib/python3.10/site-packages/aiohttp/tcp_helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..88b244223741ad2decb6cb612eae644fae88b2b2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/tcp_helpers.py @@ -0,0 +1,37 @@ +"""Helper methods to tune a TCP connection""" + +import asyncio +import socket +from contextlib import suppress +from typing import Optional # noqa + +__all__ = ("tcp_keepalive", "tcp_nodelay") + + +if hasattr(socket, "SO_KEEPALIVE"): + + def tcp_keepalive(transport: asyncio.Transport) -> None: + sock = transport.get_extra_info("socket") + if sock is not None: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) + +else: + + def tcp_keepalive(transport: asyncio.Transport) -> None: # pragma: no cover + pass + + +def tcp_nodelay(transport: asyncio.Transport, value: bool) -> None: + sock = transport.get_extra_info("socket") + + if sock is None: + return + + if sock.family not in (socket.AF_INET, socket.AF_INET6): + return + + value = bool(value) + + # socket may be closed already, on windows OSError get raised + with suppress(OSError): + sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, value) diff --git a/venv/lib/python3.10/site-packages/aiohttp/web_protocol.py b/venv/lib/python3.10/site-packages/aiohttp/web_protocol.py new file mode 100644 index 0000000000000000000000000000000000000000..f083b13eb0f13e321034600ef7e4774093f9da67 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/web_protocol.py @@ -0,0 +1,698 @@ +import asyncio +import asyncio.streams +import traceback +import warnings +from collections import deque +from contextlib import suppress +from html import escape as html_escape +from http import HTTPStatus +from logging import Logger +from typing import ( + TYPE_CHECKING, + Any, + Awaitable, + Callable, + Deque, + Optional, + Sequence, + Tuple, + Type, + Union, + cast, +) + +import attr +import yarl + +from .abc import AbstractAccessLogger, AbstractStreamWriter +from .base_protocol import BaseProtocol +from .helpers import ceil_timeout, set_exception +from .http import ( + HttpProcessingError, + HttpRequestParser, + HttpVersion10, + RawRequestMessage, + StreamWriter, +) +from .log import access_logger, server_logger +from .streams import EMPTY_PAYLOAD, StreamReader +from .tcp_helpers import tcp_keepalive +from .web_exceptions import HTTPException +from .web_log import AccessLogger +from .web_request import BaseRequest +from .web_response import Response, StreamResponse + +__all__ = ("RequestHandler", "RequestPayloadError", "PayloadAccessError") + +if TYPE_CHECKING: + from .web_server import Server + + +_RequestFactory = Callable[ + [ + RawRequestMessage, + StreamReader, + "RequestHandler", + AbstractStreamWriter, + "asyncio.Task[None]", + ], + BaseRequest, +] + +_RequestHandler = Callable[[BaseRequest], Awaitable[StreamResponse]] + +ERROR = RawRequestMessage( + "UNKNOWN", + "/", + HttpVersion10, + {}, # type: ignore[arg-type] + {}, # type: ignore[arg-type] + True, + None, + False, + False, + yarl.URL("/"), +) + + +class RequestPayloadError(Exception): + """Payload parsing error.""" + + +class PayloadAccessError(Exception): + """Payload was accessed after response was sent.""" + + +@attr.s(auto_attribs=True, frozen=True, slots=True) +class _ErrInfo: + status: int + exc: BaseException + message: str + + +_MsgType = Tuple[Union[RawRequestMessage, _ErrInfo], StreamReader] + + +class RequestHandler(BaseProtocol): + """HTTP protocol implementation. + + RequestHandler handles incoming HTTP request. It reads request line, + request headers and request payload and calls handle_request() method. + By default it always returns with 404 response. + + RequestHandler handles errors in incoming request, like bad + status line, bad headers or incomplete payload. If any error occurs, + connection gets closed. + + keepalive_timeout -- number of seconds before closing + keep-alive connection + + tcp_keepalive -- TCP keep-alive is on, default is on + + debug -- enable debug mode + + logger -- custom logger object + + access_log_class -- custom class for access_logger + + access_log -- custom logging object + + access_log_format -- access log format string + + loop -- Optional event loop + + max_line_size -- Optional maximum header line size + + max_field_size -- Optional maximum header field size + + max_headers -- Optional maximum header size + + timeout_ceil_threshold -- Optional value to specify + threshold to ceil() timeout + values + + """ + + KEEPALIVE_RESCHEDULE_DELAY = 1 + + __slots__ = ( + "_request_count", + "_keepalive", + "_manager", + "_request_handler", + "_request_factory", + "_tcp_keepalive", + "_keepalive_time", + "_keepalive_handle", + "_keepalive_timeout", + "_lingering_time", + "_messages", + "_message_tail", + "_waiter", + "_task_handler", + "_upgrade", + "_payload_parser", + "_request_parser", + "_reading_paused", + "logger", + "debug", + "access_log", + "access_logger", + "_close", + "_force_close", + "_current_request", + "_timeout_ceil_threshold", + ) + + def __init__( + self, + manager: "Server", + *, + loop: asyncio.AbstractEventLoop, + keepalive_timeout: float = 75.0, # NGINX default is 75 secs + tcp_keepalive: bool = True, + logger: Logger = server_logger, + access_log_class: Type[AbstractAccessLogger] = AccessLogger, + access_log: Logger = access_logger, + access_log_format: str = AccessLogger.LOG_FORMAT, + debug: bool = False, + max_line_size: int = 8190, + max_headers: int = 32768, + max_field_size: int = 8190, + lingering_time: float = 10.0, + read_bufsize: int = 2**16, + auto_decompress: bool = True, + timeout_ceil_threshold: float = 5, + ): + super().__init__(loop) + + self._request_count = 0 + self._keepalive = False + self._current_request: Optional[BaseRequest] = None + self._manager: Optional[Server] = manager + self._request_handler: Optional[_RequestHandler] = manager.request_handler + self._request_factory: Optional[_RequestFactory] = manager.request_factory + + self._tcp_keepalive = tcp_keepalive + # placeholder to be replaced on keepalive timeout setup + self._keepalive_time = 0.0 + self._keepalive_handle: Optional[asyncio.Handle] = None + self._keepalive_timeout = keepalive_timeout + self._lingering_time = float(lingering_time) + + self._messages: Deque[_MsgType] = deque() + self._message_tail = b"" + + self._waiter: Optional[asyncio.Future[None]] = None + self._task_handler: Optional[asyncio.Task[None]] = None + + self._upgrade = False + self._payload_parser: Any = None + self._request_parser: Optional[HttpRequestParser] = HttpRequestParser( + self, + loop, + read_bufsize, + max_line_size=max_line_size, + max_field_size=max_field_size, + max_headers=max_headers, + payload_exception=RequestPayloadError, + auto_decompress=auto_decompress, + ) + + self._timeout_ceil_threshold: float = 5 + try: + self._timeout_ceil_threshold = float(timeout_ceil_threshold) + except (TypeError, ValueError): + pass + + self.logger = logger + self.debug = debug + self.access_log = access_log + if access_log: + self.access_logger: Optional[AbstractAccessLogger] = access_log_class( + access_log, access_log_format + ) + else: + self.access_logger = None + + self._close = False + self._force_close = False + + def __repr__(self) -> str: + return "<{} {}>".format( + self.__class__.__name__, + "connected" if self.transport is not None else "disconnected", + ) + + @property + def keepalive_timeout(self) -> float: + return self._keepalive_timeout + + async def shutdown(self, timeout: Optional[float] = 15.0) -> None: + """Do worker process exit preparations. + + We need to clean up everything and stop accepting requests. + It is especially important for keep-alive connections. + """ + self._force_close = True + + if self._keepalive_handle is not None: + self._keepalive_handle.cancel() + + if self._waiter: + self._waiter.cancel() + + # wait for handlers + with suppress(asyncio.CancelledError, asyncio.TimeoutError): + async with ceil_timeout(timeout): + if self._current_request is not None: + self._current_request._cancel(asyncio.CancelledError()) + + if self._task_handler is not None and not self._task_handler.done(): + await self._task_handler + + # force-close non-idle handler + if self._task_handler is not None: + self._task_handler.cancel() + + if self.transport is not None: + self.transport.close() + self.transport = None + + def connection_made(self, transport: asyncio.BaseTransport) -> None: + super().connection_made(transport) + + real_transport = cast(asyncio.Transport, transport) + if self._tcp_keepalive: + tcp_keepalive(real_transport) + + self._task_handler = self._loop.create_task(self.start()) + assert self._manager is not None + self._manager.connection_made(self, real_transport) + + def connection_lost(self, exc: Optional[BaseException]) -> None: + if self._manager is None: + return + self._manager.connection_lost(self, exc) + + super().connection_lost(exc) + + # Grab value before setting _manager to None. + handler_cancellation = self._manager.handler_cancellation + + self._manager = None + self._force_close = True + self._request_factory = None + self._request_handler = None + self._request_parser = None + + if self._keepalive_handle is not None: + self._keepalive_handle.cancel() + + if self._current_request is not None: + if exc is None: + exc = ConnectionResetError("Connection lost") + self._current_request._cancel(exc) + + if self._waiter is not None: + self._waiter.cancel() + + if handler_cancellation and self._task_handler is not None: + self._task_handler.cancel() + + self._task_handler = None + + if self._payload_parser is not None: + self._payload_parser.feed_eof() + self._payload_parser = None + + def set_parser(self, parser: Any) -> None: + # Actual type is WebReader + assert self._payload_parser is None + + self._payload_parser = parser + + if self._message_tail: + self._payload_parser.feed_data(self._message_tail) + self._message_tail = b"" + + def eof_received(self) -> None: + pass + + def data_received(self, data: bytes) -> None: + if self._force_close or self._close: + return + # parse http messages + messages: Sequence[_MsgType] + if self._payload_parser is None and not self._upgrade: + assert self._request_parser is not None + try: + messages, upgraded, tail = self._request_parser.feed_data(data) + except HttpProcessingError as exc: + messages = [ + (_ErrInfo(status=400, exc=exc, message=exc.message), EMPTY_PAYLOAD) + ] + upgraded = False + tail = b"" + + for msg, payload in messages or (): + self._request_count += 1 + self._messages.append((msg, payload)) + + waiter = self._waiter + if messages and waiter is not None and not waiter.done(): + # don't set result twice + waiter.set_result(None) + + self._upgrade = upgraded + if upgraded and tail: + self._message_tail = tail + + # no parser, just store + elif self._payload_parser is None and self._upgrade and data: + self._message_tail += data + + # feed payload + elif data: + eof, tail = self._payload_parser.feed_data(data) + if eof: + self.close() + + def keep_alive(self, val: bool) -> None: + """Set keep-alive connection mode. + + :param bool val: new state. + """ + self._keepalive = val + if self._keepalive_handle: + self._keepalive_handle.cancel() + self._keepalive_handle = None + + def close(self) -> None: + """Close connection. + + Stop accepting new pipelining messages and close + connection when handlers done processing messages. + """ + self._close = True + if self._waiter: + self._waiter.cancel() + + def force_close(self) -> None: + """Forcefully close connection.""" + self._force_close = True + if self._waiter: + self._waiter.cancel() + if self.transport is not None: + self.transport.close() + self.transport = None + + def log_access( + self, request: BaseRequest, response: StreamResponse, time: float + ) -> None: + if self.access_logger is not None: + self.access_logger.log(request, response, self._loop.time() - time) + + def log_debug(self, *args: Any, **kw: Any) -> None: + if self.debug: + self.logger.debug(*args, **kw) + + def log_exception(self, *args: Any, **kw: Any) -> None: + self.logger.exception(*args, **kw) + + def _process_keepalive(self) -> None: + if self._force_close or not self._keepalive: + return + + next = self._keepalive_time + self._keepalive_timeout + + # handler in idle state + if self._waiter: + if self._loop.time() > next: + self.force_close() + return + + # not all request handlers are done, + # reschedule itself to next second + self._keepalive_handle = self._loop.call_later( + self.KEEPALIVE_RESCHEDULE_DELAY, + self._process_keepalive, + ) + + async def _handle_request( + self, + request: BaseRequest, + start_time: float, + request_handler: Callable[[BaseRequest], Awaitable[StreamResponse]], + ) -> Tuple[StreamResponse, bool]: + assert self._request_handler is not None + try: + try: + self._current_request = request + resp = await request_handler(request) + finally: + self._current_request = None + except HTTPException as exc: + resp = exc + reset = await self.finish_response(request, resp, start_time) + except asyncio.CancelledError: + raise + except asyncio.TimeoutError as exc: + self.log_debug("Request handler timed out.", exc_info=exc) + resp = self.handle_error(request, 504) + reset = await self.finish_response(request, resp, start_time) + except Exception as exc: + resp = self.handle_error(request, 500, exc) + reset = await self.finish_response(request, resp, start_time) + else: + # Deprecation warning (See #2415) + if getattr(resp, "__http_exception__", False): + warnings.warn( + "returning HTTPException object is deprecated " + "(#2415) and will be removed, " + "please raise the exception instead", + DeprecationWarning, + ) + + reset = await self.finish_response(request, resp, start_time) + + return resp, reset + + async def start(self) -> None: + """Process incoming request. + + It reads request line, request headers and request payload, then + calls handle_request() method. Subclass has to override + handle_request(). start() handles various exceptions in request + or response handling. Connection is being closed always unless + keep_alive(True) specified. + """ + loop = self._loop + handler = self._task_handler + assert handler is not None + manager = self._manager + assert manager is not None + keepalive_timeout = self._keepalive_timeout + resp = None + assert self._request_factory is not None + assert self._request_handler is not None + + while not self._force_close: + if not self._messages: + try: + # wait for next request + self._waiter = loop.create_future() + await self._waiter + except asyncio.CancelledError: + break + finally: + self._waiter = None + + message, payload = self._messages.popleft() + + start = loop.time() + + manager.requests_count += 1 + writer = StreamWriter(self, loop) + if isinstance(message, _ErrInfo): + # make request_factory work + request_handler = self._make_error_handler(message) + message = ERROR + else: + request_handler = self._request_handler + + request = self._request_factory(message, payload, self, writer, handler) + try: + # a new task is used for copy context vars (#3406) + task = self._loop.create_task( + self._handle_request(request, start, request_handler) + ) + try: + resp, reset = await task + except (asyncio.CancelledError, ConnectionError): + self.log_debug("Ignored premature client disconnection") + break + + # Drop the processed task from asyncio.Task.all_tasks() early + del task + if reset: + self.log_debug("Ignored premature client disconnection 2") + break + + # notify server about keep-alive + self._keepalive = bool(resp.keep_alive) + + # check payload + if not payload.is_eof(): + lingering_time = self._lingering_time + if not self._force_close and lingering_time: + self.log_debug( + "Start lingering close timer for %s sec.", lingering_time + ) + + now = loop.time() + end_t = now + lingering_time + + with suppress(asyncio.TimeoutError, asyncio.CancelledError): + while not payload.is_eof() and now < end_t: + async with ceil_timeout(end_t - now): + # read and ignore + await payload.readany() + now = loop.time() + + # if payload still uncompleted + if not payload.is_eof() and not self._force_close: + self.log_debug("Uncompleted request.") + self.close() + + set_exception(payload, PayloadAccessError()) + + except asyncio.CancelledError: + self.log_debug("Ignored premature client disconnection ") + break + except RuntimeError as exc: + if self.debug: + self.log_exception("Unhandled runtime exception", exc_info=exc) + self.force_close() + except Exception as exc: + self.log_exception("Unhandled exception", exc_info=exc) + self.force_close() + finally: + if self.transport is None and resp is not None: + self.log_debug("Ignored premature client disconnection.") + elif not self._force_close: + if self._keepalive and not self._close: + # start keep-alive timer + if keepalive_timeout is not None: + now = self._loop.time() + self._keepalive_time = now + if self._keepalive_handle is None: + self._keepalive_handle = loop.call_at( + now + keepalive_timeout, self._process_keepalive + ) + else: + break + + # remove handler, close transport if no handlers left + if not self._force_close: + self._task_handler = None + if self.transport is not None: + self.transport.close() + + async def finish_response( + self, request: BaseRequest, resp: StreamResponse, start_time: float + ) -> bool: + """Prepare the response and write_eof, then log access. + + This has to + be called within the context of any exception so the access logger + can get exception information. Returns True if the client disconnects + prematurely. + """ + if self._request_parser is not None: + self._request_parser.set_upgraded(False) + self._upgrade = False + if self._message_tail: + self._request_parser.feed_data(self._message_tail) + self._message_tail = b"" + try: + prepare_meth = resp.prepare + except AttributeError: + if resp is None: + raise RuntimeError("Missing return " "statement on request handler") + else: + raise RuntimeError( + "Web-handler should return " + "a response instance, " + "got {!r}".format(resp) + ) + try: + await prepare_meth(request) + await resp.write_eof() + except ConnectionError: + self.log_access(request, resp, start_time) + return True + else: + self.log_access(request, resp, start_time) + return False + + def handle_error( + self, + request: BaseRequest, + status: int = 500, + exc: Optional[BaseException] = None, + message: Optional[str] = None, + ) -> StreamResponse: + """Handle errors. + + Returns HTTP response with specific status code. Logs additional + information. It always closes current connection. + """ + self.log_exception("Error handling request", exc_info=exc) + + # some data already got sent, connection is broken + if request.writer.output_size > 0: + raise ConnectionError( + "Response is sent already, cannot send another response " + "with the error message" + ) + + ct = "text/plain" + if status == HTTPStatus.INTERNAL_SERVER_ERROR: + title = "{0.value} {0.phrase}".format(HTTPStatus.INTERNAL_SERVER_ERROR) + msg = HTTPStatus.INTERNAL_SERVER_ERROR.description + tb = None + if self.debug: + with suppress(Exception): + tb = traceback.format_exc() + + if "text/html" in request.headers.get("Accept", ""): + if tb: + tb = html_escape(tb) + msg = f"

Traceback:

\n
{tb}
" + message = ( + "" + "{title}" + "\n

{title}

" + "\n{msg}\n\n" + ).format(title=title, msg=msg) + ct = "text/html" + else: + if tb: + msg = tb + message = title + "\n\n" + msg + + resp = Response(status=status, text=message, content_type=ct) + resp.force_close() + + return resp + + def _make_error_handler( + self, err_info: _ErrInfo + ) -> Callable[[BaseRequest], Awaitable[StreamResponse]]: + async def handler(request: BaseRequest) -> StreamResponse: + return self.handle_error( + request, err_info.status, err_info.exc, err_info.message + ) + + return handler diff --git a/venv/lib/python3.10/site-packages/aiohttp/web_server.py b/venv/lib/python3.10/site-packages/aiohttp/web_server.py new file mode 100644 index 0000000000000000000000000000000000000000..52faacb164a0a00fdd7ed853e2ca965cc18ab1a6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/aiohttp/web_server.py @@ -0,0 +1,77 @@ +"""Low level HTTP server.""" +import asyncio +from typing import Any, Awaitable, Callable, Dict, List, Optional # noqa + +from .abc import AbstractStreamWriter +from .helpers import get_running_loop +from .http_parser import RawRequestMessage +from .streams import StreamReader +from .web_protocol import RequestHandler, _RequestFactory, _RequestHandler +from .web_request import BaseRequest + +__all__ = ("Server",) + + +class Server: + def __init__( + self, + handler: _RequestHandler, + *, + request_factory: Optional[_RequestFactory] = None, + handler_cancellation: bool = False, + loop: Optional[asyncio.AbstractEventLoop] = None, + **kwargs: Any + ) -> None: + self._loop = get_running_loop(loop) + self._connections: Dict[RequestHandler, asyncio.Transport] = {} + self._kwargs = kwargs + self.requests_count = 0 + self.request_handler = handler + self.request_factory = request_factory or self._make_request + self.handler_cancellation = handler_cancellation + + @property + def connections(self) -> List[RequestHandler]: + return list(self._connections.keys()) + + def connection_made( + self, handler: RequestHandler, transport: asyncio.Transport + ) -> None: + self._connections[handler] = transport + + def connection_lost( + self, handler: RequestHandler, exc: Optional[BaseException] = None + ) -> None: + if handler in self._connections: + del self._connections[handler] + + def _make_request( + self, + message: RawRequestMessage, + payload: StreamReader, + protocol: RequestHandler, + writer: AbstractStreamWriter, + task: "asyncio.Task[None]", + ) -> BaseRequest: + return BaseRequest(message, payload, protocol, writer, task, self._loop) + + def pre_shutdown(self) -> None: + for conn in self._connections: + conn.close() + + async def shutdown(self, timeout: Optional[float] = None) -> None: + coros = (conn.shutdown(timeout) for conn in self._connections) + await asyncio.gather(*coros) + self._connections.clear() + + def __call__(self) -> RequestHandler: + try: + return RequestHandler(self, loop=self._loop, **self._kwargs) + except TypeError: + # Failsafe creation: remove all custom handler_args + kwargs = { + k: v + for k, v in self._kwargs.items() + if k in ["debug", "access_log_class"] + } + return RequestHandler(self, loop=self._loop, **kwargs) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__init__.py b/venv/lib/python3.10/site-packages/pydantic/_internal/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d242fc4777a8a3ac92fe8b810b5b094c9fd4d5f6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_config.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_config.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec2795c0182077a519bd6774fc0e63c967fd106b Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_config.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_metadata.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_metadata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef09564bdd8872bbd19d202f554e612c4644ae8f Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_metadata.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cff50097aab3691b3006151ce18bb34b95b6e1d Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_core_utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_dataclasses.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_dataclasses.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88e99017156dac22d5e8302f76586d3bf26f41b3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_dataclasses.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3bc39c0d6614cece0413d3780559eb23b68fd49 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators_v1.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators_v1.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f096d8c56beb7a110ef06af6d39ab5bd984aa6d2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_decorators_v1.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_discriminated_union.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_discriminated_union.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4656c8ae0526d349bca3812ecc5594b56e5a09e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_discriminated_union.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_docs_extraction.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_docs_extraction.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dec1df9ba9a7e758621a2af1473c73977a4f5212 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_docs_extraction.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_fields.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_fields.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b65d263cdeefb1fe9ce39663e5151152e32bf9c Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_fields.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_forward_ref.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_forward_ref.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fdc58c7d02bd08290e3d7a259f543dfde90649d5 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_forward_ref.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generate_schema.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generate_schema.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cb57122d2067572bdcfbd21398c9e48acdaf1d1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generate_schema.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generics.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generics.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7331870f7930ebffacb11e69e7b29cbc74352d1e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_generics.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_git.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_git.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..191f16aba3e7b582472cc8abb97fe744a817fead Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_git.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_internal_dataclass.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_internal_dataclass.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6c247370801e8476a5725ef7ecb3d81534125fe Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_internal_dataclass.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_known_annotated_metadata.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_known_annotated_metadata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb312f24691b2ebe2e0f378e975c604391e9ed88 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_known_annotated_metadata.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_mock_val_ser.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_mock_val_ser.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b2409cfb4bb037cbf29e02cf8727c5eab1cf0b65 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_mock_val_ser.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_model_construction.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_model_construction.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87fe409dfe6c3f612556a4e8134f03c9f1289cbf Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_model_construction.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_repr.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_repr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29a1bc1e38925bbf9f5b09fd13403939630308d9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_repr.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_schema_generation_shared.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_schema_generation_shared.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b2c7e2be92cd6c4ed5837f56468ad218a775bb8 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_schema_generation_shared.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_signature.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_signature.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63634ca5622c04aa566e0122f1252d5839c105f7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_signature.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_std_types_schema.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_std_types_schema.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e5c540531e4b6e9b0e71cfca410ace15b10e7d6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_std_types_schema.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_typing_extra.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_typing_extra.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef003e72e4a4e34800286edd7f2f159cc2d2a8cd Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_typing_extra.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00a59eba3e70e9f32901932ad537ba95af949855 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validate_call.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validate_call.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..620099e445a96256d869d0cb2dffed3672cb3683 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validate_call.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validators.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validators.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..185c388be5f85b61e9c5361624a306bf3833533f Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/_internal/__pycache__/_validators.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_config.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_config.py new file mode 100644 index 0000000000000000000000000000000000000000..ec00b380330404c2de062a550efd3a825c1afef0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_config.py @@ -0,0 +1,334 @@ +from __future__ import annotations as _annotations + +import warnings +from contextlib import contextmanager +from typing import ( + TYPE_CHECKING, + Any, + Callable, + cast, +) + +from pydantic_core import core_schema +from typing_extensions import ( + Literal, + Self, +) + +from ..aliases import AliasGenerator +from ..config import ConfigDict, ExtraValues, JsonDict, JsonEncoder, JsonSchemaExtraCallable +from ..errors import PydanticUserError +from ..warnings import PydanticDeprecatedSince20 + +if not TYPE_CHECKING: + # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915 + # and https://youtrack.jetbrains.com/issue/PY-51428 + DeprecationWarning = PydanticDeprecatedSince20 + +if TYPE_CHECKING: + from .._internal._schema_generation_shared import GenerateSchema + +DEPRECATION_MESSAGE = 'Support for class-based `config` is deprecated, use ConfigDict instead.' + + +class ConfigWrapper: + """Internal wrapper for Config which exposes ConfigDict items as attributes.""" + + __slots__ = ('config_dict',) + + config_dict: ConfigDict + + # all annotations are copied directly from ConfigDict, and should be kept up to date, a test will fail if they + # stop matching + title: str | None + str_to_lower: bool + str_to_upper: bool + str_strip_whitespace: bool + str_min_length: int + str_max_length: int | None + extra: ExtraValues | None + frozen: bool + populate_by_name: bool + use_enum_values: bool + validate_assignment: bool + arbitrary_types_allowed: bool + from_attributes: bool + # whether to use the actual key provided in the data (e.g. alias or first alias for "field required" errors) instead of field_names + # to construct error `loc`s, default `True` + loc_by_alias: bool + alias_generator: Callable[[str], str] | AliasGenerator | None + ignored_types: tuple[type, ...] + allow_inf_nan: bool + json_schema_extra: JsonDict | JsonSchemaExtraCallable | None + json_encoders: dict[type[object], JsonEncoder] | None + + # new in V2 + strict: bool + # whether instances of models and dataclasses (including subclass instances) should re-validate, default 'never' + revalidate_instances: Literal['always', 'never', 'subclass-instances'] + ser_json_timedelta: Literal['iso8601', 'float'] + ser_json_bytes: Literal['utf8', 'base64'] + ser_json_inf_nan: Literal['null', 'constants'] + # whether to validate default values during validation, default False + validate_default: bool + validate_return: bool + protected_namespaces: tuple[str, ...] + hide_input_in_errors: bool + defer_build: bool + plugin_settings: dict[str, object] | None + schema_generator: type[GenerateSchema] | None + json_schema_serialization_defaults_required: bool + json_schema_mode_override: Literal['validation', 'serialization', None] + coerce_numbers_to_str: bool + regex_engine: Literal['rust-regex', 'python-re'] + validation_error_cause: bool + use_attribute_docstrings: bool + cache_strings: bool | Literal['all', 'keys', 'none'] + + def __init__(self, config: ConfigDict | dict[str, Any] | type[Any] | None, *, check: bool = True): + if check: + self.config_dict = prepare_config(config) + else: + self.config_dict = cast(ConfigDict, config) + + @classmethod + def for_model(cls, bases: tuple[type[Any], ...], namespace: dict[str, Any], kwargs: dict[str, Any]) -> Self: + """Build a new `ConfigWrapper` instance for a `BaseModel`. + + The config wrapper built based on (in descending order of priority): + - options from `kwargs` + - options from the `namespace` + - options from the base classes (`bases`) + + Args: + bases: A tuple of base classes. + namespace: The namespace of the class being created. + kwargs: The kwargs passed to the class being created. + + Returns: + A `ConfigWrapper` instance for `BaseModel`. + """ + config_new = ConfigDict() + for base in bases: + config = getattr(base, 'model_config', None) + if config: + config_new.update(config.copy()) + + config_class_from_namespace = namespace.get('Config') + config_dict_from_namespace = namespace.get('model_config') + + raw_annotations = namespace.get('__annotations__', {}) + if raw_annotations.get('model_config') and not config_dict_from_namespace: + raise PydanticUserError( + '`model_config` cannot be used as a model field name. Use `model_config` for model configuration.', + code='model-config-invalid-field-name', + ) + + if config_class_from_namespace and config_dict_from_namespace: + raise PydanticUserError('"Config" and "model_config" cannot be used together', code='config-both') + + config_from_namespace = config_dict_from_namespace or prepare_config(config_class_from_namespace) + + config_new.update(config_from_namespace) + + for k in list(kwargs.keys()): + if k in config_keys: + config_new[k] = kwargs.pop(k) + + return cls(config_new) + + # we don't show `__getattr__` to type checkers so missing attributes cause errors + if not TYPE_CHECKING: # pragma: no branch + + def __getattr__(self, name: str) -> Any: + try: + return self.config_dict[name] + except KeyError: + try: + return config_defaults[name] + except KeyError: + raise AttributeError(f'Config has no attribute {name!r}') from None + + def core_config(self, obj: Any) -> core_schema.CoreConfig: + """Create a pydantic-core config, `obj` is just used to populate `title` if not set in config. + + Pass `obj=None` if you do not want to attempt to infer the `title`. + + We don't use getattr here since we don't want to populate with defaults. + + Args: + obj: An object used to populate `title` if not set in config. + + Returns: + A `CoreConfig` object created from config. + """ + + def dict_not_none(**kwargs: Any) -> Any: + return {k: v for k, v in kwargs.items() if v is not None} + + core_config = core_schema.CoreConfig( + **dict_not_none( + title=self.config_dict.get('title') or (obj and obj.__name__), + extra_fields_behavior=self.config_dict.get('extra'), + allow_inf_nan=self.config_dict.get('allow_inf_nan'), + populate_by_name=self.config_dict.get('populate_by_name'), + str_strip_whitespace=self.config_dict.get('str_strip_whitespace'), + str_to_lower=self.config_dict.get('str_to_lower'), + str_to_upper=self.config_dict.get('str_to_upper'), + strict=self.config_dict.get('strict'), + ser_json_timedelta=self.config_dict.get('ser_json_timedelta'), + ser_json_bytes=self.config_dict.get('ser_json_bytes'), + ser_json_inf_nan=self.config_dict.get('ser_json_inf_nan'), + from_attributes=self.config_dict.get('from_attributes'), + loc_by_alias=self.config_dict.get('loc_by_alias'), + revalidate_instances=self.config_dict.get('revalidate_instances'), + validate_default=self.config_dict.get('validate_default'), + str_max_length=self.config_dict.get('str_max_length'), + str_min_length=self.config_dict.get('str_min_length'), + hide_input_in_errors=self.config_dict.get('hide_input_in_errors'), + coerce_numbers_to_str=self.config_dict.get('coerce_numbers_to_str'), + regex_engine=self.config_dict.get('regex_engine'), + validation_error_cause=self.config_dict.get('validation_error_cause'), + cache_strings=self.config_dict.get('cache_strings'), + ) + ) + return core_config + + def __repr__(self): + c = ', '.join(f'{k}={v!r}' for k, v in self.config_dict.items()) + return f'ConfigWrapper({c})' + + +class ConfigWrapperStack: + """A stack of `ConfigWrapper` instances.""" + + def __init__(self, config_wrapper: ConfigWrapper): + self._config_wrapper_stack: list[ConfigWrapper] = [config_wrapper] + + @property + def tail(self) -> ConfigWrapper: + return self._config_wrapper_stack[-1] + + @contextmanager + def push(self, config_wrapper: ConfigWrapper | ConfigDict | None): + if config_wrapper is None: + yield + return + + if not isinstance(config_wrapper, ConfigWrapper): + config_wrapper = ConfigWrapper(config_wrapper, check=False) + + self._config_wrapper_stack.append(config_wrapper) + try: + yield + finally: + self._config_wrapper_stack.pop() + + +config_defaults = ConfigDict( + title=None, + str_to_lower=False, + str_to_upper=False, + str_strip_whitespace=False, + str_min_length=0, + str_max_length=None, + # let the model / dataclass decide how to handle it + extra=None, + frozen=False, + populate_by_name=False, + use_enum_values=False, + validate_assignment=False, + arbitrary_types_allowed=False, + from_attributes=False, + loc_by_alias=True, + alias_generator=None, + ignored_types=(), + allow_inf_nan=True, + json_schema_extra=None, + strict=False, + revalidate_instances='never', + ser_json_timedelta='iso8601', + ser_json_bytes='utf8', + ser_json_inf_nan='null', + validate_default=False, + validate_return=False, + protected_namespaces=('model_',), + hide_input_in_errors=False, + json_encoders=None, + defer_build=False, + plugin_settings=None, + schema_generator=None, + json_schema_serialization_defaults_required=False, + json_schema_mode_override=None, + coerce_numbers_to_str=False, + regex_engine='rust-regex', + validation_error_cause=False, + use_attribute_docstrings=False, + cache_strings=True, +) + + +def prepare_config(config: ConfigDict | dict[str, Any] | type[Any] | None) -> ConfigDict: + """Create a `ConfigDict` instance from an existing dict, a class (e.g. old class-based config) or None. + + Args: + config: The input config. + + Returns: + A ConfigDict object created from config. + """ + if config is None: + return ConfigDict() + + if not isinstance(config, dict): + warnings.warn(DEPRECATION_MESSAGE, DeprecationWarning) + config = {k: getattr(config, k) for k in dir(config) if not k.startswith('__')} + + config_dict = cast(ConfigDict, config) + check_deprecated(config_dict) + return config_dict + + +config_keys = set(ConfigDict.__annotations__.keys()) + + +V2_REMOVED_KEYS = { + 'allow_mutation', + 'error_msg_templates', + 'fields', + 'getter_dict', + 'smart_union', + 'underscore_attrs_are_private', + 'json_loads', + 'json_dumps', + 'copy_on_model_validation', + 'post_init_call', +} +V2_RENAMED_KEYS = { + 'allow_population_by_field_name': 'populate_by_name', + 'anystr_lower': 'str_to_lower', + 'anystr_strip_whitespace': 'str_strip_whitespace', + 'anystr_upper': 'str_to_upper', + 'keep_untouched': 'ignored_types', + 'max_anystr_length': 'str_max_length', + 'min_anystr_length': 'str_min_length', + 'orm_mode': 'from_attributes', + 'schema_extra': 'json_schema_extra', + 'validate_all': 'validate_default', +} + + +def check_deprecated(config_dict: ConfigDict) -> None: + """Check for deprecated config keys and warn the user. + + Args: + config_dict: The input config. + """ + deprecated_removed_keys = V2_REMOVED_KEYS & config_dict.keys() + deprecated_renamed_keys = V2_RENAMED_KEYS.keys() & config_dict.keys() + if deprecated_removed_keys or deprecated_renamed_keys: + renamings = {k: V2_RENAMED_KEYS[k] for k in sorted(deprecated_renamed_keys)} + renamed_bullets = [f'* {k!r} has been renamed to {v!r}' for k, v in renamings.items()] + removed_bullets = [f'* {k!r} has been removed' for k in sorted(deprecated_removed_keys)] + message = '\n'.join(['Valid config keys have changed in V2:'] + renamed_bullets + removed_bullets) + warnings.warn(message, UserWarning) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_core_metadata.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_core_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..296d49f5989635c4e0c230dfb7f930ff13d2bedb --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_core_metadata.py @@ -0,0 +1,92 @@ +from __future__ import annotations as _annotations + +import typing +from typing import Any + +import typing_extensions + +if typing.TYPE_CHECKING: + from ._schema_generation_shared import ( + CoreSchemaOrField as CoreSchemaOrField, + ) + from ._schema_generation_shared import ( + GetJsonSchemaFunction, + ) + + +class CoreMetadata(typing_extensions.TypedDict, total=False): + """A `TypedDict` for holding the metadata dict of the schema. + + Attributes: + pydantic_js_functions: List of JSON schema functions. + pydantic_js_prefer_positional_arguments: Whether JSON schema generator will + prefer positional over keyword arguments for an 'arguments' schema. + """ + + pydantic_js_functions: list[GetJsonSchemaFunction] + pydantic_js_annotation_functions: list[GetJsonSchemaFunction] + + # If `pydantic_js_prefer_positional_arguments` is True, the JSON schema generator will + # prefer positional over keyword arguments for an 'arguments' schema. + pydantic_js_prefer_positional_arguments: bool | None + + pydantic_typed_dict_cls: type[Any] | None # TODO: Consider moving this into the pydantic-core TypedDictSchema + + +class CoreMetadataHandler: + """Because the metadata field in pydantic_core is of type `Any`, we can't assume much about its contents. + + This class is used to interact with the metadata field on a CoreSchema object in a consistent + way throughout pydantic. + """ + + __slots__ = ('_schema',) + + def __init__(self, schema: CoreSchemaOrField): + self._schema = schema + + metadata = schema.get('metadata') + if metadata is None: + schema['metadata'] = CoreMetadata() + elif not isinstance(metadata, dict): + raise TypeError(f'CoreSchema metadata should be a dict; got {metadata!r}.') + + @property + def metadata(self) -> CoreMetadata: + """Retrieves the metadata dict from the schema, initializing it to a dict if it is None + and raises an error if it is not a dict. + """ + metadata = self._schema.get('metadata') + if metadata is None: + self._schema['metadata'] = metadata = CoreMetadata() + if not isinstance(metadata, dict): + raise TypeError(f'CoreSchema metadata should be a dict; got {metadata!r}.') + return metadata + + +def build_metadata_dict( + *, # force keyword arguments to make it easier to modify this signature in a backwards-compatible way + js_functions: list[GetJsonSchemaFunction] | None = None, + js_annotation_functions: list[GetJsonSchemaFunction] | None = None, + js_prefer_positional_arguments: bool | None = None, + typed_dict_cls: type[Any] | None = None, + initial_metadata: Any | None = None, +) -> Any: + """Builds a dict to use as the metadata field of a CoreSchema object in a manner that is consistent + with the CoreMetadataHandler class. + """ + if initial_metadata is not None and not isinstance(initial_metadata, dict): + raise TypeError(f'CoreSchema metadata should be a dict; got {initial_metadata!r}.') + + metadata = CoreMetadata( + pydantic_js_functions=js_functions or [], + pydantic_js_annotation_functions=js_annotation_functions or [], + pydantic_js_prefer_positional_arguments=js_prefer_positional_arguments, + pydantic_typed_dict_cls=typed_dict_cls, + ) + metadata = {k: v for k, v in metadata.items() if v is not None} + + if initial_metadata is not None: + metadata = {**initial_metadata, **metadata} + + return metadata diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_core_utils.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_core_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..baec70625a68ca591d6e86ad68ce8c4b1d6518e5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_core_utils.py @@ -0,0 +1,568 @@ +from __future__ import annotations + +import os +from collections import defaultdict +from typing import ( + Any, + Callable, + Hashable, + TypeVar, + Union, +) + +from pydantic_core import CoreSchema, core_schema +from pydantic_core import validate_core_schema as _validate_core_schema +from typing_extensions import TypeAliasType, TypeGuard, get_args, get_origin + +from . import _repr +from ._typing_extra import is_generic_alias + +AnyFunctionSchema = Union[ + core_schema.AfterValidatorFunctionSchema, + core_schema.BeforeValidatorFunctionSchema, + core_schema.WrapValidatorFunctionSchema, + core_schema.PlainValidatorFunctionSchema, +] + + +FunctionSchemaWithInnerSchema = Union[ + core_schema.AfterValidatorFunctionSchema, + core_schema.BeforeValidatorFunctionSchema, + core_schema.WrapValidatorFunctionSchema, +] + +CoreSchemaField = Union[ + core_schema.ModelField, core_schema.DataclassField, core_schema.TypedDictField, core_schema.ComputedField +] +CoreSchemaOrField = Union[core_schema.CoreSchema, CoreSchemaField] + +_CORE_SCHEMA_FIELD_TYPES = {'typed-dict-field', 'dataclass-field', 'model-field', 'computed-field'} +_FUNCTION_WITH_INNER_SCHEMA_TYPES = {'function-before', 'function-after', 'function-wrap'} +_LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES = {'list', 'set', 'frozenset'} + +TAGGED_UNION_TAG_KEY = 'pydantic.internal.tagged_union_tag' +""" +Used in a `Tag` schema to specify the tag used for a discriminated union. +""" +HAS_INVALID_SCHEMAS_METADATA_KEY = 'pydantic.internal.invalid' +"""Used to mark a schema that is invalid because it refers to a definition that was not yet defined when the +schema was first encountered. +""" + + +def is_core_schema( + schema: CoreSchemaOrField, +) -> TypeGuard[CoreSchema]: + return schema['type'] not in _CORE_SCHEMA_FIELD_TYPES + + +def is_core_schema_field( + schema: CoreSchemaOrField, +) -> TypeGuard[CoreSchemaField]: + return schema['type'] in _CORE_SCHEMA_FIELD_TYPES + + +def is_function_with_inner_schema( + schema: CoreSchemaOrField, +) -> TypeGuard[FunctionSchemaWithInnerSchema]: + return schema['type'] in _FUNCTION_WITH_INNER_SCHEMA_TYPES + + +def is_list_like_schema_with_items_schema( + schema: CoreSchema, +) -> TypeGuard[core_schema.ListSchema | core_schema.SetSchema | core_schema.FrozenSetSchema]: + return schema['type'] in _LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES + + +def get_type_ref(type_: type[Any], args_override: tuple[type[Any], ...] | None = None) -> str: + """Produces the ref to be used for this type by pydantic_core's core schemas. + + This `args_override` argument was added for the purpose of creating valid recursive references + when creating generic models without needing to create a concrete class. + """ + origin = get_origin(type_) or type_ + + args = get_args(type_) if is_generic_alias(type_) else (args_override or ()) + generic_metadata = getattr(type_, '__pydantic_generic_metadata__', None) + if generic_metadata: + origin = generic_metadata['origin'] or origin + args = generic_metadata['args'] or args + + module_name = getattr(origin, '__module__', '') + if isinstance(origin, TypeAliasType): + type_ref = f'{module_name}.{origin.__name__}:{id(origin)}' + else: + try: + qualname = getattr(origin, '__qualname__', f'') + except Exception: + qualname = getattr(origin, '__qualname__', '') + type_ref = f'{module_name}.{qualname}:{id(origin)}' + + arg_refs: list[str] = [] + for arg in args: + if isinstance(arg, str): + # Handle string literals as a special case; we may be able to remove this special handling if we + # wrap them in a ForwardRef at some point. + arg_ref = f'{arg}:str-{id(arg)}' + else: + arg_ref = f'{_repr.display_as_type(arg)}:{id(arg)}' + arg_refs.append(arg_ref) + if arg_refs: + type_ref = f'{type_ref}[{",".join(arg_refs)}]' + return type_ref + + +def get_ref(s: core_schema.CoreSchema) -> None | str: + """Get the ref from the schema if it has one. + This exists just for type checking to work correctly. + """ + return s.get('ref', None) + + +def collect_definitions(schema: core_schema.CoreSchema) -> dict[str, core_schema.CoreSchema]: + defs: dict[str, CoreSchema] = {} + + def _record_valid_refs(s: core_schema.CoreSchema, recurse: Recurse) -> core_schema.CoreSchema: + ref = get_ref(s) + if ref: + defs[ref] = s + return recurse(s, _record_valid_refs) + + walk_core_schema(schema, _record_valid_refs) + + return defs + + +def define_expected_missing_refs( + schema: core_schema.CoreSchema, allowed_missing_refs: set[str] +) -> core_schema.CoreSchema | None: + if not allowed_missing_refs: + # in this case, there are no missing refs to potentially substitute, so there's no need to walk the schema + # this is a common case (will be hit for all non-generic models), so it's worth optimizing for + return None + + refs = collect_definitions(schema).keys() + + expected_missing_refs = allowed_missing_refs.difference(refs) + if expected_missing_refs: + definitions: list[core_schema.CoreSchema] = [ + # TODO: Replace this with a (new) CoreSchema that, if present at any level, makes validation fail + # Issue: https://github.com/pydantic/pydantic-core/issues/619 + core_schema.none_schema(ref=ref, metadata={HAS_INVALID_SCHEMAS_METADATA_KEY: True}) + for ref in expected_missing_refs + ] + return core_schema.definitions_schema(schema, definitions) + return None + + +def collect_invalid_schemas(schema: core_schema.CoreSchema) -> bool: + invalid = False + + def _is_schema_valid(s: core_schema.CoreSchema, recurse: Recurse) -> core_schema.CoreSchema: + nonlocal invalid + if 'metadata' in s: + metadata = s['metadata'] + if HAS_INVALID_SCHEMAS_METADATA_KEY in metadata: + invalid = metadata[HAS_INVALID_SCHEMAS_METADATA_KEY] + return s + return recurse(s, _is_schema_valid) + + walk_core_schema(schema, _is_schema_valid) + return invalid + + +T = TypeVar('T') + + +Recurse = Callable[[core_schema.CoreSchema, 'Walk'], core_schema.CoreSchema] +Walk = Callable[[core_schema.CoreSchema, Recurse], core_schema.CoreSchema] + +# TODO: Should we move _WalkCoreSchema into pydantic_core proper? +# Issue: https://github.com/pydantic/pydantic-core/issues/615 + + +class _WalkCoreSchema: + def __init__(self): + self._schema_type_to_method = self._build_schema_type_to_method() + + def _build_schema_type_to_method(self) -> dict[core_schema.CoreSchemaType, Recurse]: + mapping: dict[core_schema.CoreSchemaType, Recurse] = {} + key: core_schema.CoreSchemaType + for key in get_args(core_schema.CoreSchemaType): + method_name = f"handle_{key.replace('-', '_')}_schema" + mapping[key] = getattr(self, method_name, self._handle_other_schemas) + return mapping + + def walk(self, schema: core_schema.CoreSchema, f: Walk) -> core_schema.CoreSchema: + return f(schema, self._walk) + + def _walk(self, schema: core_schema.CoreSchema, f: Walk) -> core_schema.CoreSchema: + schema = self._schema_type_to_method[schema['type']](schema.copy(), f) + ser_schema: core_schema.SerSchema | None = schema.get('serialization') # type: ignore + if ser_schema: + schema['serialization'] = self._handle_ser_schemas(ser_schema, f) + return schema + + def _handle_other_schemas(self, schema: core_schema.CoreSchema, f: Walk) -> core_schema.CoreSchema: + sub_schema = schema.get('schema', None) + if sub_schema is not None: + schema['schema'] = self.walk(sub_schema, f) # type: ignore + return schema + + def _handle_ser_schemas(self, ser_schema: core_schema.SerSchema, f: Walk) -> core_schema.SerSchema: + schema: core_schema.CoreSchema | None = ser_schema.get('schema', None) + if schema is not None: + ser_schema['schema'] = self.walk(schema, f) # type: ignore + return_schema: core_schema.CoreSchema | None = ser_schema.get('return_schema', None) + if return_schema is not None: + ser_schema['return_schema'] = self.walk(return_schema, f) # type: ignore + return ser_schema + + def handle_definitions_schema(self, schema: core_schema.DefinitionsSchema, f: Walk) -> core_schema.CoreSchema: + new_definitions: list[core_schema.CoreSchema] = [] + for definition in schema['definitions']: + if 'schema_ref' in definition and 'ref' in definition: + # This indicates a purposely indirect reference + # We want to keep such references around for implications related to JSON schema, etc.: + new_definitions.append(definition) + # However, we still need to walk the referenced definition: + self.walk(definition, f) + continue + + updated_definition = self.walk(definition, f) + if 'ref' in updated_definition: + # If the updated definition schema doesn't have a 'ref', it shouldn't go in the definitions + # This is most likely to happen due to replacing something with a definition reference, in + # which case it should certainly not go in the definitions list + new_definitions.append(updated_definition) + new_inner_schema = self.walk(schema['schema'], f) + + if not new_definitions and len(schema) == 3: + # This means we'd be returning a "trivial" definitions schema that just wrapped the inner schema + return new_inner_schema + + new_schema = schema.copy() + new_schema['schema'] = new_inner_schema + new_schema['definitions'] = new_definitions + return new_schema + + def handle_list_schema(self, schema: core_schema.ListSchema, f: Walk) -> core_schema.CoreSchema: + items_schema = schema.get('items_schema') + if items_schema is not None: + schema['items_schema'] = self.walk(items_schema, f) + return schema + + def handle_set_schema(self, schema: core_schema.SetSchema, f: Walk) -> core_schema.CoreSchema: + items_schema = schema.get('items_schema') + if items_schema is not None: + schema['items_schema'] = self.walk(items_schema, f) + return schema + + def handle_frozenset_schema(self, schema: core_schema.FrozenSetSchema, f: Walk) -> core_schema.CoreSchema: + items_schema = schema.get('items_schema') + if items_schema is not None: + schema['items_schema'] = self.walk(items_schema, f) + return schema + + def handle_generator_schema(self, schema: core_schema.GeneratorSchema, f: Walk) -> core_schema.CoreSchema: + items_schema = schema.get('items_schema') + if items_schema is not None: + schema['items_schema'] = self.walk(items_schema, f) + return schema + + def handle_tuple_schema(self, schema: core_schema.TupleSchema, f: Walk) -> core_schema.CoreSchema: + schema['items_schema'] = [self.walk(v, f) for v in schema['items_schema']] + return schema + + def handle_dict_schema(self, schema: core_schema.DictSchema, f: Walk) -> core_schema.CoreSchema: + keys_schema = schema.get('keys_schema') + if keys_schema is not None: + schema['keys_schema'] = self.walk(keys_schema, f) + values_schema = schema.get('values_schema') + if values_schema: + schema['values_schema'] = self.walk(values_schema, f) + return schema + + def handle_function_schema(self, schema: AnyFunctionSchema, f: Walk) -> core_schema.CoreSchema: + if not is_function_with_inner_schema(schema): + return schema + schema['schema'] = self.walk(schema['schema'], f) + return schema + + def handle_union_schema(self, schema: core_schema.UnionSchema, f: Walk) -> core_schema.CoreSchema: + new_choices: list[CoreSchema | tuple[CoreSchema, str]] = [] + for v in schema['choices']: + if isinstance(v, tuple): + new_choices.append((self.walk(v[0], f), v[1])) + else: + new_choices.append(self.walk(v, f)) + schema['choices'] = new_choices + return schema + + def handle_tagged_union_schema(self, schema: core_schema.TaggedUnionSchema, f: Walk) -> core_schema.CoreSchema: + new_choices: dict[Hashable, core_schema.CoreSchema] = {} + for k, v in schema['choices'].items(): + new_choices[k] = v if isinstance(v, (str, int)) else self.walk(v, f) + schema['choices'] = new_choices + return schema + + def handle_chain_schema(self, schema: core_schema.ChainSchema, f: Walk) -> core_schema.CoreSchema: + schema['steps'] = [self.walk(v, f) for v in schema['steps']] + return schema + + def handle_lax_or_strict_schema(self, schema: core_schema.LaxOrStrictSchema, f: Walk) -> core_schema.CoreSchema: + schema['lax_schema'] = self.walk(schema['lax_schema'], f) + schema['strict_schema'] = self.walk(schema['strict_schema'], f) + return schema + + def handle_json_or_python_schema(self, schema: core_schema.JsonOrPythonSchema, f: Walk) -> core_schema.CoreSchema: + schema['json_schema'] = self.walk(schema['json_schema'], f) + schema['python_schema'] = self.walk(schema['python_schema'], f) + return schema + + def handle_model_fields_schema(self, schema: core_schema.ModelFieldsSchema, f: Walk) -> core_schema.CoreSchema: + extras_schema = schema.get('extras_schema') + if extras_schema is not None: + schema['extras_schema'] = self.walk(extras_schema, f) + replaced_fields: dict[str, core_schema.ModelField] = {} + replaced_computed_fields: list[core_schema.ComputedField] = [] + for computed_field in schema.get('computed_fields', ()): + replaced_field = computed_field.copy() + replaced_field['return_schema'] = self.walk(computed_field['return_schema'], f) + replaced_computed_fields.append(replaced_field) + if replaced_computed_fields: + schema['computed_fields'] = replaced_computed_fields + for k, v in schema['fields'].items(): + replaced_field = v.copy() + replaced_field['schema'] = self.walk(v['schema'], f) + replaced_fields[k] = replaced_field + schema['fields'] = replaced_fields + return schema + + def handle_typed_dict_schema(self, schema: core_schema.TypedDictSchema, f: Walk) -> core_schema.CoreSchema: + extras_schema = schema.get('extras_schema') + if extras_schema is not None: + schema['extras_schema'] = self.walk(extras_schema, f) + replaced_computed_fields: list[core_schema.ComputedField] = [] + for computed_field in schema.get('computed_fields', ()): + replaced_field = computed_field.copy() + replaced_field['return_schema'] = self.walk(computed_field['return_schema'], f) + replaced_computed_fields.append(replaced_field) + if replaced_computed_fields: + schema['computed_fields'] = replaced_computed_fields + replaced_fields: dict[str, core_schema.TypedDictField] = {} + for k, v in schema['fields'].items(): + replaced_field = v.copy() + replaced_field['schema'] = self.walk(v['schema'], f) + replaced_fields[k] = replaced_field + schema['fields'] = replaced_fields + return schema + + def handle_dataclass_args_schema(self, schema: core_schema.DataclassArgsSchema, f: Walk) -> core_schema.CoreSchema: + replaced_fields: list[core_schema.DataclassField] = [] + replaced_computed_fields: list[core_schema.ComputedField] = [] + for computed_field in schema.get('computed_fields', ()): + replaced_field = computed_field.copy() + replaced_field['return_schema'] = self.walk(computed_field['return_schema'], f) + replaced_computed_fields.append(replaced_field) + if replaced_computed_fields: + schema['computed_fields'] = replaced_computed_fields + for field in schema['fields']: + replaced_field = field.copy() + replaced_field['schema'] = self.walk(field['schema'], f) + replaced_fields.append(replaced_field) + schema['fields'] = replaced_fields + return schema + + def handle_arguments_schema(self, schema: core_schema.ArgumentsSchema, f: Walk) -> core_schema.CoreSchema: + replaced_arguments_schema: list[core_schema.ArgumentsParameter] = [] + for param in schema['arguments_schema']: + replaced_param = param.copy() + replaced_param['schema'] = self.walk(param['schema'], f) + replaced_arguments_schema.append(replaced_param) + schema['arguments_schema'] = replaced_arguments_schema + if 'var_args_schema' in schema: + schema['var_args_schema'] = self.walk(schema['var_args_schema'], f) + if 'var_kwargs_schema' in schema: + schema['var_kwargs_schema'] = self.walk(schema['var_kwargs_schema'], f) + return schema + + def handle_call_schema(self, schema: core_schema.CallSchema, f: Walk) -> core_schema.CoreSchema: + schema['arguments_schema'] = self.walk(schema['arguments_schema'], f) + if 'return_schema' in schema: + schema['return_schema'] = self.walk(schema['return_schema'], f) + return schema + + +_dispatch = _WalkCoreSchema().walk + + +def walk_core_schema(schema: core_schema.CoreSchema, f: Walk) -> core_schema.CoreSchema: + """Recursively traverse a CoreSchema. + + Args: + schema (core_schema.CoreSchema): The CoreSchema to process, it will not be modified. + f (Walk): A function to apply. This function takes two arguments: + 1. The current CoreSchema that is being processed + (not the same one you passed into this function, one level down). + 2. The "next" `f` to call. This lets you for example use `f=functools.partial(some_method, some_context)` + to pass data down the recursive calls without using globals or other mutable state. + + Returns: + core_schema.CoreSchema: A processed CoreSchema. + """ + return f(schema.copy(), _dispatch) + + +def simplify_schema_references(schema: core_schema.CoreSchema) -> core_schema.CoreSchema: # noqa: C901 + definitions: dict[str, core_schema.CoreSchema] = {} + ref_counts: dict[str, int] = defaultdict(int) + involved_in_recursion: dict[str, bool] = {} + current_recursion_ref_count: dict[str, int] = defaultdict(int) + + def collect_refs(s: core_schema.CoreSchema, recurse: Recurse) -> core_schema.CoreSchema: + if s['type'] == 'definitions': + for definition in s['definitions']: + ref = get_ref(definition) + assert ref is not None + if ref not in definitions: + definitions[ref] = definition + recurse(definition, collect_refs) + return recurse(s['schema'], collect_refs) + else: + ref = get_ref(s) + if ref is not None: + new = recurse(s, collect_refs) + new_ref = get_ref(new) + if new_ref: + definitions[new_ref] = new + return core_schema.definition_reference_schema(schema_ref=ref) + else: + return recurse(s, collect_refs) + + schema = walk_core_schema(schema, collect_refs) + + def count_refs(s: core_schema.CoreSchema, recurse: Recurse) -> core_schema.CoreSchema: + if s['type'] != 'definition-ref': + return recurse(s, count_refs) + ref = s['schema_ref'] + ref_counts[ref] += 1 + + if ref_counts[ref] >= 2: + # If this model is involved in a recursion this should be detected + # on its second encounter, we can safely stop the walk here. + if current_recursion_ref_count[ref] != 0: + involved_in_recursion[ref] = True + return s + + current_recursion_ref_count[ref] += 1 + recurse(definitions[ref], count_refs) + current_recursion_ref_count[ref] -= 1 + return s + + schema = walk_core_schema(schema, count_refs) + + assert all(c == 0 for c in current_recursion_ref_count.values()), 'this is a bug! please report it' + + def can_be_inlined(s: core_schema.DefinitionReferenceSchema, ref: str) -> bool: + if ref_counts[ref] > 1: + return False + if involved_in_recursion.get(ref, False): + return False + if 'serialization' in s: + return False + if 'metadata' in s: + metadata = s['metadata'] + for k in ( + 'pydantic_js_functions', + 'pydantic_js_annotation_functions', + 'pydantic.internal.union_discriminator', + ): + if k in metadata: + # we need to keep this as a ref + return False + return True + + def inline_refs(s: core_schema.CoreSchema, recurse: Recurse) -> core_schema.CoreSchema: + if s['type'] == 'definition-ref': + ref = s['schema_ref'] + # Check if the reference is only used once, not involved in recursion and does not have + # any extra keys (like 'serialization') + if can_be_inlined(s, ref): + # Inline the reference by replacing the reference with the actual schema + new = definitions.pop(ref) + ref_counts[ref] -= 1 # because we just replaced it! + # put all other keys that were on the def-ref schema into the inlined version + # in particular this is needed for `serialization` + if 'serialization' in s: + new['serialization'] = s['serialization'] + s = recurse(new, inline_refs) + return s + else: + return recurse(s, inline_refs) + else: + return recurse(s, inline_refs) + + schema = walk_core_schema(schema, inline_refs) + + def_values = [v for v in definitions.values() if ref_counts[v['ref']] > 0] # type: ignore + + if def_values: + schema = core_schema.definitions_schema(schema=schema, definitions=def_values) + return schema + + +def _strip_metadata(schema: CoreSchema) -> CoreSchema: + def strip_metadata(s: CoreSchema, recurse: Recurse) -> CoreSchema: + s = s.copy() + s.pop('metadata', None) + if s['type'] == 'model-fields': + s = s.copy() + s['fields'] = {k: v.copy() for k, v in s['fields'].items()} + for field_name, field_schema in s['fields'].items(): + field_schema.pop('metadata', None) + s['fields'][field_name] = field_schema + computed_fields = s.get('computed_fields', None) + if computed_fields: + s['computed_fields'] = [cf.copy() for cf in computed_fields] + for cf in computed_fields: + cf.pop('metadata', None) + else: + s.pop('computed_fields', None) + elif s['type'] == 'model': + # remove some defaults + if s.get('custom_init', True) is False: + s.pop('custom_init') + if s.get('root_model', True) is False: + s.pop('root_model') + if {'title'}.issuperset(s.get('config', {}).keys()): + s.pop('config', None) + + return recurse(s, strip_metadata) + + return walk_core_schema(schema, strip_metadata) + + +def pretty_print_core_schema( + schema: CoreSchema, + include_metadata: bool = False, +) -> None: + """Pretty print a CoreSchema using rich. + This is intended for debugging purposes. + + Args: + schema: The CoreSchema to print. + include_metadata: Whether to include metadata in the output. Defaults to `False`. + """ + from rich import print # type: ignore # install it manually in your dev env + + if not include_metadata: + schema = _strip_metadata(schema) + + return print(schema) + + +def validate_core_schema(schema: CoreSchema) -> CoreSchema: + if 'PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS' in os.environ: + return schema + return _validate_core_schema(schema) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_dataclasses.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_dataclasses.py new file mode 100644 index 0000000000000000000000000000000000000000..db200f4bdf6e0fcd81027e73c70151a9d7623de7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_dataclasses.py @@ -0,0 +1,230 @@ +"""Private logic for creating pydantic dataclasses.""" +from __future__ import annotations as _annotations + +import dataclasses +import typing +import warnings +from functools import partial, wraps +from typing import Any, Callable, ClassVar + +from pydantic_core import ( + ArgsKwargs, + SchemaSerializer, + SchemaValidator, + core_schema, +) +from typing_extensions import TypeGuard + +from ..errors import PydanticUndefinedAnnotation +from ..fields import FieldInfo +from ..plugin._schema_validator import create_schema_validator +from ..warnings import PydanticDeprecatedSince20 +from . import _config, _decorators, _typing_extra +from ._fields import collect_dataclass_fields +from ._generate_schema import GenerateSchema +from ._generics import get_standard_typevars_map +from ._mock_val_ser import set_dataclass_mocks +from ._schema_generation_shared import CallbackGetCoreSchemaHandler +from ._signature import generate_pydantic_signature + +if typing.TYPE_CHECKING: + from ..config import ConfigDict + + class StandardDataclass(typing.Protocol): + __dataclass_fields__: ClassVar[dict[str, Any]] + __dataclass_params__: ClassVar[Any] # in reality `dataclasses._DataclassParams` + __post_init__: ClassVar[Callable[..., None]] + + def __init__(self, *args: object, **kwargs: object) -> None: + pass + + class PydanticDataclass(StandardDataclass, typing.Protocol): + """A protocol containing attributes only available once a class has been decorated as a Pydantic dataclass. + + Attributes: + __pydantic_config__: Pydantic-specific configuration settings for the dataclass. + __pydantic_complete__: Whether dataclass building is completed, or if there are still undefined fields. + __pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer. + __pydantic_decorators__: Metadata containing the decorators defined on the dataclass. + __pydantic_fields__: Metadata about the fields defined on the dataclass. + __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the dataclass. + __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the dataclass. + """ + + __pydantic_config__: ClassVar[ConfigDict] + __pydantic_complete__: ClassVar[bool] + __pydantic_core_schema__: ClassVar[core_schema.CoreSchema] + __pydantic_decorators__: ClassVar[_decorators.DecoratorInfos] + __pydantic_fields__: ClassVar[dict[str, FieldInfo]] + __pydantic_serializer__: ClassVar[SchemaSerializer] + __pydantic_validator__: ClassVar[SchemaValidator] + +else: + # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915 + # and https://youtrack.jetbrains.com/issue/PY-51428 + DeprecationWarning = PydanticDeprecatedSince20 + + +def set_dataclass_fields( + cls: type[StandardDataclass], + types_namespace: dict[str, Any] | None = None, + config_wrapper: _config.ConfigWrapper | None = None, +) -> None: + """Collect and set `cls.__pydantic_fields__`. + + Args: + cls: The class. + types_namespace: The types namespace, defaults to `None`. + config_wrapper: The config wrapper instance, defaults to `None`. + """ + typevars_map = get_standard_typevars_map(cls) + fields = collect_dataclass_fields(cls, types_namespace, typevars_map=typevars_map, config_wrapper=config_wrapper) + + cls.__pydantic_fields__ = fields # type: ignore + + +def complete_dataclass( + cls: type[Any], + config_wrapper: _config.ConfigWrapper, + *, + raise_errors: bool = True, + types_namespace: dict[str, Any] | None, +) -> bool: + """Finish building a pydantic dataclass. + + This logic is called on a class which has already been wrapped in `dataclasses.dataclass()`. + + This is somewhat analogous to `pydantic._internal._model_construction.complete_model_class`. + + Args: + cls: The class. + config_wrapper: The config wrapper instance. + raise_errors: Whether to raise errors, defaults to `True`. + types_namespace: The types namespace. + + Returns: + `True` if building a pydantic dataclass is successfully completed, `False` otherwise. + + Raises: + PydanticUndefinedAnnotation: If `raise_error` is `True` and there is an undefined annotations. + """ + if hasattr(cls, '__post_init_post_parse__'): + warnings.warn( + 'Support for `__post_init_post_parse__` has been dropped, the method will not be called', DeprecationWarning + ) + + if types_namespace is None: + types_namespace = _typing_extra.get_cls_types_namespace(cls) + + set_dataclass_fields(cls, types_namespace, config_wrapper=config_wrapper) + + typevars_map = get_standard_typevars_map(cls) + gen_schema = GenerateSchema( + config_wrapper, + types_namespace, + typevars_map, + ) + + # This needs to be called before we change the __init__ + sig = generate_pydantic_signature( + init=cls.__init__, + fields=cls.__pydantic_fields__, # type: ignore + config_wrapper=config_wrapper, + is_dataclass=True, + ) + + # dataclass.__init__ must be defined here so its `__qualname__` can be changed since functions can't be copied. + def __init__(__dataclass_self__: PydanticDataclass, *args: Any, **kwargs: Any) -> None: + __tracebackhide__ = True + s = __dataclass_self__ + s.__pydantic_validator__.validate_python(ArgsKwargs(args, kwargs), self_instance=s) + + __init__.__qualname__ = f'{cls.__qualname__}.__init__' + + cls.__init__ = __init__ # type: ignore + cls.__pydantic_config__ = config_wrapper.config_dict # type: ignore + cls.__signature__ = sig # type: ignore + get_core_schema = getattr(cls, '__get_pydantic_core_schema__', None) + try: + if get_core_schema: + schema = get_core_schema( + cls, + CallbackGetCoreSchemaHandler( + partial(gen_schema.generate_schema, from_dunder_get_core_schema=False), + gen_schema, + ref_mode='unpack', + ), + ) + else: + schema = gen_schema.generate_schema(cls, from_dunder_get_core_schema=False) + except PydanticUndefinedAnnotation as e: + if raise_errors: + raise + set_dataclass_mocks(cls, cls.__name__, f'`{e.name}`') + return False + + core_config = config_wrapper.core_config(cls) + + try: + schema = gen_schema.clean_schema(schema) + except gen_schema.CollectedInvalid: + set_dataclass_mocks(cls, cls.__name__, 'all referenced types') + return False + + # We are about to set all the remaining required properties expected for this cast; + # __pydantic_decorators__ and __pydantic_fields__ should already be set + cls = typing.cast('type[PydanticDataclass]', cls) + # debug(schema) + + cls.__pydantic_core_schema__ = schema + cls.__pydantic_validator__ = validator = create_schema_validator( + schema, cls, cls.__module__, cls.__qualname__, 'dataclass', core_config, config_wrapper.plugin_settings + ) + cls.__pydantic_serializer__ = SchemaSerializer(schema, core_config) + + if config_wrapper.validate_assignment: + + @wraps(cls.__setattr__) + def validated_setattr(instance: Any, field: str, value: str, /) -> None: + validator.validate_assignment(instance, field, value) + + cls.__setattr__ = validated_setattr.__get__(None, cls) # type: ignore + + return True + + +def is_builtin_dataclass(_cls: type[Any]) -> TypeGuard[type[StandardDataclass]]: + """Returns True if a class is a stdlib dataclass and *not* a pydantic dataclass. + + We check that + - `_cls` is a dataclass + - `_cls` does not inherit from a processed pydantic dataclass (and thus have a `__pydantic_validator__`) + - `_cls` does not have any annotations that are not dataclass fields + e.g. + ```py + import dataclasses + + import pydantic.dataclasses + + @dataclasses.dataclass + class A: + x: int + + @pydantic.dataclasses.dataclass + class B(A): + y: int + ``` + In this case, when we first check `B`, we make an extra check and look at the annotations ('y'), + which won't be a superset of all the dataclass fields (only the stdlib fields i.e. 'x') + + Args: + cls: The class. + + Returns: + `True` if the class is a stdlib dataclass, `False` otherwise. + """ + return ( + dataclasses.is_dataclass(_cls) + and not hasattr(_cls, '__pydantic_validator__') + and set(_cls.__dataclass_fields__).issuperset(set(getattr(_cls, '__annotations__', {}))) + ) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators.py new file mode 100644 index 0000000000000000000000000000000000000000..8507e4a2434eb4027021ad88c13c2ad0fcda19e4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators.py @@ -0,0 +1,791 @@ +"""Logic related to validators applied to models etc. via the `@field_validator` and `@model_validator` decorators.""" +from __future__ import annotations as _annotations + +from collections import deque +from dataclasses import dataclass, field +from functools import cached_property, partial, partialmethod +from inspect import Parameter, Signature, isdatadescriptor, ismethoddescriptor, signature +from itertools import islice +from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, Iterable, TypeVar, Union + +from pydantic_core import PydanticUndefined, core_schema +from typing_extensions import Literal, TypeAlias, is_typeddict + +from ..errors import PydanticUserError +from ._core_utils import get_type_ref +from ._internal_dataclass import slots_true +from ._typing_extra import get_function_type_hints + +if TYPE_CHECKING: + from ..fields import ComputedFieldInfo + from ..functional_validators import FieldValidatorModes + + +@dataclass(**slots_true) +class ValidatorDecoratorInfo: + """A container for data from `@validator` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@validator'. + fields: A tuple of field names the validator should be called on. + mode: The proposed validator mode. + each_item: For complex objects (sets, lists etc.) whether to validate individual + elements rather than the whole object. + always: Whether this method and other validators should be called even if the value is missing. + check_fields: Whether to check that the fields actually exist on the model. + """ + + decorator_repr: ClassVar[str] = '@validator' + + fields: tuple[str, ...] + mode: Literal['before', 'after'] + each_item: bool + always: bool + check_fields: bool | None + + +@dataclass(**slots_true) +class FieldValidatorDecoratorInfo: + """A container for data from `@field_validator` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@field_validator'. + fields: A tuple of field names the validator should be called on. + mode: The proposed validator mode. + check_fields: Whether to check that the fields actually exist on the model. + """ + + decorator_repr: ClassVar[str] = '@field_validator' + + fields: tuple[str, ...] + mode: FieldValidatorModes + check_fields: bool | None + + +@dataclass(**slots_true) +class RootValidatorDecoratorInfo: + """A container for data from `@root_validator` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@root_validator'. + mode: The proposed validator mode. + """ + + decorator_repr: ClassVar[str] = '@root_validator' + mode: Literal['before', 'after'] + + +@dataclass(**slots_true) +class FieldSerializerDecoratorInfo: + """A container for data from `@field_serializer` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@field_serializer'. + fields: A tuple of field names the serializer should be called on. + mode: The proposed serializer mode. + return_type: The type of the serializer's return value. + when_used: The serialization condition. Accepts a string with values `'always'`, `'unless-none'`, `'json'`, + and `'json-unless-none'`. + check_fields: Whether to check that the fields actually exist on the model. + """ + + decorator_repr: ClassVar[str] = '@field_serializer' + fields: tuple[str, ...] + mode: Literal['plain', 'wrap'] + return_type: Any + when_used: core_schema.WhenUsed + check_fields: bool | None + + +@dataclass(**slots_true) +class ModelSerializerDecoratorInfo: + """A container for data from `@model_serializer` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@model_serializer'. + mode: The proposed serializer mode. + return_type: The type of the serializer's return value. + when_used: The serialization condition. Accepts a string with values `'always'`, `'unless-none'`, `'json'`, + and `'json-unless-none'`. + """ + + decorator_repr: ClassVar[str] = '@model_serializer' + mode: Literal['plain', 'wrap'] + return_type: Any + when_used: core_schema.WhenUsed + + +@dataclass(**slots_true) +class ModelValidatorDecoratorInfo: + """A container for data from `@model_validator` so that we can access it + while building the pydantic-core schema. + + Attributes: + decorator_repr: A class variable representing the decorator string, '@model_serializer'. + mode: The proposed serializer mode. + """ + + decorator_repr: ClassVar[str] = '@model_validator' + mode: Literal['wrap', 'before', 'after'] + + +DecoratorInfo: TypeAlias = """Union[ + ValidatorDecoratorInfo, + FieldValidatorDecoratorInfo, + RootValidatorDecoratorInfo, + FieldSerializerDecoratorInfo, + ModelSerializerDecoratorInfo, + ModelValidatorDecoratorInfo, + ComputedFieldInfo, +]""" + +ReturnType = TypeVar('ReturnType') +DecoratedType: TypeAlias = ( + 'Union[classmethod[Any, Any, ReturnType], staticmethod[Any, ReturnType], Callable[..., ReturnType], property]' +) + + +@dataclass # can't use slots here since we set attributes on `__post_init__` +class PydanticDescriptorProxy(Generic[ReturnType]): + """Wrap a classmethod, staticmethod, property or unbound function + and act as a descriptor that allows us to detect decorated items + from the class' attributes. + + This class' __get__ returns the wrapped item's __get__ result, + which makes it transparent for classmethods and staticmethods. + + Attributes: + wrapped: The decorator that has to be wrapped. + decorator_info: The decorator info. + shim: A wrapper function to wrap V1 style function. + """ + + wrapped: DecoratedType[ReturnType] + decorator_info: DecoratorInfo + shim: Callable[[Callable[..., Any]], Callable[..., Any]] | None = None + + def __post_init__(self): + for attr in 'setter', 'deleter': + if hasattr(self.wrapped, attr): + f = partial(self._call_wrapped_attr, name=attr) + setattr(self, attr, f) + + def _call_wrapped_attr(self, func: Callable[[Any], None], *, name: str) -> PydanticDescriptorProxy[ReturnType]: + self.wrapped = getattr(self.wrapped, name)(func) + return self + + def __get__(self, obj: object | None, obj_type: type[object] | None = None) -> PydanticDescriptorProxy[ReturnType]: + try: + return self.wrapped.__get__(obj, obj_type) + except AttributeError: + # not a descriptor, e.g. a partial object + return self.wrapped # type: ignore[return-value] + + def __set_name__(self, instance: Any, name: str) -> None: + if hasattr(self.wrapped, '__set_name__'): + self.wrapped.__set_name__(instance, name) # pyright: ignore[reportFunctionMemberAccess] + + def __getattr__(self, __name: str) -> Any: + """Forward checks for __isabstractmethod__ and such.""" + return getattr(self.wrapped, __name) + + +DecoratorInfoType = TypeVar('DecoratorInfoType', bound=DecoratorInfo) + + +@dataclass(**slots_true) +class Decorator(Generic[DecoratorInfoType]): + """A generic container class to join together the decorator metadata + (metadata from decorator itself, which we have when the + decorator is called but not when we are building the core-schema) + and the bound function (which we have after the class itself is created). + + Attributes: + cls_ref: The class ref. + cls_var_name: The decorated function name. + func: The decorated function. + shim: A wrapper function to wrap V1 style function. + info: The decorator info. + """ + + cls_ref: str + cls_var_name: str + func: Callable[..., Any] + shim: Callable[[Any], Any] | None + info: DecoratorInfoType + + @staticmethod + def build( + cls_: Any, + *, + cls_var_name: str, + shim: Callable[[Any], Any] | None, + info: DecoratorInfoType, + ) -> Decorator[DecoratorInfoType]: + """Build a new decorator. + + Args: + cls_: The class. + cls_var_name: The decorated function name. + shim: A wrapper function to wrap V1 style function. + info: The decorator info. + + Returns: + The new decorator instance. + """ + func = get_attribute_from_bases(cls_, cls_var_name) + if shim is not None: + func = shim(func) + func = unwrap_wrapped_function(func, unwrap_partial=False) + if not callable(func): + # This branch will get hit for classmethod properties + attribute = get_attribute_from_base_dicts(cls_, cls_var_name) # prevents the binding call to `__get__` + if isinstance(attribute, PydanticDescriptorProxy): + func = unwrap_wrapped_function(attribute.wrapped) + return Decorator( + cls_ref=get_type_ref(cls_), + cls_var_name=cls_var_name, + func=func, + shim=shim, + info=info, + ) + + def bind_to_cls(self, cls: Any) -> Decorator[DecoratorInfoType]: + """Bind the decorator to a class. + + Args: + cls: the class. + + Returns: + The new decorator instance. + """ + return self.build( + cls, + cls_var_name=self.cls_var_name, + shim=self.shim, + info=self.info, + ) + + +def get_bases(tp: type[Any]) -> tuple[type[Any], ...]: + """Get the base classes of a class or typeddict. + + Args: + tp: The type or class to get the bases. + + Returns: + The base classes. + """ + if is_typeddict(tp): + return tp.__orig_bases__ # type: ignore + try: + return tp.__bases__ + except AttributeError: + return () + + +def mro(tp: type[Any]) -> tuple[type[Any], ...]: + """Calculate the Method Resolution Order of bases using the C3 algorithm. + + See https://www.python.org/download/releases/2.3/mro/ + """ + # try to use the existing mro, for performance mainly + # but also because it helps verify the implementation below + if not is_typeddict(tp): + try: + return tp.__mro__ + except AttributeError: + # GenericAlias and some other cases + pass + + bases = get_bases(tp) + return (tp,) + mro_for_bases(bases) + + +def mro_for_bases(bases: tuple[type[Any], ...]) -> tuple[type[Any], ...]: + def merge_seqs(seqs: list[deque[type[Any]]]) -> Iterable[type[Any]]: + while True: + non_empty = [seq for seq in seqs if seq] + if not non_empty: + # Nothing left to process, we're done. + return + candidate: type[Any] | None = None + for seq in non_empty: # Find merge candidates among seq heads. + candidate = seq[0] + not_head = [s for s in non_empty if candidate in islice(s, 1, None)] + if not_head: + # Reject the candidate. + candidate = None + else: + break + if not candidate: + raise TypeError('Inconsistent hierarchy, no C3 MRO is possible') + yield candidate + for seq in non_empty: + # Remove candidate. + if seq[0] == candidate: + seq.popleft() + + seqs = [deque(mro(base)) for base in bases] + [deque(bases)] + return tuple(merge_seqs(seqs)) + + +_sentinel = object() + + +def get_attribute_from_bases(tp: type[Any] | tuple[type[Any], ...], name: str) -> Any: + """Get the attribute from the next class in the MRO that has it, + aiming to simulate calling the method on the actual class. + + The reason for iterating over the mro instead of just getting + the attribute (which would do that for us) is to support TypedDict, + which lacks a real __mro__, but can have a virtual one constructed + from its bases (as done here). + + Args: + tp: The type or class to search for the attribute. If a tuple, this is treated as a set of base classes. + name: The name of the attribute to retrieve. + + Returns: + Any: The attribute value, if found. + + Raises: + AttributeError: If the attribute is not found in any class in the MRO. + """ + if isinstance(tp, tuple): + for base in mro_for_bases(tp): + attribute = base.__dict__.get(name, _sentinel) + if attribute is not _sentinel: + attribute_get = getattr(attribute, '__get__', None) + if attribute_get is not None: + return attribute_get(None, tp) + return attribute + raise AttributeError(f'{name} not found in {tp}') + else: + try: + return getattr(tp, name) + except AttributeError: + return get_attribute_from_bases(mro(tp), name) + + +def get_attribute_from_base_dicts(tp: type[Any], name: str) -> Any: + """Get an attribute out of the `__dict__` following the MRO. + This prevents the call to `__get__` on the descriptor, and allows + us to get the original function for classmethod properties. + + Args: + tp: The type or class to search for the attribute. + name: The name of the attribute to retrieve. + + Returns: + Any: The attribute value, if found. + + Raises: + KeyError: If the attribute is not found in any class's `__dict__` in the MRO. + """ + for base in reversed(mro(tp)): + if name in base.__dict__: + return base.__dict__[name] + return tp.__dict__[name] # raise the error + + +@dataclass(**slots_true) +class DecoratorInfos: + """Mapping of name in the class namespace to decorator info. + + note that the name in the class namespace is the function or attribute name + not the field name! + """ + + validators: dict[str, Decorator[ValidatorDecoratorInfo]] = field(default_factory=dict) + field_validators: dict[str, Decorator[FieldValidatorDecoratorInfo]] = field(default_factory=dict) + root_validators: dict[str, Decorator[RootValidatorDecoratorInfo]] = field(default_factory=dict) + field_serializers: dict[str, Decorator[FieldSerializerDecoratorInfo]] = field(default_factory=dict) + model_serializers: dict[str, Decorator[ModelSerializerDecoratorInfo]] = field(default_factory=dict) + model_validators: dict[str, Decorator[ModelValidatorDecoratorInfo]] = field(default_factory=dict) + computed_fields: dict[str, Decorator[ComputedFieldInfo]] = field(default_factory=dict) + + @staticmethod + def build(model_dc: type[Any]) -> DecoratorInfos: # noqa: C901 (ignore complexity) + """We want to collect all DecFunc instances that exist as + attributes in the namespace of the class (a BaseModel or dataclass) + that called us + But we want to collect these in the order of the bases + So instead of getting them all from the leaf class (the class that called us), + we traverse the bases from root (the oldest ancestor class) to leaf + and collect all of the instances as we go, taking care to replace + any duplicate ones with the last one we see to mimic how function overriding + works with inheritance. + If we do replace any functions we put the replacement into the position + the replaced function was in; that is, we maintain the order. + """ + # reminder: dicts are ordered and replacement does not alter the order + res = DecoratorInfos() + for base in reversed(mro(model_dc)[1:]): + existing: DecoratorInfos | None = base.__dict__.get('__pydantic_decorators__') + if existing is None: + existing = DecoratorInfos.build(base) + res.validators.update({k: v.bind_to_cls(model_dc) for k, v in existing.validators.items()}) + res.field_validators.update({k: v.bind_to_cls(model_dc) for k, v in existing.field_validators.items()}) + res.root_validators.update({k: v.bind_to_cls(model_dc) for k, v in existing.root_validators.items()}) + res.field_serializers.update({k: v.bind_to_cls(model_dc) for k, v in existing.field_serializers.items()}) + res.model_serializers.update({k: v.bind_to_cls(model_dc) for k, v in existing.model_serializers.items()}) + res.model_validators.update({k: v.bind_to_cls(model_dc) for k, v in existing.model_validators.items()}) + res.computed_fields.update({k: v.bind_to_cls(model_dc) for k, v in existing.computed_fields.items()}) + + to_replace: list[tuple[str, Any]] = [] + + for var_name, var_value in vars(model_dc).items(): + if isinstance(var_value, PydanticDescriptorProxy): + info = var_value.decorator_info + if isinstance(info, ValidatorDecoratorInfo): + res.validators[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + elif isinstance(info, FieldValidatorDecoratorInfo): + res.field_validators[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + elif isinstance(info, RootValidatorDecoratorInfo): + res.root_validators[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + elif isinstance(info, FieldSerializerDecoratorInfo): + # check whether a serializer function is already registered for fields + for field_serializer_decorator in res.field_serializers.values(): + # check that each field has at most one serializer function. + # serializer functions for the same field in subclasses are allowed, + # and are treated as overrides + if field_serializer_decorator.cls_var_name == var_name: + continue + for f in info.fields: + if f in field_serializer_decorator.info.fields: + raise PydanticUserError( + 'Multiple field serializer functions were defined ' + f'for field {f!r}, this is not allowed.', + code='multiple-field-serializers', + ) + res.field_serializers[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + elif isinstance(info, ModelValidatorDecoratorInfo): + res.model_validators[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + elif isinstance(info, ModelSerializerDecoratorInfo): + res.model_serializers[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=var_value.shim, info=info + ) + else: + from ..fields import ComputedFieldInfo + + isinstance(var_value, ComputedFieldInfo) + res.computed_fields[var_name] = Decorator.build( + model_dc, cls_var_name=var_name, shim=None, info=info + ) + to_replace.append((var_name, var_value.wrapped)) + if to_replace: + # If we can save `__pydantic_decorators__` on the class we'll be able to check for it above + # so then we don't need to re-process the type, which means we can discard our descriptor wrappers + # and replace them with the thing they are wrapping (see the other setattr call below) + # which allows validator class methods to also function as regular class methods + setattr(model_dc, '__pydantic_decorators__', res) + for name, value in to_replace: + setattr(model_dc, name, value) + return res + + +def inspect_validator(validator: Callable[..., Any], mode: FieldValidatorModes) -> bool: + """Look at a field or model validator function and determine whether it takes an info argument. + + An error is raised if the function has an invalid signature. + + Args: + validator: The validator function to inspect. + mode: The proposed validator mode. + + Returns: + Whether the validator takes an info argument. + """ + try: + sig = signature(validator) + except ValueError: + # builtins and some C extensions don't have signatures + # assume that they don't take an info argument and only take a single argument + # e.g. `str.strip` or `datetime.datetime` + return False + n_positional = count_positional_params(sig) + if mode == 'wrap': + if n_positional == 3: + return True + elif n_positional == 2: + return False + else: + assert mode in {'before', 'after', 'plain'}, f"invalid mode: {mode!r}, expected 'before', 'after' or 'plain" + if n_positional == 2: + return True + elif n_positional == 1: + return False + + raise PydanticUserError( + f'Unrecognized field_validator function signature for {validator} with `mode={mode}`:{sig}', + code='validator-signature', + ) + + +def inspect_field_serializer( + serializer: Callable[..., Any], mode: Literal['plain', 'wrap'], computed_field: bool = False +) -> tuple[bool, bool]: + """Look at a field serializer function and determine if it is a field serializer, + and whether it takes an info argument. + + An error is raised if the function has an invalid signature. + + Args: + serializer: The serializer function to inspect. + mode: The serializer mode, either 'plain' or 'wrap'. + computed_field: When serializer is applied on computed_field. It doesn't require + info signature. + + Returns: + Tuple of (is_field_serializer, info_arg). + """ + sig = signature(serializer) + + first = next(iter(sig.parameters.values()), None) + is_field_serializer = first is not None and first.name == 'self' + + n_positional = count_positional_params(sig) + if is_field_serializer: + # -1 to correct for self parameter + info_arg = _serializer_info_arg(mode, n_positional - 1) + else: + info_arg = _serializer_info_arg(mode, n_positional) + + if info_arg is None: + raise PydanticUserError( + f'Unrecognized field_serializer function signature for {serializer} with `mode={mode}`:{sig}', + code='field-serializer-signature', + ) + if info_arg and computed_field: + raise PydanticUserError( + 'field_serializer on computed_field does not use info signature', code='field-serializer-signature' + ) + + else: + return is_field_serializer, info_arg + + +def inspect_annotated_serializer(serializer: Callable[..., Any], mode: Literal['plain', 'wrap']) -> bool: + """Look at a serializer function used via `Annotated` and determine whether it takes an info argument. + + An error is raised if the function has an invalid signature. + + Args: + serializer: The serializer function to check. + mode: The serializer mode, either 'plain' or 'wrap'. + + Returns: + info_arg + """ + sig = signature(serializer) + info_arg = _serializer_info_arg(mode, count_positional_params(sig)) + if info_arg is None: + raise PydanticUserError( + f'Unrecognized field_serializer function signature for {serializer} with `mode={mode}`:{sig}', + code='field-serializer-signature', + ) + else: + return info_arg + + +def inspect_model_serializer(serializer: Callable[..., Any], mode: Literal['plain', 'wrap']) -> bool: + """Look at a model serializer function and determine whether it takes an info argument. + + An error is raised if the function has an invalid signature. + + Args: + serializer: The serializer function to check. + mode: The serializer mode, either 'plain' or 'wrap'. + + Returns: + `info_arg` - whether the function expects an info argument. + """ + if isinstance(serializer, (staticmethod, classmethod)) or not is_instance_method_from_sig(serializer): + raise PydanticUserError( + '`@model_serializer` must be applied to instance methods', code='model-serializer-instance-method' + ) + + sig = signature(serializer) + info_arg = _serializer_info_arg(mode, count_positional_params(sig)) + if info_arg is None: + raise PydanticUserError( + f'Unrecognized model_serializer function signature for {serializer} with `mode={mode}`:{sig}', + code='model-serializer-signature', + ) + else: + return info_arg + + +def _serializer_info_arg(mode: Literal['plain', 'wrap'], n_positional: int) -> bool | None: + if mode == 'plain': + if n_positional == 1: + # (input_value: Any, /) -> Any + return False + elif n_positional == 2: + # (model: Any, input_value: Any, /) -> Any + return True + else: + assert mode == 'wrap', f"invalid mode: {mode!r}, expected 'plain' or 'wrap'" + if n_positional == 2: + # (input_value: Any, serializer: SerializerFunctionWrapHandler, /) -> Any + return False + elif n_positional == 3: + # (input_value: Any, serializer: SerializerFunctionWrapHandler, info: SerializationInfo, /) -> Any + return True + + return None + + +AnyDecoratorCallable: TypeAlias = ( + 'Union[classmethod[Any, Any, Any], staticmethod[Any, Any], partialmethod[Any], Callable[..., Any]]' +) + + +def is_instance_method_from_sig(function: AnyDecoratorCallable) -> bool: + """Whether the function is an instance method. + + It will consider a function as instance method if the first parameter of + function is `self`. + + Args: + function: The function to check. + + Returns: + `True` if the function is an instance method, `False` otherwise. + """ + sig = signature(unwrap_wrapped_function(function)) + first = next(iter(sig.parameters.values()), None) + if first and first.name == 'self': + return True + return False + + +def ensure_classmethod_based_on_signature(function: AnyDecoratorCallable) -> Any: + """Apply the `@classmethod` decorator on the function. + + Args: + function: The function to apply the decorator on. + + Return: + The `@classmethod` decorator applied function. + """ + if not isinstance( + unwrap_wrapped_function(function, unwrap_class_static_method=False), classmethod + ) and _is_classmethod_from_sig(function): + return classmethod(function) # type: ignore[arg-type] + return function + + +def _is_classmethod_from_sig(function: AnyDecoratorCallable) -> bool: + sig = signature(unwrap_wrapped_function(function)) + first = next(iter(sig.parameters.values()), None) + if first and first.name == 'cls': + return True + return False + + +def unwrap_wrapped_function( + func: Any, + *, + unwrap_partial: bool = True, + unwrap_class_static_method: bool = True, +) -> Any: + """Recursively unwraps a wrapped function until the underlying function is reached. + This handles property, functools.partial, functools.partialmethod, staticmethod and classmethod. + + Args: + func: The function to unwrap. + unwrap_partial: If True (default), unwrap partial and partialmethod decorators, otherwise don't. + decorators. + unwrap_class_static_method: If True (default), also unwrap classmethod and staticmethod + decorators. If False, only unwrap partial and partialmethod decorators. + + Returns: + The underlying function of the wrapped function. + """ + all: set[Any] = {property, cached_property} + + if unwrap_partial: + all.update({partial, partialmethod}) + + if unwrap_class_static_method: + all.update({staticmethod, classmethod}) + + while isinstance(func, tuple(all)): + if unwrap_class_static_method and isinstance(func, (classmethod, staticmethod)): + func = func.__func__ + elif isinstance(func, (partial, partialmethod)): + func = func.func + elif isinstance(func, property): + func = func.fget # arbitrary choice, convenient for computed fields + else: + # Make coverage happy as it can only get here in the last possible case + assert isinstance(func, cached_property) + func = func.func # type: ignore + + return func + + +def get_function_return_type( + func: Any, explicit_return_type: Any, types_namespace: dict[str, Any] | None = None +) -> Any: + """Get the function return type. + + It gets the return type from the type annotation if `explicit_return_type` is `None`. + Otherwise, it returns `explicit_return_type`. + + Args: + func: The function to get its return type. + explicit_return_type: The explicit return type. + types_namespace: The types namespace, defaults to `None`. + + Returns: + The function return type. + """ + if explicit_return_type is PydanticUndefined: + # try to get it from the type annotation + hints = get_function_type_hints( + unwrap_wrapped_function(func), include_keys={'return'}, types_namespace=types_namespace + ) + return hints.get('return', PydanticUndefined) + else: + return explicit_return_type + + +def count_positional_params(sig: Signature) -> int: + return sum(1 for param in sig.parameters.values() if can_be_positional(param)) + + +def can_be_positional(param: Parameter) -> bool: + return param.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD) + + +def ensure_property(f: Any) -> Any: + """Ensure that a function is a `property` or `cached_property`, or is a valid descriptor. + + Args: + f: The function to check. + + Returns: + The function, or a `property` or `cached_property` instance wrapping the function. + """ + if ismethoddescriptor(f) or isdatadescriptor(f): + return f + else: + return property(f) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators_v1.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators_v1.py new file mode 100644 index 0000000000000000000000000000000000000000..4f81e6d4a327610eb7c8ed56f82bb3ab298edd39 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_decorators_v1.py @@ -0,0 +1,181 @@ +"""Logic for V1 validators, e.g. `@validator` and `@root_validator`.""" +from __future__ import annotations as _annotations + +from inspect import Parameter, signature +from typing import Any, Dict, Tuple, Union, cast + +from pydantic_core import core_schema +from typing_extensions import Protocol + +from ..errors import PydanticUserError +from ._decorators import can_be_positional + + +class V1OnlyValueValidator(Protocol): + """A simple validator, supported for V1 validators and V2 validators.""" + + def __call__(self, __value: Any) -> Any: + ... + + +class V1ValidatorWithValues(Protocol): + """A validator with `values` argument, supported for V1 validators and V2 validators.""" + + def __call__(self, __value: Any, values: dict[str, Any]) -> Any: + ... + + +class V1ValidatorWithValuesKwOnly(Protocol): + """A validator with keyword only `values` argument, supported for V1 validators and V2 validators.""" + + def __call__(self, __value: Any, *, values: dict[str, Any]) -> Any: + ... + + +class V1ValidatorWithKwargs(Protocol): + """A validator with `kwargs` argument, supported for V1 validators and V2 validators.""" + + def __call__(self, __value: Any, **kwargs: Any) -> Any: + ... + + +class V1ValidatorWithValuesAndKwargs(Protocol): + """A validator with `values` and `kwargs` arguments, supported for V1 validators and V2 validators.""" + + def __call__(self, __value: Any, values: dict[str, Any], **kwargs: Any) -> Any: + ... + + +V1Validator = Union[ + V1ValidatorWithValues, V1ValidatorWithValuesKwOnly, V1ValidatorWithKwargs, V1ValidatorWithValuesAndKwargs +] + + +def can_be_keyword(param: Parameter) -> bool: + return param.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY) + + +def make_generic_v1_field_validator(validator: V1Validator) -> core_schema.WithInfoValidatorFunction: + """Wrap a V1 style field validator for V2 compatibility. + + Args: + validator: The V1 style field validator. + + Returns: + A wrapped V2 style field validator. + + Raises: + PydanticUserError: If the signature is not supported or the parameters are + not available in Pydantic V2. + """ + sig = signature(validator) + + needs_values_kw = False + + for param_num, (param_name, parameter) in enumerate(sig.parameters.items()): + if can_be_keyword(parameter) and param_name in ('field', 'config'): + raise PydanticUserError( + 'The `field` and `config` parameters are not available in Pydantic V2, ' + 'please use the `info` parameter instead.', + code='validator-field-config-info', + ) + if parameter.kind is Parameter.VAR_KEYWORD: + needs_values_kw = True + elif can_be_keyword(parameter) and param_name == 'values': + needs_values_kw = True + elif can_be_positional(parameter) and param_num == 0: + # value + continue + elif parameter.default is Parameter.empty: # ignore params with defaults e.g. bound by functools.partial + raise PydanticUserError( + f'Unsupported signature for V1 style validator {validator}: {sig} is not supported.', + code='validator-v1-signature', + ) + + if needs_values_kw: + # (v, **kwargs), (v, values, **kwargs), (v, *, values, **kwargs) or (v, *, values) + val1 = cast(V1ValidatorWithValues, validator) + + def wrapper1(value: Any, info: core_schema.ValidationInfo) -> Any: + return val1(value, values=info.data) + + return wrapper1 + else: + val2 = cast(V1OnlyValueValidator, validator) + + def wrapper2(value: Any, _: core_schema.ValidationInfo) -> Any: + return val2(value) + + return wrapper2 + + +RootValidatorValues = Dict[str, Any] +# technically tuple[model_dict, model_extra, fields_set] | tuple[dataclass_dict, init_vars] +RootValidatorFieldsTuple = Tuple[Any, ...] + + +class V1RootValidatorFunction(Protocol): + """A simple root validator, supported for V1 validators and V2 validators.""" + + def __call__(self, __values: RootValidatorValues) -> RootValidatorValues: + ... + + +class V2CoreBeforeRootValidator(Protocol): + """V2 validator with mode='before'.""" + + def __call__(self, __values: RootValidatorValues, __info: core_schema.ValidationInfo) -> RootValidatorValues: + ... + + +class V2CoreAfterRootValidator(Protocol): + """V2 validator with mode='after'.""" + + def __call__( + self, __fields_tuple: RootValidatorFieldsTuple, __info: core_schema.ValidationInfo + ) -> RootValidatorFieldsTuple: + ... + + +def make_v1_generic_root_validator( + validator: V1RootValidatorFunction, pre: bool +) -> V2CoreBeforeRootValidator | V2CoreAfterRootValidator: + """Wrap a V1 style root validator for V2 compatibility. + + Args: + validator: The V1 style field validator. + pre: Whether the validator is a pre validator. + + Returns: + A wrapped V2 style validator. + """ + if pre is True: + # mode='before' for pydantic-core + def _wrapper1(values: RootValidatorValues, _: core_schema.ValidationInfo) -> RootValidatorValues: + return validator(values) + + return _wrapper1 + + # mode='after' for pydantic-core + def _wrapper2(fields_tuple: RootValidatorFieldsTuple, _: core_schema.ValidationInfo) -> RootValidatorFieldsTuple: + if len(fields_tuple) == 2: + # dataclass, this is easy + values, init_vars = fields_tuple + values = validator(values) + return values, init_vars + else: + # ugly hack: to match v1 behaviour, we merge values and model_extra, then split them up based on fields + # afterwards + model_dict, model_extra, fields_set = fields_tuple + if model_extra: + fields = set(model_dict.keys()) + model_dict.update(model_extra) + model_dict_new = validator(model_dict) + for k in list(model_dict_new.keys()): + if k not in fields: + model_extra[k] = model_dict_new.pop(k) + else: + model_dict_new = validator(model_dict) + return model_dict_new, model_extra, fields_set + + return _wrapper2 diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_discriminated_union.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_discriminated_union.py new file mode 100644 index 0000000000000000000000000000000000000000..a090c36f0dea140c0ce35fb06c71122e8e92ca9b --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_discriminated_union.py @@ -0,0 +1,503 @@ +from __future__ import annotations as _annotations + +from typing import TYPE_CHECKING, Any, Hashable, Sequence + +from pydantic_core import CoreSchema, core_schema + +from ..errors import PydanticUserError +from . import _core_utils +from ._core_utils import ( + CoreSchemaField, + collect_definitions, +) + +if TYPE_CHECKING: + from ..types import Discriminator + +CORE_SCHEMA_METADATA_DISCRIMINATOR_PLACEHOLDER_KEY = 'pydantic.internal.union_discriminator' + + +class MissingDefinitionForUnionRef(Exception): + """Raised when applying a discriminated union discriminator to a schema + requires a definition that is not yet defined + """ + + def __init__(self, ref: str) -> None: + self.ref = ref + super().__init__(f'Missing definition for ref {self.ref!r}') + + +def set_discriminator_in_metadata(schema: CoreSchema, discriminator: Any) -> None: + schema.setdefault('metadata', {}) + metadata = schema.get('metadata') + assert metadata is not None + metadata[CORE_SCHEMA_METADATA_DISCRIMINATOR_PLACEHOLDER_KEY] = discriminator + + +def apply_discriminators(schema: core_schema.CoreSchema) -> core_schema.CoreSchema: + # We recursively walk through the `schema` passed to `apply_discriminators`, applying discriminators + # where necessary at each level. During this recursion, we allow references to be resolved from the definitions + # that are originally present on the original, outermost `schema`. Before `apply_discriminators` is called, + # `simplify_schema_references` is called on the schema (in the `clean_schema` function), + # which often puts the definitions in the outermost schema. + global_definitions: dict[str, CoreSchema] = collect_definitions(schema) + + def inner(s: core_schema.CoreSchema, recurse: _core_utils.Recurse) -> core_schema.CoreSchema: + nonlocal global_definitions + + s = recurse(s, inner) + if s['type'] == 'tagged-union': + return s + + metadata = s.get('metadata', {}) + discriminator = metadata.pop(CORE_SCHEMA_METADATA_DISCRIMINATOR_PLACEHOLDER_KEY, None) + if discriminator is not None: + s = apply_discriminator(s, discriminator, global_definitions) + return s + + return _core_utils.walk_core_schema(schema, inner) + + +def apply_discriminator( + schema: core_schema.CoreSchema, + discriminator: str | Discriminator, + definitions: dict[str, core_schema.CoreSchema] | None = None, +) -> core_schema.CoreSchema: + """Applies the discriminator and returns a new core schema. + + Args: + schema: The input schema. + discriminator: The name of the field which will serve as the discriminator. + definitions: A mapping of schema ref to schema. + + Returns: + The new core schema. + + Raises: + TypeError: + - If `discriminator` is used with invalid union variant. + - If `discriminator` is used with `Union` type with one variant. + - If `discriminator` value mapped to multiple choices. + MissingDefinitionForUnionRef: + If the definition for ref is missing. + PydanticUserError: + - If a model in union doesn't have a discriminator field. + - If discriminator field has a non-string alias. + - If discriminator fields have different aliases. + - If discriminator field not of type `Literal`. + """ + from ..types import Discriminator + + if isinstance(discriminator, Discriminator): + if isinstance(discriminator.discriminator, str): + discriminator = discriminator.discriminator + else: + return discriminator._convert_schema(schema) + + return _ApplyInferredDiscriminator(discriminator, definitions or {}).apply(schema) + + +class _ApplyInferredDiscriminator: + """This class is used to convert an input schema containing a union schema into one where that union is + replaced with a tagged-union, with all the associated debugging and performance benefits. + + This is done by: + * Validating that the input schema is compatible with the provided discriminator + * Introspecting the schema to determine which discriminator values should map to which union choices + * Handling various edge cases such as 'definitions', 'default', 'nullable' schemas, and more + + I have chosen to implement the conversion algorithm in this class, rather than a function, + to make it easier to maintain state while recursively walking the provided CoreSchema. + """ + + def __init__(self, discriminator: str, definitions: dict[str, core_schema.CoreSchema]): + # `discriminator` should be the name of the field which will serve as the discriminator. + # It must be the python name of the field, and *not* the field's alias. Note that as of now, + # all members of a discriminated union _must_ use a field with the same name as the discriminator. + # This may change if/when we expose a way to manually specify the TaggedUnionSchema's choices. + self.discriminator = discriminator + + # `definitions` should contain a mapping of schema ref to schema for all schemas which might + # be referenced by some choice + self.definitions = definitions + + # `_discriminator_alias` will hold the value, if present, of the alias for the discriminator + # + # Note: following the v1 implementation, we currently disallow the use of different aliases + # for different choices. This is not a limitation of pydantic_core, but if we try to handle + # this, the inference logic gets complicated very quickly, and could result in confusing + # debugging challenges for users making subtle mistakes. + # + # Rather than trying to do the most powerful inference possible, I think we should eventually + # expose a way to more-manually control the way the TaggedUnionSchema is constructed through + # the use of a new type which would be placed as an Annotation on the Union type. This would + # provide the full flexibility/power of pydantic_core's TaggedUnionSchema where necessary for + # more complex cases, without over-complicating the inference logic for the common cases. + self._discriminator_alias: str | None = None + + # `_should_be_nullable` indicates whether the converted union has `None` as an allowed value. + # If `None` is an acceptable value of the (possibly-wrapped) union, we ignore it while + # constructing the TaggedUnionSchema, but set the `_should_be_nullable` attribute to True. + # Once we have constructed the TaggedUnionSchema, if `_should_be_nullable` is True, we ensure + # that the final schema gets wrapped as a NullableSchema. This has the same semantics on the + # python side, but resolves the issue that `None` cannot correspond to any discriminator values. + self._should_be_nullable = False + + # `_is_nullable` is used to track if the final produced schema will definitely be nullable; + # we set it to True if the input schema is wrapped in a nullable schema that we know will be preserved + # as an indication that, even if None is discovered as one of the union choices, we will not need to wrap + # the final value in another nullable schema. + # + # This is more complicated than just checking for the final outermost schema having type 'nullable' thanks + # to the possible presence of other wrapper schemas such as DefinitionsSchema, WithDefaultSchema, etc. + self._is_nullable = False + + # `_choices_to_handle` serves as a stack of choices to add to the tagged union. Initially, choices + # from the union in the wrapped schema will be appended to this list, and the recursive choice-handling + # algorithm may add more choices to this stack as (nested) unions are encountered. + self._choices_to_handle: list[core_schema.CoreSchema] = [] + + # `_tagged_union_choices` is built during the call to `apply`, and will hold the choices to be included + # in the output TaggedUnionSchema that will replace the union from the input schema + self._tagged_union_choices: dict[Hashable, core_schema.CoreSchema] = {} + + # `_used` is changed to True after applying the discriminator to prevent accidental re-use + self._used = False + + def apply(self, schema: core_schema.CoreSchema) -> core_schema.CoreSchema: + """Return a new CoreSchema based on `schema` that uses a tagged-union with the discriminator provided + to this class. + + Args: + schema: The input schema. + + Returns: + The new core schema. + + Raises: + TypeError: + - If `discriminator` is used with invalid union variant. + - If `discriminator` is used with `Union` type with one variant. + - If `discriminator` value mapped to multiple choices. + ValueError: + If the definition for ref is missing. + PydanticUserError: + - If a model in union doesn't have a discriminator field. + - If discriminator field has a non-string alias. + - If discriminator fields have different aliases. + - If discriminator field not of type `Literal`. + """ + assert not self._used + schema = self._apply_to_root(schema) + if self._should_be_nullable and not self._is_nullable: + schema = core_schema.nullable_schema(schema) + self._used = True + return schema + + def _apply_to_root(self, schema: core_schema.CoreSchema) -> core_schema.CoreSchema: + """This method handles the outer-most stage of recursion over the input schema: + unwrapping nullable or definitions schemas, and calling the `_handle_choice` + method iteratively on the choices extracted (recursively) from the possibly-wrapped union. + """ + if schema['type'] == 'nullable': + self._is_nullable = True + wrapped = self._apply_to_root(schema['schema']) + nullable_wrapper = schema.copy() + nullable_wrapper['schema'] = wrapped + return nullable_wrapper + + if schema['type'] == 'definitions': + wrapped = self._apply_to_root(schema['schema']) + definitions_wrapper = schema.copy() + definitions_wrapper['schema'] = wrapped + return definitions_wrapper + + if schema['type'] != 'union': + # If the schema is not a union, it probably means it just had a single member and + # was flattened by pydantic_core. + # However, it still may make sense to apply the discriminator to this schema, + # as a way to get discriminated-union-style error messages, so we allow this here. + schema = core_schema.union_schema([schema]) + + # Reverse the choices list before extending the stack so that they get handled in the order they occur + choices_schemas = [v[0] if isinstance(v, tuple) else v for v in schema['choices'][::-1]] + self._choices_to_handle.extend(choices_schemas) + while self._choices_to_handle: + choice = self._choices_to_handle.pop() + self._handle_choice(choice) + + if self._discriminator_alias is not None and self._discriminator_alias != self.discriminator: + # * We need to annotate `discriminator` as a union here to handle both branches of this conditional + # * We need to annotate `discriminator` as list[list[str | int]] and not list[list[str]] due to the + # invariance of list, and because list[list[str | int]] is the type of the discriminator argument + # to tagged_union_schema below + # * See the docstring of pydantic_core.core_schema.tagged_union_schema for more details about how to + # interpret the value of the discriminator argument to tagged_union_schema. (The list[list[str]] here + # is the appropriate way to provide a list of fallback attributes to check for a discriminator value.) + discriminator: str | list[list[str | int]] = [[self.discriminator], [self._discriminator_alias]] + else: + discriminator = self.discriminator + return core_schema.tagged_union_schema( + choices=self._tagged_union_choices, + discriminator=discriminator, + custom_error_type=schema.get('custom_error_type'), + custom_error_message=schema.get('custom_error_message'), + custom_error_context=schema.get('custom_error_context'), + strict=False, + from_attributes=True, + ref=schema.get('ref'), + metadata=schema.get('metadata'), + serialization=schema.get('serialization'), + ) + + def _handle_choice(self, choice: core_schema.CoreSchema) -> None: + """This method handles the "middle" stage of recursion over the input schema. + Specifically, it is responsible for handling each choice of the outermost union + (and any "coalesced" choices obtained from inner unions). + + Here, "handling" entails: + * Coalescing nested unions and compatible tagged-unions + * Tracking the presence of 'none' and 'nullable' schemas occurring as choices + * Validating that each allowed discriminator value maps to a unique choice + * Updating the _tagged_union_choices mapping that will ultimately be used to build the TaggedUnionSchema. + """ + if choice['type'] == 'definition-ref': + if choice['schema_ref'] not in self.definitions: + raise MissingDefinitionForUnionRef(choice['schema_ref']) + + if choice['type'] == 'none': + self._should_be_nullable = True + elif choice['type'] == 'definitions': + self._handle_choice(choice['schema']) + elif choice['type'] == 'nullable': + self._should_be_nullable = True + self._handle_choice(choice['schema']) # unwrap the nullable schema + elif choice['type'] == 'union': + # Reverse the choices list before extending the stack so that they get handled in the order they occur + choices_schemas = [v[0] if isinstance(v, tuple) else v for v in choice['choices'][::-1]] + self._choices_to_handle.extend(choices_schemas) + elif choice['type'] not in { + 'model', + 'typed-dict', + 'tagged-union', + 'lax-or-strict', + 'dataclass', + 'dataclass-args', + 'definition-ref', + } and not _core_utils.is_function_with_inner_schema(choice): + # We should eventually handle 'definition-ref' as well + raise TypeError( + f'{choice["type"]!r} is not a valid discriminated union variant;' + ' should be a `BaseModel` or `dataclass`' + ) + else: + if choice['type'] == 'tagged-union' and self._is_discriminator_shared(choice): + # In this case, this inner tagged-union is compatible with the outer tagged-union, + # and its choices can be coalesced into the outer TaggedUnionSchema. + subchoices = [x for x in choice['choices'].values() if not isinstance(x, (str, int))] + # Reverse the choices list before extending the stack so that they get handled in the order they occur + self._choices_to_handle.extend(subchoices[::-1]) + return + + inferred_discriminator_values = self._infer_discriminator_values_for_choice(choice, source_name=None) + self._set_unique_choice_for_values(choice, inferred_discriminator_values) + + def _is_discriminator_shared(self, choice: core_schema.TaggedUnionSchema) -> bool: + """This method returns a boolean indicating whether the discriminator for the `choice` + is the same as that being used for the outermost tagged union. This is used to + determine whether this TaggedUnionSchema choice should be "coalesced" into the top level, + or whether it should be treated as a separate (nested) choice. + """ + inner_discriminator = choice['discriminator'] + return inner_discriminator == self.discriminator or ( + isinstance(inner_discriminator, list) + and (self.discriminator in inner_discriminator or [self.discriminator] in inner_discriminator) + ) + + def _infer_discriminator_values_for_choice( # noqa C901 + self, choice: core_schema.CoreSchema, source_name: str | None + ) -> list[str | int]: + """This function recurses over `choice`, extracting all discriminator values that should map to this choice. + + `model_name` is accepted for the purpose of producing useful error messages. + """ + if choice['type'] == 'definitions': + return self._infer_discriminator_values_for_choice(choice['schema'], source_name=source_name) + elif choice['type'] == 'function-plain': + raise TypeError( + f'{choice["type"]!r} is not a valid discriminated union variant;' + ' should be a `BaseModel` or `dataclass`' + ) + elif _core_utils.is_function_with_inner_schema(choice): + return self._infer_discriminator_values_for_choice(choice['schema'], source_name=source_name) + elif choice['type'] == 'lax-or-strict': + return sorted( + set( + self._infer_discriminator_values_for_choice(choice['lax_schema'], source_name=None) + + self._infer_discriminator_values_for_choice(choice['strict_schema'], source_name=None) + ) + ) + + elif choice['type'] == 'tagged-union': + values: list[str | int] = [] + # Ignore str/int "choices" since these are just references to other choices + subchoices = [x for x in choice['choices'].values() if not isinstance(x, (str, int))] + for subchoice in subchoices: + subchoice_values = self._infer_discriminator_values_for_choice(subchoice, source_name=None) + values.extend(subchoice_values) + return values + + elif choice['type'] == 'union': + values = [] + for subchoice in choice['choices']: + subchoice_schema = subchoice[0] if isinstance(subchoice, tuple) else subchoice + subchoice_values = self._infer_discriminator_values_for_choice(subchoice_schema, source_name=None) + values.extend(subchoice_values) + return values + + elif choice['type'] == 'nullable': + self._should_be_nullable = True + return self._infer_discriminator_values_for_choice(choice['schema'], source_name=None) + + elif choice['type'] == 'model': + return self._infer_discriminator_values_for_choice(choice['schema'], source_name=choice['cls'].__name__) + + elif choice['type'] == 'dataclass': + return self._infer_discriminator_values_for_choice(choice['schema'], source_name=choice['cls'].__name__) + + elif choice['type'] == 'model-fields': + return self._infer_discriminator_values_for_model_choice(choice, source_name=source_name) + + elif choice['type'] == 'dataclass-args': + return self._infer_discriminator_values_for_dataclass_choice(choice, source_name=source_name) + + elif choice['type'] == 'typed-dict': + return self._infer_discriminator_values_for_typed_dict_choice(choice, source_name=source_name) + + elif choice['type'] == 'definition-ref': + schema_ref = choice['schema_ref'] + if schema_ref not in self.definitions: + raise MissingDefinitionForUnionRef(schema_ref) + return self._infer_discriminator_values_for_choice(self.definitions[schema_ref], source_name=source_name) + else: + raise TypeError( + f'{choice["type"]!r} is not a valid discriminated union variant;' + ' should be a `BaseModel` or `dataclass`' + ) + + def _infer_discriminator_values_for_typed_dict_choice( + self, choice: core_schema.TypedDictSchema, source_name: str | None = None + ) -> list[str | int]: + """This method just extracts the _infer_discriminator_values_for_choice logic specific to TypedDictSchema + for the sake of readability. + """ + source = 'TypedDict' if source_name is None else f'TypedDict {source_name!r}' + field = choice['fields'].get(self.discriminator) + if field is None: + raise PydanticUserError( + f'{source} needs a discriminator field for key {self.discriminator!r}', code='discriminator-no-field' + ) + return self._infer_discriminator_values_for_field(field, source) + + def _infer_discriminator_values_for_model_choice( + self, choice: core_schema.ModelFieldsSchema, source_name: str | None = None + ) -> list[str | int]: + source = 'ModelFields' if source_name is None else f'Model {source_name!r}' + field = choice['fields'].get(self.discriminator) + if field is None: + raise PydanticUserError( + f'{source} needs a discriminator field for key {self.discriminator!r}', code='discriminator-no-field' + ) + return self._infer_discriminator_values_for_field(field, source) + + def _infer_discriminator_values_for_dataclass_choice( + self, choice: core_schema.DataclassArgsSchema, source_name: str | None = None + ) -> list[str | int]: + source = 'DataclassArgs' if source_name is None else f'Dataclass {source_name!r}' + for field in choice['fields']: + if field['name'] == self.discriminator: + break + else: + raise PydanticUserError( + f'{source} needs a discriminator field for key {self.discriminator!r}', code='discriminator-no-field' + ) + return self._infer_discriminator_values_for_field(field, source) + + def _infer_discriminator_values_for_field(self, field: CoreSchemaField, source: str) -> list[str | int]: + if field['type'] == 'computed-field': + # This should never occur as a discriminator, as it is only relevant to serialization + return [] + alias = field.get('validation_alias', self.discriminator) + if not isinstance(alias, str): + raise PydanticUserError( + f'Alias {alias!r} is not supported in a discriminated union', code='discriminator-alias-type' + ) + if self._discriminator_alias is None: + self._discriminator_alias = alias + elif self._discriminator_alias != alias: + raise PydanticUserError( + f'Aliases for discriminator {self.discriminator!r} must be the same ' + f'(got {alias}, {self._discriminator_alias})', + code='discriminator-alias', + ) + return self._infer_discriminator_values_for_inner_schema(field['schema'], source) + + def _infer_discriminator_values_for_inner_schema( + self, schema: core_schema.CoreSchema, source: str + ) -> list[str | int]: + """When inferring discriminator values for a field, we typically extract the expected values from a literal + schema. This function does that, but also handles nested unions and defaults. + """ + if schema['type'] == 'literal': + return schema['expected'] + + elif schema['type'] == 'union': + # Generally when multiple values are allowed they should be placed in a single `Literal`, but + # we add this case to handle the situation where a field is annotated as a `Union` of `Literal`s. + # For example, this lets us handle `Union[Literal['key'], Union[Literal['Key'], Literal['KEY']]]` + values: list[Any] = [] + for choice in schema['choices']: + choice_schema = choice[0] if isinstance(choice, tuple) else choice + choice_values = self._infer_discriminator_values_for_inner_schema(choice_schema, source) + values.extend(choice_values) + return values + + elif schema['type'] == 'default': + # This will happen if the field has a default value; we ignore it while extracting the discriminator values + return self._infer_discriminator_values_for_inner_schema(schema['schema'], source) + + elif schema['type'] == 'function-after': + # After validators don't affect the discriminator values + return self._infer_discriminator_values_for_inner_schema(schema['schema'], source) + + elif schema['type'] in {'function-before', 'function-wrap', 'function-plain'}: + validator_type = repr(schema['type'].split('-')[1]) + raise PydanticUserError( + f'Cannot use a mode={validator_type} validator in the' + f' discriminator field {self.discriminator!r} of {source}', + code='discriminator-validator', + ) + + else: + raise PydanticUserError( + f'{source} needs field {self.discriminator!r} to be of type `Literal`', + code='discriminator-needs-literal', + ) + + def _set_unique_choice_for_values(self, choice: core_schema.CoreSchema, values: Sequence[str | int]) -> None: + """This method updates `self.tagged_union_choices` so that all provided (discriminator) `values` map to the + provided `choice`, validating that none of these values already map to another (different) choice. + """ + for discriminator_value in values: + if discriminator_value in self._tagged_union_choices: + # It is okay if `value` is already in tagged_union_choices as long as it maps to the same value. + # Because tagged_union_choices may map values to other values, we need to walk the choices dict + # until we get to a "real" choice, and confirm that is equal to the one assigned. + existing_choice = self._tagged_union_choices[discriminator_value] + if existing_choice != choice: + raise TypeError( + f'Value {discriminator_value!r} for discriminator ' + f'{self.discriminator!r} mapped to multiple choices' + ) + else: + self._tagged_union_choices[discriminator_value] = choice diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_docs_extraction.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_docs_extraction.py new file mode 100644 index 0000000000000000000000000000000000000000..261aec24238f0cfcacf180c65f29596dea2f2f19 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_docs_extraction.py @@ -0,0 +1,107 @@ +"""Utilities related to attribute docstring extraction.""" +from __future__ import annotations + +import ast +import inspect +import textwrap +from typing import Any + + +class DocstringVisitor(ast.NodeVisitor): + def __init__(self) -> None: + super().__init__() + + self.target: str | None = None + self.attrs: dict[str, str] = {} + self.previous_node_type: type[ast.AST] | None = None + + def visit(self, node: ast.AST) -> Any: + node_result = super().visit(node) + self.previous_node_type = type(node) + return node_result + + def visit_AnnAssign(self, node: ast.AnnAssign) -> Any: + if isinstance(node.target, ast.Name): + self.target = node.target.id + + def visit_Expr(self, node: ast.Expr) -> Any: + if ( + isinstance(node.value, ast.Constant) + and isinstance(node.value.value, str) + and self.previous_node_type is ast.AnnAssign + ): + docstring = inspect.cleandoc(node.value.value) + if self.target: + self.attrs[self.target] = docstring + self.target = None + + +def _dedent_source_lines(source: list[str]) -> str: + # Required for nested class definitions, e.g. in a function block + dedent_source = textwrap.dedent(''.join(source)) + if dedent_source.startswith((' ', '\t')): + # We are in the case where there's a dedented (usually multiline) string + # at a lower indentation level than the class itself. We wrap our class + # in a function as a workaround. + dedent_source = f'def dedent_workaround():\n{dedent_source}' + return dedent_source + + +def _extract_source_from_frame(cls: type[Any]) -> list[str] | None: + frame = inspect.currentframe() + + while frame: + if inspect.getmodule(frame) is inspect.getmodule(cls): + lnum = frame.f_lineno + try: + lines, _ = inspect.findsource(frame) + except OSError: + # Source can't be retrieved (maybe because running in an interactive terminal), + # we don't want to error here. + pass + else: + block_lines = inspect.getblock(lines[lnum - 1 :]) + dedent_source = _dedent_source_lines(block_lines) + try: + block_tree = ast.parse(dedent_source) + except SyntaxError: + pass + else: + stmt = block_tree.body[0] + if isinstance(stmt, ast.FunctionDef) and stmt.name == 'dedent_workaround': + # `_dedent_source_lines` wrapped the class around the workaround function + stmt = stmt.body[0] + if isinstance(stmt, ast.ClassDef) and stmt.name == cls.__name__: + return block_lines + + frame = frame.f_back + + +def extract_docstrings_from_cls(cls: type[Any], use_inspect: bool = False) -> dict[str, str]: + """Map model attributes and their corresponding docstring. + + Args: + cls: The class of the Pydantic model to inspect. + use_inspect: Whether to skip usage of frames to find the object and use + the `inspect` module instead. + + Returns: + A mapping containing attribute names and their corresponding docstring. + """ + if use_inspect: + # Might not work as expected if two classes have the same name in the same source file. + try: + source, _ = inspect.getsourcelines(cls) + except OSError: + return {} + else: + source = _extract_source_from_frame(cls) + + if not source: + return {} + + dedent_source = _dedent_source_lines(source) + + visitor = DocstringVisitor() + visitor.visit(ast.parse(dedent_source)) + return visitor.attrs diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_fields.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_fields.py new file mode 100644 index 0000000000000000000000000000000000000000..6e5e9330612fa25510fe412aee88d9e07d09971e --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_fields.py @@ -0,0 +1,344 @@ +"""Private logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.""" +from __future__ import annotations as _annotations + +import dataclasses +import sys +import warnings +from copy import copy +from functools import lru_cache +from typing import TYPE_CHECKING, Any + +from pydantic_core import PydanticUndefined + +from pydantic.errors import PydanticUserError + +from . import _typing_extra +from ._config import ConfigWrapper +from ._docs_extraction import extract_docstrings_from_cls +from ._repr import Representation +from ._typing_extra import get_cls_type_hints_lenient, get_type_hints, is_classvar, is_finalvar + +if TYPE_CHECKING: + from annotated_types import BaseMetadata + + from ..fields import FieldInfo + from ..main import BaseModel + from ._dataclasses import StandardDataclass + from ._decorators import DecoratorInfos + + +def get_type_hints_infer_globalns( + obj: Any, + localns: dict[str, Any] | None = None, + include_extras: bool = False, +) -> dict[str, Any]: + """Gets type hints for an object by inferring the global namespace. + + It uses the `typing.get_type_hints`, The only thing that we do here is fetching + global namespace from `obj.__module__` if it is not `None`. + + Args: + obj: The object to get its type hints. + localns: The local namespaces. + include_extras: Whether to recursively include annotation metadata. + + Returns: + The object type hints. + """ + module_name = getattr(obj, '__module__', None) + globalns: dict[str, Any] | None = None + if module_name: + try: + globalns = sys.modules[module_name].__dict__ + except KeyError: + # happens occasionally, see https://github.com/pydantic/pydantic/issues/2363 + pass + return get_type_hints(obj, globalns=globalns, localns=localns, include_extras=include_extras) + + +class PydanticMetadata(Representation): + """Base class for annotation markers like `Strict`.""" + + __slots__ = () + + +def pydantic_general_metadata(**metadata: Any) -> BaseMetadata: + """Create a new `_PydanticGeneralMetadata` class with the given metadata. + + Args: + **metadata: The metadata to add. + + Returns: + The new `_PydanticGeneralMetadata` class. + """ + return _general_metadata_cls()(metadata) # type: ignore + + +@lru_cache(maxsize=None) +def _general_metadata_cls() -> type[BaseMetadata]: + """Do it this way to avoid importing `annotated_types` at import time.""" + from annotated_types import BaseMetadata + + class _PydanticGeneralMetadata(PydanticMetadata, BaseMetadata): + """Pydantic general metadata like `max_digits`.""" + + def __init__(self, metadata: Any): + self.__dict__ = metadata + + return _PydanticGeneralMetadata # type: ignore + + +def _update_fields_from_docstrings(cls: type[Any], fields: dict[str, FieldInfo], config_wrapper: ConfigWrapper) -> None: + if config_wrapper.use_attribute_docstrings: + fields_docs = extract_docstrings_from_cls(cls) + for ann_name, field_info in fields.items(): + if field_info.description is None and ann_name in fields_docs: + field_info.description = fields_docs[ann_name] + + +def collect_model_fields( # noqa: C901 + cls: type[BaseModel], + bases: tuple[type[Any], ...], + config_wrapper: ConfigWrapper, + types_namespace: dict[str, Any] | None, + *, + typevars_map: dict[Any, Any] | None = None, +) -> tuple[dict[str, FieldInfo], set[str]]: + """Collect the fields of a nascent pydantic model. + + Also collect the names of any ClassVars present in the type hints. + + The returned value is a tuple of two items: the fields dict, and the set of ClassVar names. + + Args: + cls: BaseModel or dataclass. + bases: Parents of the class, generally `cls.__bases__`. + config_wrapper: The config wrapper instance. + types_namespace: Optional extra namespace to look for types in. + typevars_map: A dictionary mapping type variables to their concrete types. + + Returns: + A tuple contains fields and class variables. + + Raises: + NameError: + - If there is a conflict between a field name and protected namespaces. + - If there is a field other than `root` in `RootModel`. + - If a field shadows an attribute in the parent model. + """ + from ..fields import FieldInfo + + type_hints = get_cls_type_hints_lenient(cls, types_namespace) + + # https://docs.python.org/3/howto/annotations.html#accessing-the-annotations-dict-of-an-object-in-python-3-9-and-older + # annotations is only used for finding fields in parent classes + annotations = cls.__dict__.get('__annotations__', {}) + fields: dict[str, FieldInfo] = {} + + class_vars: set[str] = set() + for ann_name, ann_type in type_hints.items(): + if ann_name == 'model_config': + # We never want to treat `model_config` as a field + # Note: we may need to change this logic if/when we introduce a `BareModel` class with no + # protected namespaces (where `model_config` might be allowed as a field name) + continue + for protected_namespace in config_wrapper.protected_namespaces: + if ann_name.startswith(protected_namespace): + for b in bases: + if hasattr(b, ann_name): + from ..main import BaseModel + + if not (issubclass(b, BaseModel) and ann_name in b.model_fields): + raise NameError( + f'Field "{ann_name}" conflicts with member {getattr(b, ann_name)}' + f' of protected namespace "{protected_namespace}".' + ) + else: + valid_namespaces = tuple( + x for x in config_wrapper.protected_namespaces if not ann_name.startswith(x) + ) + warnings.warn( + f'Field "{ann_name}" has conflict with protected namespace "{protected_namespace}".' + '\n\nYou may be able to resolve this warning by setting' + f" `model_config['protected_namespaces'] = {valid_namespaces}`.", + UserWarning, + ) + if is_classvar(ann_type): + class_vars.add(ann_name) + continue + if _is_finalvar_with_default_val(ann_type, getattr(cls, ann_name, PydanticUndefined)): + class_vars.add(ann_name) + continue + if not is_valid_field_name(ann_name): + continue + if cls.__pydantic_root_model__ and ann_name != 'root': + raise NameError( + f"Unexpected field with name {ann_name!r}; only 'root' is allowed as a field of a `RootModel`" + ) + + # when building a generic model with `MyModel[int]`, the generic_origin check makes sure we don't get + # "... shadows an attribute" warnings + generic_origin = getattr(cls, '__pydantic_generic_metadata__', {}).get('origin') + for base in bases: + dataclass_fields = { + field.name for field in (dataclasses.fields(base) if dataclasses.is_dataclass(base) else ()) + } + if hasattr(base, ann_name): + if base is generic_origin: + # Don't warn when "shadowing" of attributes in parametrized generics + continue + + if ann_name in dataclass_fields: + # Don't warn when inheriting stdlib dataclasses whose fields are "shadowed" by defaults being set + # on the class instance. + continue + + if ann_name not in annotations: + # Don't warn when a field exists in a parent class but has not been defined in the current class + continue + + warnings.warn( + f'Field name "{ann_name}" in "{cls.__qualname__}" shadows an attribute in parent ' + f'"{base.__qualname__}"', + UserWarning, + ) + + try: + default = getattr(cls, ann_name, PydanticUndefined) + if default is PydanticUndefined: + raise AttributeError + except AttributeError: + if ann_name in annotations: + field_info = FieldInfo.from_annotation(ann_type) + else: + # if field has no default value and is not in __annotations__ this means that it is + # defined in a base class and we can take it from there + model_fields_lookup: dict[str, FieldInfo] = {} + for x in cls.__bases__[::-1]: + model_fields_lookup.update(getattr(x, 'model_fields', {})) + if ann_name in model_fields_lookup: + # The field was present on one of the (possibly multiple) base classes + # copy the field to make sure typevar substitutions don't cause issues with the base classes + field_info = copy(model_fields_lookup[ann_name]) + else: + # The field was not found on any base classes; this seems to be caused by fields not getting + # generated thanks to models not being fully defined while initializing recursive models. + # Nothing stops us from just creating a new FieldInfo for this type hint, so we do this. + field_info = FieldInfo.from_annotation(ann_type) + else: + field_info = FieldInfo.from_annotated_attribute(ann_type, default) + # attributes which are fields are removed from the class namespace: + # 1. To match the behaviour of annotation-only fields + # 2. To avoid false positives in the NameError check above + try: + delattr(cls, ann_name) + except AttributeError: + pass # indicates the attribute was on a parent class + + # Use cls.__dict__['__pydantic_decorators__'] instead of cls.__pydantic_decorators__ + # to make sure the decorators have already been built for this exact class + decorators: DecoratorInfos = cls.__dict__['__pydantic_decorators__'] + if ann_name in decorators.computed_fields: + raise ValueError("you can't override a field with a computed field") + fields[ann_name] = field_info + + if typevars_map: + for field in fields.values(): + field.apply_typevars_map(typevars_map, types_namespace) + + _update_fields_from_docstrings(cls, fields, config_wrapper) + + return fields, class_vars + + +def _is_finalvar_with_default_val(type_: type[Any], val: Any) -> bool: + from ..fields import FieldInfo + + if not is_finalvar(type_): + return False + elif val is PydanticUndefined: + return False + elif isinstance(val, FieldInfo) and (val.default is PydanticUndefined and val.default_factory is None): + return False + else: + return True + + +def collect_dataclass_fields( + cls: type[StandardDataclass], + types_namespace: dict[str, Any] | None, + *, + typevars_map: dict[Any, Any] | None = None, + config_wrapper: ConfigWrapper | None = None, +) -> dict[str, FieldInfo]: + """Collect the fields of a dataclass. + + Args: + cls: dataclass. + types_namespace: Optional extra namespace to look for types in. + typevars_map: A dictionary mapping type variables to their concrete types. + config_wrapper: The config wrapper instance. + + Returns: + The dataclass fields. + """ + from ..fields import FieldInfo + + fields: dict[str, FieldInfo] = {} + dataclass_fields: dict[str, dataclasses.Field] = cls.__dataclass_fields__ + cls_localns = dict(vars(cls)) # this matches get_cls_type_hints_lenient, but all tests pass with `= None` instead + + source_module = sys.modules.get(cls.__module__) + if source_module is not None: + types_namespace = {**source_module.__dict__, **(types_namespace or {})} + + for ann_name, dataclass_field in dataclass_fields.items(): + ann_type = _typing_extra.eval_type_lenient(dataclass_field.type, types_namespace, cls_localns) + if is_classvar(ann_type): + continue + + if ( + not dataclass_field.init + and dataclass_field.default == dataclasses.MISSING + and dataclass_field.default_factory == dataclasses.MISSING + ): + # TODO: We should probably do something with this so that validate_assignment behaves properly + # Issue: https://github.com/pydantic/pydantic/issues/5470 + continue + + if isinstance(dataclass_field.default, FieldInfo): + if dataclass_field.default.init_var: + if dataclass_field.default.init is False: + raise PydanticUserError( + f'Dataclass field {ann_name} has init=False and init_var=True, but these are mutually exclusive.', + code='clashing-init-and-init-var', + ) + + # TODO: same note as above re validate_assignment + continue + field_info = FieldInfo.from_annotated_attribute(ann_type, dataclass_field.default) + else: + field_info = FieldInfo.from_annotated_attribute(ann_type, dataclass_field) + + fields[ann_name] = field_info + + if field_info.default is not PydanticUndefined and isinstance(getattr(cls, ann_name, field_info), FieldInfo): + # We need this to fix the default when the "default" from __dataclass_fields__ is a pydantic.FieldInfo + setattr(cls, ann_name, field_info.default) + + if typevars_map: + for field in fields.values(): + field.apply_typevars_map(typevars_map, types_namespace) + + if config_wrapper is not None: + _update_fields_from_docstrings(cls, fields, config_wrapper) + + return fields + + +def is_valid_field_name(name: str) -> bool: + return not name.startswith('_') + + +def is_valid_privateattr_name(name: str) -> bool: + return name.startswith('_') and not name.startswith('__') diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_forward_ref.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_forward_ref.py new file mode 100644 index 0000000000000000000000000000000000000000..231f81d11b87ef05d4765cd61d88d7348eb9e401 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_forward_ref.py @@ -0,0 +1,23 @@ +from __future__ import annotations as _annotations + +from dataclasses import dataclass +from typing import Union + + +@dataclass +class PydanticRecursiveRef: + type_ref: str + + __name__ = 'PydanticRecursiveRef' + __hash__ = object.__hash__ + + def __call__(self) -> None: + """Defining __call__ is necessary for the `typing` module to let you use an instance of + this class as the result of resolving a standard ForwardRef. + """ + + def __or__(self, other): + return Union[self, other] # type: ignore + + def __ror__(self, other): + return Union[other, self] # type: ignore diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..b88dd8b2b19d7df9318674f5e016e837530c1843 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py @@ -0,0 +1,2306 @@ +"""Convert python types to pydantic-core schema.""" +from __future__ import annotations as _annotations + +import collections.abc +import dataclasses +import inspect +import re +import sys +import typing +import warnings +from contextlib import ExitStack, contextmanager +from copy import copy, deepcopy +from enum import Enum +from functools import partial +from inspect import Parameter, _ParameterKind, signature +from itertools import chain +from operator import attrgetter +from types import FunctionType, LambdaType, MethodType +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Dict, + Final, + ForwardRef, + Iterable, + Iterator, + Mapping, + Type, + TypeVar, + Union, + cast, + overload, +) +from warnings import warn + +from pydantic_core import CoreSchema, PydanticUndefined, core_schema, to_jsonable_python +from typing_extensions import Annotated, Literal, TypeAliasType, TypedDict, get_args, get_origin, is_typeddict + +from ..aliases import AliasGenerator +from ..annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler +from ..config import ConfigDict, JsonDict, JsonEncoder +from ..errors import PydanticSchemaGenerationError, PydanticUndefinedAnnotation, PydanticUserError +from ..json_schema import JsonSchemaValue +from ..version import version_short +from ..warnings import PydanticDeprecatedSince20 +from . import _core_utils, _decorators, _discriminated_union, _known_annotated_metadata, _typing_extra +from ._config import ConfigWrapper, ConfigWrapperStack +from ._core_metadata import CoreMetadataHandler, build_metadata_dict +from ._core_utils import ( + CoreSchemaOrField, + collect_invalid_schemas, + define_expected_missing_refs, + get_ref, + get_type_ref, + is_function_with_inner_schema, + is_list_like_schema_with_items_schema, + simplify_schema_references, + validate_core_schema, +) +from ._decorators import ( + Decorator, + DecoratorInfos, + FieldSerializerDecoratorInfo, + FieldValidatorDecoratorInfo, + ModelSerializerDecoratorInfo, + ModelValidatorDecoratorInfo, + RootValidatorDecoratorInfo, + ValidatorDecoratorInfo, + get_attribute_from_bases, + inspect_field_serializer, + inspect_model_serializer, + inspect_validator, +) +from ._docs_extraction import extract_docstrings_from_cls +from ._fields import collect_dataclass_fields, get_type_hints_infer_globalns +from ._forward_ref import PydanticRecursiveRef +from ._generics import get_standard_typevars_map, has_instance_in_type, recursively_defined_type_refs, replace_types +from ._schema_generation_shared import CallbackGetCoreSchemaHandler +from ._typing_extra import is_finalvar, is_self_type +from ._utils import lenient_issubclass + +if TYPE_CHECKING: + from ..fields import ComputedFieldInfo, FieldInfo + from ..main import BaseModel + from ..types import Discriminator + from ..validators import FieldValidatorModes + from ._dataclasses import StandardDataclass + from ._schema_generation_shared import GetJsonSchemaFunction + +_SUPPORTS_TYPEDDICT = sys.version_info >= (3, 12) +_AnnotatedType = type(Annotated[int, 123]) + +FieldDecoratorInfo = Union[ValidatorDecoratorInfo, FieldValidatorDecoratorInfo, FieldSerializerDecoratorInfo] +FieldDecoratorInfoType = TypeVar('FieldDecoratorInfoType', bound=FieldDecoratorInfo) +AnyFieldDecorator = Union[ + Decorator[ValidatorDecoratorInfo], + Decorator[FieldValidatorDecoratorInfo], + Decorator[FieldSerializerDecoratorInfo], +] + +ModifyCoreSchemaWrapHandler = GetCoreSchemaHandler +GetCoreSchemaFunction = Callable[[Any, ModifyCoreSchemaWrapHandler], core_schema.CoreSchema] + + +TUPLE_TYPES: list[type] = [tuple, typing.Tuple] +LIST_TYPES: list[type] = [list, typing.List, collections.abc.MutableSequence] +SET_TYPES: list[type] = [set, typing.Set, collections.abc.MutableSet] +FROZEN_SET_TYPES: list[type] = [frozenset, typing.FrozenSet, collections.abc.Set] +DICT_TYPES: list[type] = [dict, typing.Dict, collections.abc.MutableMapping, collections.abc.Mapping] + + +def check_validator_fields_against_field_name( + info: FieldDecoratorInfo, + field: str, +) -> bool: + """Check if field name is in validator fields. + + Args: + info: The field info. + field: The field name to check. + + Returns: + `True` if field name is in validator fields, `False` otherwise. + """ + if '*' in info.fields: + return True + for v_field_name in info.fields: + if v_field_name == field: + return True + return False + + +def check_decorator_fields_exist(decorators: Iterable[AnyFieldDecorator], fields: Iterable[str]) -> None: + """Check if the defined fields in decorators exist in `fields` param. + + It ignores the check for a decorator if the decorator has `*` as field or `check_fields=False`. + + Args: + decorators: An iterable of decorators. + fields: An iterable of fields name. + + Raises: + PydanticUserError: If one of the field names does not exist in `fields` param. + """ + fields = set(fields) + for dec in decorators: + if '*' in dec.info.fields: + continue + if dec.info.check_fields is False: + continue + for field in dec.info.fields: + if field not in fields: + raise PydanticUserError( + f'Decorators defined with incorrect fields: {dec.cls_ref}.{dec.cls_var_name}' + " (use check_fields=False if you're inheriting from the model and intended this)", + code='decorator-missing-field', + ) + + +def filter_field_decorator_info_by_field( + validator_functions: Iterable[Decorator[FieldDecoratorInfoType]], field: str +) -> list[Decorator[FieldDecoratorInfoType]]: + return [dec for dec in validator_functions if check_validator_fields_against_field_name(dec.info, field)] + + +def apply_each_item_validators( + schema: core_schema.CoreSchema, + each_item_validators: list[Decorator[ValidatorDecoratorInfo]], + field_name: str | None, +) -> core_schema.CoreSchema: + # This V1 compatibility shim should eventually be removed + + # push down any `each_item=True` validators + # note that this won't work for any Annotated types that get wrapped by a function validator + # but that's okay because that didn't exist in V1 + if schema['type'] == 'nullable': + schema['schema'] = apply_each_item_validators(schema['schema'], each_item_validators, field_name) + return schema + elif schema['type'] == 'tuple': + if (variadic_item_index := schema.get('variadic_item_index')) is not None: + schema['items_schema'][variadic_item_index] = apply_validators( + schema['items_schema'][variadic_item_index], each_item_validators, field_name + ) + elif is_list_like_schema_with_items_schema(schema): + inner_schema = schema.get('items_schema', None) + if inner_schema is None: + inner_schema = core_schema.any_schema() + schema['items_schema'] = apply_validators(inner_schema, each_item_validators, field_name) + elif schema['type'] == 'dict': + # push down any `each_item=True` validators onto dict _values_ + # this is super arbitrary but it's the V1 behavior + inner_schema = schema.get('values_schema', None) + if inner_schema is None: + inner_schema = core_schema.any_schema() + schema['values_schema'] = apply_validators(inner_schema, each_item_validators, field_name) + elif each_item_validators: + raise TypeError( + f"`@validator(..., each_item=True)` cannot be applied to fields with a schema of {schema['type']}" + ) + return schema + + +def modify_model_json_schema( + schema_or_field: CoreSchemaOrField, handler: GetJsonSchemaHandler, *, cls: Any +) -> JsonSchemaValue: + """Add title and description for model-like classes' JSON schema. + + Args: + schema_or_field: The schema data to generate a JSON schema from. + handler: The `GetCoreSchemaHandler` instance. + cls: The model-like class. + + Returns: + JsonSchemaValue: The updated JSON schema. + """ + from ..main import BaseModel + from ..root_model import RootModel + + json_schema = handler(schema_or_field) + original_schema = handler.resolve_ref_schema(json_schema) + # Preserve the fact that definitions schemas should never have sibling keys: + if '$ref' in original_schema: + ref = original_schema['$ref'] + original_schema.clear() + original_schema['allOf'] = [{'$ref': ref}] + if 'title' not in original_schema: + original_schema['title'] = cls.__name__ + # BaseModel; don't use cls.__doc__ as it will contain the verbose class signature by default + docstring = None if cls is BaseModel else cls.__doc__ + if docstring and 'description' not in original_schema: + original_schema['description'] = inspect.cleandoc(docstring) + elif issubclass(cls, RootModel) and cls.model_fields['root'].description: + original_schema['description'] = cls.model_fields['root'].description + return json_schema + + +JsonEncoders = Dict[Type[Any], JsonEncoder] + + +def _add_custom_serialization_from_json_encoders( + json_encoders: JsonEncoders | None, tp: Any, schema: CoreSchema +) -> CoreSchema: + """Iterate over the json_encoders and add the first matching encoder to the schema. + + Args: + json_encoders: A dictionary of types and their encoder functions. + tp: The type to check for a matching encoder. + schema: The schema to add the encoder to. + """ + if not json_encoders: + return schema + if 'serialization' in schema: + return schema + # Check the class type and its superclasses for a matching encoder + # Decimal.__class__.__mro__ (and probably other cases) doesn't include Decimal itself + # if the type is a GenericAlias (e.g. from list[int]) we need to use __class__ instead of .__mro__ + for base in (tp, *getattr(tp, '__mro__', tp.__class__.__mro__)[:-1]): + encoder = json_encoders.get(base) + if encoder is None: + continue + + warnings.warn( + f'`json_encoders` is deprecated. See https://docs.pydantic.dev/{version_short()}/concepts/serialization/#custom-serializers for alternatives', + PydanticDeprecatedSince20, + ) + + # TODO: in theory we should check that the schema accepts a serialization key + schema['serialization'] = core_schema.plain_serializer_function_ser_schema(encoder, when_used='json') + return schema + + return schema + + +TypesNamespace = Union[Dict[str, Any], None] + + +class TypesNamespaceStack: + """A stack of types namespaces.""" + + def __init__(self, types_namespace: TypesNamespace): + self._types_namespace_stack: list[TypesNamespace] = [types_namespace] + + @property + def tail(self) -> TypesNamespace: + return self._types_namespace_stack[-1] + + @contextmanager + def push(self, for_type: type[Any]): + types_namespace = {**_typing_extra.get_cls_types_namespace(for_type), **(self.tail or {})} + self._types_namespace_stack.append(types_namespace) + try: + yield + finally: + self._types_namespace_stack.pop() + + +def _get_first_non_null(a: Any, b: Any) -> Any: + """Return the first argument if it is not None, otherwise return the second argument. + + Use case: serialization_alias (argument a) and alias (argument b) are both defined, and serialization_alias is ''. + This function will return serialization_alias, which is the first argument, even though it is an empty string. + """ + return a if a is not None else b + + +class GenerateSchema: + """Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .""" + + __slots__ = ( + '_config_wrapper_stack', + '_types_namespace_stack', + '_typevars_map', + 'field_name_stack', + 'model_type_stack', + 'defs', + ) + + def __init__( + self, + config_wrapper: ConfigWrapper, + types_namespace: dict[str, Any] | None, + typevars_map: dict[Any, Any] | None = None, + ) -> None: + # we need a stack for recursing into child models + self._config_wrapper_stack = ConfigWrapperStack(config_wrapper) + self._types_namespace_stack = TypesNamespaceStack(types_namespace) + self._typevars_map = typevars_map + self.field_name_stack = _FieldNameStack() + self.model_type_stack = _ModelTypeStack() + self.defs = _Definitions() + + @classmethod + def __from_parent( + cls, + config_wrapper_stack: ConfigWrapperStack, + types_namespace_stack: TypesNamespaceStack, + model_type_stack: _ModelTypeStack, + typevars_map: dict[Any, Any] | None, + defs: _Definitions, + ) -> GenerateSchema: + obj = cls.__new__(cls) + obj._config_wrapper_stack = config_wrapper_stack + obj._types_namespace_stack = types_namespace_stack + obj.model_type_stack = model_type_stack + obj._typevars_map = typevars_map + obj.field_name_stack = _FieldNameStack() + obj.defs = defs + return obj + + @property + def _config_wrapper(self) -> ConfigWrapper: + return self._config_wrapper_stack.tail + + @property + def _types_namespace(self) -> dict[str, Any] | None: + return self._types_namespace_stack.tail + + @property + def _current_generate_schema(self) -> GenerateSchema: + cls = self._config_wrapper.schema_generator or GenerateSchema + return cls.__from_parent( + self._config_wrapper_stack, + self._types_namespace_stack, + self.model_type_stack, + self._typevars_map, + self.defs, + ) + + @property + def _arbitrary_types(self) -> bool: + return self._config_wrapper.arbitrary_types_allowed + + def str_schema(self) -> CoreSchema: + """Generate a CoreSchema for `str`""" + return core_schema.str_schema() + + # the following methods can be overridden but should be considered + # unstable / private APIs + def _list_schema(self, tp: Any, items_type: Any) -> CoreSchema: + return core_schema.list_schema(self.generate_schema(items_type)) + + def _dict_schema(self, tp: Any, keys_type: Any, values_type: Any) -> CoreSchema: + return core_schema.dict_schema(self.generate_schema(keys_type), self.generate_schema(values_type)) + + def _set_schema(self, tp: Any, items_type: Any) -> CoreSchema: + return core_schema.set_schema(self.generate_schema(items_type)) + + def _frozenset_schema(self, tp: Any, items_type: Any) -> CoreSchema: + return core_schema.frozenset_schema(self.generate_schema(items_type)) + + def _arbitrary_type_schema(self, tp: Any) -> CoreSchema: + if not isinstance(tp, type): + warn( + f'{tp!r} is not a Python type (it may be an instance of an object),' + ' Pydantic will allow any object with no validation since we cannot even' + ' enforce that the input is an instance of the given type.' + ' To get rid of this error wrap the type with `pydantic.SkipValidation`.', + UserWarning, + ) + return core_schema.any_schema() + return core_schema.is_instance_schema(tp) + + def _unknown_type_schema(self, obj: Any) -> CoreSchema: + raise PydanticSchemaGenerationError( + f'Unable to generate pydantic-core schema for {obj!r}. ' + 'Set `arbitrary_types_allowed=True` in the model_config to ignore this error' + ' or implement `__get_pydantic_core_schema__` on your type to fully support it.' + '\n\nIf you got this error by calling handler() within' + ' `__get_pydantic_core_schema__` then you likely need to call' + ' `handler.generate_schema()` since we do not call' + ' `__get_pydantic_core_schema__` on `` otherwise to avoid infinite recursion.' + ) + + def _apply_discriminator_to_union( + self, schema: CoreSchema, discriminator: str | Discriminator | None + ) -> CoreSchema: + if discriminator is None: + return schema + try: + return _discriminated_union.apply_discriminator( + schema, + discriminator, + ) + except _discriminated_union.MissingDefinitionForUnionRef: + # defer until defs are resolved + _discriminated_union.set_discriminator_in_metadata( + schema, + discriminator, + ) + return schema + + class CollectedInvalid(Exception): + pass + + def clean_schema(self, schema: CoreSchema) -> CoreSchema: + schema = self.collect_definitions(schema) + schema = simplify_schema_references(schema) + if collect_invalid_schemas(schema): + raise self.CollectedInvalid() + schema = _discriminated_union.apply_discriminators(schema) + schema = validate_core_schema(schema) + return schema + + def collect_definitions(self, schema: CoreSchema) -> CoreSchema: + ref = cast('str | None', schema.get('ref', None)) + if ref: + self.defs.definitions[ref] = schema + if 'ref' in schema: + schema = core_schema.definition_reference_schema(schema['ref']) + return core_schema.definitions_schema( + schema, + list(self.defs.definitions.values()), + ) + + def _add_js_function(self, metadata_schema: CoreSchema, js_function: Callable[..., Any]) -> None: + metadata = CoreMetadataHandler(metadata_schema).metadata + pydantic_js_functions = metadata.setdefault('pydantic_js_functions', []) + # because of how we generate core schemas for nested generic models + # we can end up adding `BaseModel.__get_pydantic_json_schema__` multiple times + # this check may fail to catch duplicates if the function is a `functools.partial` + # or something like that + # but if it does it'll fail by inserting the duplicate + if js_function not in pydantic_js_functions: + pydantic_js_functions.append(js_function) + + def generate_schema( + self, + obj: Any, + from_dunder_get_core_schema: bool = True, + ) -> core_schema.CoreSchema: + """Generate core schema. + + Args: + obj: The object to generate core schema for. + from_dunder_get_core_schema: Whether to generate schema from either the + `__get_pydantic_core_schema__` function or `__pydantic_core_schema__` property. + + Returns: + The generated core schema. + + Raises: + PydanticUndefinedAnnotation: + If it is not possible to evaluate forward reference. + PydanticSchemaGenerationError: + If it is not possible to generate pydantic-core schema. + TypeError: + - If `alias_generator` returns a disallowed type (must be str, AliasPath or AliasChoices). + - If V1 style validator with `each_item=True` applied on a wrong field. + PydanticUserError: + - If `typing.TypedDict` is used instead of `typing_extensions.TypedDict` on Python < 3.12. + - If `__modify_schema__` method is used instead of `__get_pydantic_json_schema__`. + """ + schema: CoreSchema | None = None + + if from_dunder_get_core_schema: + from_property = self._generate_schema_from_property(obj, obj) + if from_property is not None: + schema = from_property + + if schema is None: + schema = self._generate_schema_inner(obj) + + metadata_js_function = _extract_get_pydantic_json_schema(obj, schema) + if metadata_js_function is not None: + metadata_schema = resolve_original_schema(schema, self.defs.definitions) + if metadata_schema: + self._add_js_function(metadata_schema, metadata_js_function) + + schema = _add_custom_serialization_from_json_encoders(self._config_wrapper.json_encoders, obj, schema) + + return schema + + def _model_schema(self, cls: type[BaseModel]) -> core_schema.CoreSchema: + """Generate schema for a Pydantic model.""" + with self.defs.get_schema_or_ref(cls) as (model_ref, maybe_schema): + if maybe_schema is not None: + return maybe_schema + + fields = cls.model_fields + decorators = cls.__pydantic_decorators__ + computed_fields = decorators.computed_fields + check_decorator_fields_exist( + chain( + decorators.field_validators.values(), + decorators.field_serializers.values(), + decorators.validators.values(), + ), + {*fields.keys(), *computed_fields.keys()}, + ) + config_wrapper = ConfigWrapper(cls.model_config, check=False) + core_config = config_wrapper.core_config(cls) + metadata = build_metadata_dict(js_functions=[partial(modify_model_json_schema, cls=cls)]) + + model_validators = decorators.model_validators.values() + + extras_schema = None + if core_config.get('extra_fields_behavior') == 'allow': + assert cls.__mro__[0] is cls + assert cls.__mro__[-1] is object + for candidate_cls in cls.__mro__[:-1]: + extras_annotation = getattr(candidate_cls, '__annotations__', {}).get('__pydantic_extra__', None) + if extras_annotation is not None: + if isinstance(extras_annotation, str): + extras_annotation = _typing_extra.eval_type_backport( + _typing_extra._make_forward_ref(extras_annotation, is_argument=False, is_class=True), + self._types_namespace, + ) + tp = get_origin(extras_annotation) + if tp not in (Dict, dict): + raise PydanticSchemaGenerationError( + 'The type annotation for `__pydantic_extra__` must be `Dict[str, ...]`' + ) + extra_items_type = self._get_args_resolving_forward_refs( + extras_annotation, + required=True, + )[1] + if extra_items_type is not Any: + extras_schema = self.generate_schema(extra_items_type) + break + + with self._config_wrapper_stack.push(config_wrapper), self._types_namespace_stack.push(cls): + self = self._current_generate_schema + if cls.__pydantic_root_model__: + root_field = self._common_field_schema('root', fields['root'], decorators) + inner_schema = root_field['schema'] + inner_schema = apply_model_validators(inner_schema, model_validators, 'inner') + model_schema = core_schema.model_schema( + cls, + inner_schema, + custom_init=getattr(cls, '__pydantic_custom_init__', None), + root_model=True, + post_init=getattr(cls, '__pydantic_post_init__', None), + config=core_config, + ref=model_ref, + metadata=metadata, + ) + else: + fields_schema: core_schema.CoreSchema = core_schema.model_fields_schema( + {k: self._generate_md_field_schema(k, v, decorators) for k, v in fields.items()}, + computed_fields=[ + self._computed_field_schema(d, decorators.field_serializers) + for d in computed_fields.values() + ], + extras_schema=extras_schema, + model_name=cls.__name__, + ) + inner_schema = apply_validators(fields_schema, decorators.root_validators.values(), None) + new_inner_schema = define_expected_missing_refs(inner_schema, recursively_defined_type_refs()) + if new_inner_schema is not None: + inner_schema = new_inner_schema + inner_schema = apply_model_validators(inner_schema, model_validators, 'inner') + + model_schema = core_schema.model_schema( + cls, + inner_schema, + custom_init=getattr(cls, '__pydantic_custom_init__', None), + root_model=False, + post_init=getattr(cls, '__pydantic_post_init__', None), + config=core_config, + ref=model_ref, + metadata=metadata, + ) + + schema = self._apply_model_serializers(model_schema, decorators.model_serializers.values()) + schema = apply_model_validators(schema, model_validators, 'outer') + self.defs.definitions[model_ref] = schema + return core_schema.definition_reference_schema(model_ref) + + def _unpack_refs_defs(self, schema: CoreSchema) -> CoreSchema: + """Unpack all 'definitions' schemas into `GenerateSchema.defs.definitions` + and return the inner schema. + """ + + def get_ref(s: CoreSchema) -> str: + return s['ref'] # type: ignore + + if schema['type'] == 'definitions': + self.defs.definitions.update({get_ref(s): s for s in schema['definitions']}) + schema = schema['schema'] + return schema + + def _generate_schema_from_property(self, obj: Any, source: Any) -> core_schema.CoreSchema | None: + """Try to generate schema from either the `__get_pydantic_core_schema__` function or + `__pydantic_core_schema__` property. + + Note: `__get_pydantic_core_schema__` takes priority so it can + decide whether to use a `__pydantic_core_schema__` attribute, or generate a fresh schema. + """ + # avoid calling `__get_pydantic_core_schema__` if we've already visited this object + if is_self_type(obj): + obj = self.model_type_stack.get() + with self.defs.get_schema_or_ref(obj) as (_, maybe_schema): + if maybe_schema is not None: + return maybe_schema + if obj is source: + ref_mode = 'unpack' + else: + ref_mode = 'to-def' + + schema: CoreSchema + + if (get_schema := getattr(obj, '__get_pydantic_core_schema__', None)) is not None: + if len(inspect.signature(get_schema).parameters) == 1: + # (source) -> CoreSchema + schema = get_schema(source) + else: + schema = get_schema( + source, CallbackGetCoreSchemaHandler(self._generate_schema_inner, self, ref_mode=ref_mode) + ) + # fmt: off + elif (existing_schema := getattr(obj, '__pydantic_core_schema__', None)) is not None and existing_schema.get( + 'cls', None + ) == obj: + schema = existing_schema + # fmt: on + elif (validators := getattr(obj, '__get_validators__', None)) is not None: + warn( + '`__get_validators__` is deprecated and will be removed, use `__get_pydantic_core_schema__` instead.', + PydanticDeprecatedSince20, + ) + schema = core_schema.chain_schema([core_schema.with_info_plain_validator_function(v) for v in validators()]) + else: + # we have no existing schema information on the property, exit early so that we can go generate a schema + return None + + schema = self._unpack_refs_defs(schema) + + if is_function_with_inner_schema(schema): + ref = schema['schema'].pop('ref', None) # pyright: ignore[reportGeneralTypeIssues] + if ref: + schema['ref'] = ref + else: + ref = get_ref(schema) + + if ref: + self.defs.definitions[ref] = schema + return core_schema.definition_reference_schema(ref) + + return schema + + def _resolve_forward_ref(self, obj: Any) -> Any: + # we assume that types_namespace has the target of forward references in its scope, + # but this could fail, for example, if calling Validator on an imported type which contains + # forward references to other types only defined in the module from which it was imported + # `Validator(SomeImportedTypeAliasWithAForwardReference)` + # or the equivalent for BaseModel + # class Model(BaseModel): + # x: SomeImportedTypeAliasWithAForwardReference + try: + obj = _typing_extra.eval_type_backport(obj, globalns=self._types_namespace) + except NameError as e: + raise PydanticUndefinedAnnotation.from_name_error(e) from e + + # if obj is still a ForwardRef, it means we can't evaluate it, raise PydanticUndefinedAnnotation + if isinstance(obj, ForwardRef): + raise PydanticUndefinedAnnotation(obj.__forward_arg__, f'Unable to evaluate forward reference {obj}') + + if self._typevars_map: + obj = replace_types(obj, self._typevars_map) + + return obj + + @overload + def _get_args_resolving_forward_refs(self, obj: Any, required: Literal[True]) -> tuple[Any, ...]: + ... + + @overload + def _get_args_resolving_forward_refs(self, obj: Any) -> tuple[Any, ...] | None: + ... + + def _get_args_resolving_forward_refs(self, obj: Any, required: bool = False) -> tuple[Any, ...] | None: + args = get_args(obj) + if args: + args = tuple([self._resolve_forward_ref(a) if isinstance(a, ForwardRef) else a for a in args]) + elif required: # pragma: no cover + raise TypeError(f'Expected {obj} to have generic parameters but it had none') + return args + + def _get_first_arg_or_any(self, obj: Any) -> Any: + args = self._get_args_resolving_forward_refs(obj) + if not args: + return Any + return args[0] + + def _get_first_two_args_or_any(self, obj: Any) -> tuple[Any, Any]: + args = self._get_args_resolving_forward_refs(obj) + if not args: + return (Any, Any) + if len(args) < 2: + origin = get_origin(obj) + raise TypeError(f'Expected two type arguments for {origin}, got 1') + return args[0], args[1] + + def _generate_schema_inner(self, obj: Any) -> core_schema.CoreSchema: + if isinstance(obj, _AnnotatedType): + return self._annotated_schema(obj) + + if isinstance(obj, dict): + # we assume this is already a valid schema + return obj # type: ignore[return-value] + + if isinstance(obj, str): + obj = ForwardRef(obj) + + if isinstance(obj, ForwardRef): + return self.generate_schema(self._resolve_forward_ref(obj)) + + from ..main import BaseModel + + if lenient_issubclass(obj, BaseModel): + with self.model_type_stack.push(obj): + return self._model_schema(obj) + + if isinstance(obj, PydanticRecursiveRef): + return core_schema.definition_reference_schema(schema_ref=obj.type_ref) + + return self.match_type(obj) + + def match_type(self, obj: Any) -> core_schema.CoreSchema: # noqa: C901 + """Main mapping of types to schemas. + + The general structure is a series of if statements starting with the simple cases + (non-generic primitive types) and then handling generics and other more complex cases. + + Each case either generates a schema directly, calls into a public user-overridable method + (like `GenerateSchema.tuple_variable_schema`) or calls into a private method that handles some + boilerplate before calling into the user-facing method (e.g. `GenerateSchema._tuple_schema`). + + The idea is that we'll evolve this into adding more and more user facing methods over time + as they get requested and we figure out what the right API for them is. + """ + if obj is str: + return self.str_schema() + elif obj is bytes: + return core_schema.bytes_schema() + elif obj is int: + return core_schema.int_schema() + elif obj is float: + return core_schema.float_schema() + elif obj is bool: + return core_schema.bool_schema() + elif obj is Any or obj is object: + return core_schema.any_schema() + elif obj is None or obj is _typing_extra.NoneType: + return core_schema.none_schema() + elif obj in TUPLE_TYPES: + return self._tuple_schema(obj) + elif obj in LIST_TYPES: + return self._list_schema(obj, self._get_first_arg_or_any(obj)) + elif obj in SET_TYPES: + return self._set_schema(obj, self._get_first_arg_or_any(obj)) + elif obj in FROZEN_SET_TYPES: + return self._frozenset_schema(obj, self._get_first_arg_or_any(obj)) + elif obj in DICT_TYPES: + return self._dict_schema(obj, *self._get_first_two_args_or_any(obj)) + elif isinstance(obj, TypeAliasType): + return self._type_alias_type_schema(obj) + elif obj == type: + return self._type_schema() + elif _typing_extra.is_callable_type(obj): + return core_schema.callable_schema() + elif _typing_extra.is_literal_type(obj): + return self._literal_schema(obj) + elif is_typeddict(obj): + return self._typed_dict_schema(obj, None) + elif _typing_extra.is_namedtuple(obj): + return self._namedtuple_schema(obj, None) + elif _typing_extra.is_new_type(obj): + # NewType, can't use isinstance because it fails <3.10 + return self.generate_schema(obj.__supertype__) + elif obj == re.Pattern: + return self._pattern_schema(obj) + elif obj is collections.abc.Hashable or obj is typing.Hashable: + return self._hashable_schema() + elif isinstance(obj, typing.TypeVar): + return self._unsubstituted_typevar_schema(obj) + elif is_finalvar(obj): + if obj is Final: + return core_schema.any_schema() + return self.generate_schema( + self._get_first_arg_or_any(obj), + ) + elif isinstance(obj, (FunctionType, LambdaType, MethodType, partial)): + return self._callable_schema(obj) + elif inspect.isclass(obj) and issubclass(obj, Enum): + from ._std_types_schema import get_enum_core_schema + + return get_enum_core_schema(obj, self._config_wrapper.config_dict) + + if _typing_extra.is_dataclass(obj): + return self._dataclass_schema(obj, None) + res = self._get_prepare_pydantic_annotations_for_known_type(obj, ()) + if res is not None: + source_type, annotations = res + return self._apply_annotations(source_type, annotations) + + origin = get_origin(obj) + if origin is not None: + return self._match_generic_type(obj, origin) + + if self._arbitrary_types: + return self._arbitrary_type_schema(obj) + return self._unknown_type_schema(obj) + + def _match_generic_type(self, obj: Any, origin: Any) -> CoreSchema: # noqa: C901 + if isinstance(origin, TypeAliasType): + return self._type_alias_type_schema(obj) + + # Need to handle generic dataclasses before looking for the schema properties because attribute accesses + # on _GenericAlias delegate to the origin type, so lose the information about the concrete parametrization + # As a result, currently, there is no way to cache the schema for generic dataclasses. This may be possible + # to resolve by modifying the value returned by `Generic.__class_getitem__`, but that is a dangerous game. + if _typing_extra.is_dataclass(origin): + return self._dataclass_schema(obj, origin) + if _typing_extra.is_namedtuple(origin): + return self._namedtuple_schema(obj, origin) + + from_property = self._generate_schema_from_property(origin, obj) + if from_property is not None: + return from_property + + if _typing_extra.origin_is_union(origin): + return self._union_schema(obj) + elif origin in TUPLE_TYPES: + return self._tuple_schema(obj) + elif origin in LIST_TYPES: + return self._list_schema(obj, self._get_first_arg_or_any(obj)) + elif origin in SET_TYPES: + return self._set_schema(obj, self._get_first_arg_or_any(obj)) + elif origin in FROZEN_SET_TYPES: + return self._frozenset_schema(obj, self._get_first_arg_or_any(obj)) + elif origin in DICT_TYPES: + return self._dict_schema(obj, *self._get_first_two_args_or_any(obj)) + elif is_typeddict(origin): + return self._typed_dict_schema(obj, origin) + elif origin in (typing.Type, type): + return self._subclass_schema(obj) + elif origin in {typing.Sequence, collections.abc.Sequence}: + return self._sequence_schema(obj) + elif origin in {typing.Iterable, collections.abc.Iterable, typing.Generator, collections.abc.Generator}: + return self._iterable_schema(obj) + elif origin in (re.Pattern, typing.Pattern): + return self._pattern_schema(obj) + + if self._arbitrary_types: + return self._arbitrary_type_schema(origin) + return self._unknown_type_schema(obj) + + def _generate_td_field_schema( + self, + name: str, + field_info: FieldInfo, + decorators: DecoratorInfos, + *, + required: bool = True, + ) -> core_schema.TypedDictField: + """Prepare a TypedDictField to represent a model or typeddict field.""" + common_field = self._common_field_schema(name, field_info, decorators) + return core_schema.typed_dict_field( + common_field['schema'], + required=False if not field_info.is_required() else required, + serialization_exclude=common_field['serialization_exclude'], + validation_alias=common_field['validation_alias'], + serialization_alias=common_field['serialization_alias'], + metadata=common_field['metadata'], + ) + + def _generate_md_field_schema( + self, + name: str, + field_info: FieldInfo, + decorators: DecoratorInfos, + ) -> core_schema.ModelField: + """Prepare a ModelField to represent a model field.""" + common_field = self._common_field_schema(name, field_info, decorators) + return core_schema.model_field( + common_field['schema'], + serialization_exclude=common_field['serialization_exclude'], + validation_alias=common_field['validation_alias'], + serialization_alias=common_field['serialization_alias'], + frozen=common_field['frozen'], + metadata=common_field['metadata'], + ) + + def _generate_dc_field_schema( + self, + name: str, + field_info: FieldInfo, + decorators: DecoratorInfos, + ) -> core_schema.DataclassField: + """Prepare a DataclassField to represent the parameter/field, of a dataclass.""" + common_field = self._common_field_schema(name, field_info, decorators) + return core_schema.dataclass_field( + name, + common_field['schema'], + init=field_info.init, + init_only=field_info.init_var or None, + kw_only=None if field_info.kw_only else False, + serialization_exclude=common_field['serialization_exclude'], + validation_alias=common_field['validation_alias'], + serialization_alias=common_field['serialization_alias'], + frozen=common_field['frozen'], + metadata=common_field['metadata'], + ) + + @staticmethod + def _apply_alias_generator_to_field_info( + alias_generator: Callable[[str], str] | AliasGenerator, field_info: FieldInfo, field_name: str + ) -> None: + """Apply an alias_generator to aliases on a FieldInfo instance if appropriate. + + Args: + alias_generator: A callable that takes a string and returns a string, or an AliasGenerator instance. + field_info: The FieldInfo instance to which the alias_generator is (maybe) applied. + field_name: The name of the field from which to generate the alias. + """ + # Apply an alias_generator if + # 1. An alias is not specified + # 2. An alias is specified, but the priority is <= 1 + if ( + field_info.alias_priority is None + or field_info.alias_priority <= 1 + or field_info.alias is None + or field_info.validation_alias is None + or field_info.serialization_alias is None + ): + alias, validation_alias, serialization_alias = None, None, None + + if isinstance(alias_generator, AliasGenerator): + alias, validation_alias, serialization_alias = alias_generator.generate_aliases(field_name) + elif isinstance(alias_generator, Callable): + alias = alias_generator(field_name) + if not isinstance(alias, str): + raise TypeError(f'alias_generator {alias_generator} must return str, not {alias.__class__}') + + # if priority is not set, we set to 1 + # which supports the case where the alias_generator from a child class is used + # to generate an alias for a field in a parent class + if field_info.alias_priority is None or field_info.alias_priority <= 1: + field_info.alias_priority = 1 + + # if the priority is 1, then we set the aliases to the generated alias + if field_info.alias_priority == 1: + field_info.serialization_alias = _get_first_non_null(serialization_alias, alias) + field_info.validation_alias = _get_first_non_null(validation_alias, alias) + field_info.alias = alias + + # if any of the aliases are not set, then we set them to the corresponding generated alias + if field_info.alias is None: + field_info.alias = alias + if field_info.serialization_alias is None: + field_info.serialization_alias = _get_first_non_null(serialization_alias, alias) + if field_info.validation_alias is None: + field_info.validation_alias = _get_first_non_null(validation_alias, alias) + + @staticmethod + def _apply_alias_generator_to_computed_field_info( + alias_generator: Callable[[str], str] | AliasGenerator, + computed_field_info: ComputedFieldInfo, + computed_field_name: str, + ): + """Apply an alias_generator to alias on a ComputedFieldInfo instance if appropriate. + + Args: + alias_generator: A callable that takes a string and returns a string, or an AliasGenerator instance. + computed_field_info: The ComputedFieldInfo instance to which the alias_generator is (maybe) applied. + computed_field_name: The name of the computed field from which to generate the alias. + """ + # Apply an alias_generator if + # 1. An alias is not specified + # 2. An alias is specified, but the priority is <= 1 + + if ( + computed_field_info.alias_priority is None + or computed_field_info.alias_priority <= 1 + or computed_field_info.alias is None + ): + alias, validation_alias, serialization_alias = None, None, None + + if isinstance(alias_generator, AliasGenerator): + alias, validation_alias, serialization_alias = alias_generator.generate_aliases(computed_field_name) + elif isinstance(alias_generator, Callable): + alias = alias_generator(computed_field_name) + if not isinstance(alias, str): + raise TypeError(f'alias_generator {alias_generator} must return str, not {alias.__class__}') + + # if priority is not set, we set to 1 + # which supports the case where the alias_generator from a child class is used + # to generate an alias for a field in a parent class + if computed_field_info.alias_priority is None or computed_field_info.alias_priority <= 1: + computed_field_info.alias_priority = 1 + + # if the priority is 1, then we set the aliases to the generated alias + # note that we use the serialization_alias with priority over alias, as computed_field + # aliases are used for serialization only (not validation) + if computed_field_info.alias_priority == 1: + computed_field_info.alias = _get_first_non_null(serialization_alias, alias) + + def _common_field_schema( # C901 + self, name: str, field_info: FieldInfo, decorators: DecoratorInfos + ) -> _CommonField: + # Update FieldInfo annotation if appropriate: + from .. import AliasChoices, AliasPath + from ..fields import FieldInfo + + if has_instance_in_type(field_info.annotation, (ForwardRef, str)): + types_namespace = self._types_namespace + if self._typevars_map: + types_namespace = (types_namespace or {}).copy() + # Ensure that typevars get mapped to their concrete types: + types_namespace.update({k.__name__: v for k, v in self._typevars_map.items()}) + + evaluated = _typing_extra.eval_type_lenient(field_info.annotation, types_namespace) + if evaluated is not field_info.annotation and not has_instance_in_type(evaluated, PydanticRecursiveRef): + new_field_info = FieldInfo.from_annotation(evaluated) + field_info.annotation = new_field_info.annotation + + # Handle any field info attributes that may have been obtained from now-resolved annotations + for k, v in new_field_info._attributes_set.items(): + # If an attribute is already set, it means it was set by assigning to a call to Field (or just a + # default value), and that should take the highest priority. So don't overwrite existing attributes. + # We skip over "attributes" that are present in the metadata_lookup dict because these won't + # actually end up as attributes of the `FieldInfo` instance. + if k not in field_info._attributes_set and k not in field_info.metadata_lookup: + setattr(field_info, k, v) + + # Finally, ensure the field info also reflects all the `_attributes_set` that are actually metadata. + field_info.metadata = [*new_field_info.metadata, *field_info.metadata] + + source_type, annotations = field_info.annotation, field_info.metadata + + def set_discriminator(schema: CoreSchema) -> CoreSchema: + schema = self._apply_discriminator_to_union(schema, field_info.discriminator) + return schema + + with self.field_name_stack.push(name): + if field_info.discriminator is not None: + schema = self._apply_annotations(source_type, annotations, transform_inner_schema=set_discriminator) + else: + schema = self._apply_annotations( + source_type, + annotations, + ) + + # This V1 compatibility shim should eventually be removed + # push down any `each_item=True` validators + # note that this won't work for any Annotated types that get wrapped by a function validator + # but that's okay because that didn't exist in V1 + this_field_validators = filter_field_decorator_info_by_field(decorators.validators.values(), name) + if _validators_require_validate_default(this_field_validators): + field_info.validate_default = True + each_item_validators = [v for v in this_field_validators if v.info.each_item is True] + this_field_validators = [v for v in this_field_validators if v not in each_item_validators] + schema = apply_each_item_validators(schema, each_item_validators, name) + + schema = apply_validators(schema, filter_field_decorator_info_by_field(this_field_validators, name), name) + schema = apply_validators( + schema, filter_field_decorator_info_by_field(decorators.field_validators.values(), name), name + ) + + # the default validator needs to go outside of any other validators + # so that it is the topmost validator for the field validator + # which uses it to check if the field has a default value or not + if not field_info.is_required(): + schema = wrap_default(field_info, schema) + + schema = self._apply_field_serializers( + schema, filter_field_decorator_info_by_field(decorators.field_serializers.values(), name) + ) + json_schema_updates = { + 'title': field_info.title, + 'description': field_info.description, + 'deprecated': bool(field_info.deprecated) or field_info.deprecated == '' or None, + 'examples': to_jsonable_python(field_info.examples), + } + json_schema_updates = {k: v for k, v in json_schema_updates.items() if v is not None} + + json_schema_extra = field_info.json_schema_extra + + metadata = build_metadata_dict( + js_annotation_functions=[get_json_schema_update_func(json_schema_updates, json_schema_extra)] + ) + + alias_generator = self._config_wrapper.alias_generator + if alias_generator is not None: + self._apply_alias_generator_to_field_info(alias_generator, field_info, name) + + if isinstance(field_info.validation_alias, (AliasChoices, AliasPath)): + validation_alias = field_info.validation_alias.convert_to_aliases() + else: + validation_alias = field_info.validation_alias + + return _common_field( + schema, + serialization_exclude=True if field_info.exclude else None, + validation_alias=validation_alias, + serialization_alias=field_info.serialization_alias, + frozen=field_info.frozen, + metadata=metadata, + ) + + def _union_schema(self, union_type: Any) -> core_schema.CoreSchema: + """Generate schema for a Union.""" + args = self._get_args_resolving_forward_refs(union_type, required=True) + choices: list[CoreSchema] = [] + nullable = False + for arg in args: + if arg is None or arg is _typing_extra.NoneType: + nullable = True + else: + choices.append(self.generate_schema(arg)) + + if len(choices) == 1: + s = choices[0] + else: + choices_with_tags: list[CoreSchema | tuple[CoreSchema, str]] = [] + for choice in choices: + tag = choice.get('metadata', {}).get(_core_utils.TAGGED_UNION_TAG_KEY) + if tag is not None: + choices_with_tags.append((choice, tag)) + else: + choices_with_tags.append(choice) + s = core_schema.union_schema(choices_with_tags) + + if nullable: + s = core_schema.nullable_schema(s) + return s + + def _type_alias_type_schema( + self, + obj: Any, # TypeAliasType + ) -> CoreSchema: + with self.defs.get_schema_or_ref(obj) as (ref, maybe_schema): + if maybe_schema is not None: + return maybe_schema + + origin = get_origin(obj) or obj + + annotation = origin.__value__ + typevars_map = get_standard_typevars_map(obj) + + with self._types_namespace_stack.push(origin): + annotation = _typing_extra.eval_type_lenient(annotation, self._types_namespace) + annotation = replace_types(annotation, typevars_map) + schema = self.generate_schema(annotation) + assert schema['type'] != 'definitions' + schema['ref'] = ref # type: ignore + self.defs.definitions[ref] = schema + return core_schema.definition_reference_schema(ref) + + def _literal_schema(self, literal_type: Any) -> CoreSchema: + """Generate schema for a Literal.""" + expected = _typing_extra.all_literal_values(literal_type) + assert expected, f'literal "expected" cannot be empty, obj={literal_type}' + return core_schema.literal_schema(expected) + + def _typed_dict_schema(self, typed_dict_cls: Any, origin: Any) -> core_schema.CoreSchema: + """Generate schema for a TypedDict. + + It is not possible to track required/optional keys in TypedDict without __required_keys__ + since TypedDict.__new__ erases the base classes (it replaces them with just `dict`) + and thus we can track usage of total=True/False + __required_keys__ was added in Python 3.9 + (https://github.com/miss-islington/cpython/blob/1e9939657dd1f8eb9f596f77c1084d2d351172fc/Doc/library/typing.rst?plain=1#L1546-L1548) + however it is buggy + (https://github.com/python/typing_extensions/blob/ac52ac5f2cb0e00e7988bae1e2a1b8257ac88d6d/src/typing_extensions.py#L657-L666). + + On 3.11 but < 3.12 TypedDict does not preserve inheritance information. + + Hence to avoid creating validators that do not do what users expect we only + support typing.TypedDict on Python >= 3.12 or typing_extension.TypedDict on all versions + """ + from ..fields import FieldInfo + + with self.model_type_stack.push(typed_dict_cls), self.defs.get_schema_or_ref(typed_dict_cls) as ( + typed_dict_ref, + maybe_schema, + ): + if maybe_schema is not None: + return maybe_schema + + typevars_map = get_standard_typevars_map(typed_dict_cls) + if origin is not None: + typed_dict_cls = origin + + if not _SUPPORTS_TYPEDDICT and type(typed_dict_cls).__module__ == 'typing': + raise PydanticUserError( + 'Please use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.', + code='typed-dict-version', + ) + + try: + config: ConfigDict | None = get_attribute_from_bases(typed_dict_cls, '__pydantic_config__') + except AttributeError: + config = None + + with self._config_wrapper_stack.push(config), self._types_namespace_stack.push(typed_dict_cls): + core_config = self._config_wrapper.core_config(typed_dict_cls) + + self = self._current_generate_schema + + required_keys: frozenset[str] = typed_dict_cls.__required_keys__ + + fields: dict[str, core_schema.TypedDictField] = {} + + decorators = DecoratorInfos.build(typed_dict_cls) + + if self._config_wrapper.use_attribute_docstrings: + field_docstrings = extract_docstrings_from_cls(typed_dict_cls, use_inspect=True) + else: + field_docstrings = None + + for field_name, annotation in get_type_hints_infer_globalns( + typed_dict_cls, localns=self._types_namespace, include_extras=True + ).items(): + annotation = replace_types(annotation, typevars_map) + required = field_name in required_keys + + if get_origin(annotation) == _typing_extra.Required: + required = True + annotation = self._get_args_resolving_forward_refs( + annotation, + required=True, + )[0] + elif get_origin(annotation) == _typing_extra.NotRequired: + required = False + annotation = self._get_args_resolving_forward_refs( + annotation, + required=True, + )[0] + + field_info = FieldInfo.from_annotation(annotation) + if ( + field_docstrings is not None + and field_info.description is None + and field_name in field_docstrings + ): + field_info.description = field_docstrings[field_name] + fields[field_name] = self._generate_td_field_schema( + field_name, field_info, decorators, required=required + ) + + metadata = build_metadata_dict( + js_functions=[partial(modify_model_json_schema, cls=typed_dict_cls)], typed_dict_cls=typed_dict_cls + ) + + td_schema = core_schema.typed_dict_schema( + fields, + computed_fields=[ + self._computed_field_schema(d, decorators.field_serializers) + for d in decorators.computed_fields.values() + ], + ref=typed_dict_ref, + metadata=metadata, + config=core_config, + ) + + schema = self._apply_model_serializers(td_schema, decorators.model_serializers.values()) + schema = apply_model_validators(schema, decorators.model_validators.values(), 'all') + self.defs.definitions[typed_dict_ref] = schema + return core_schema.definition_reference_schema(typed_dict_ref) + + def _namedtuple_schema(self, namedtuple_cls: Any, origin: Any) -> core_schema.CoreSchema: + """Generate schema for a NamedTuple.""" + with self.model_type_stack.push(namedtuple_cls), self.defs.get_schema_or_ref(namedtuple_cls) as ( + namedtuple_ref, + maybe_schema, + ): + if maybe_schema is not None: + return maybe_schema + typevars_map = get_standard_typevars_map(namedtuple_cls) + if origin is not None: + namedtuple_cls = origin + + annotations: dict[str, Any] = get_type_hints_infer_globalns( + namedtuple_cls, include_extras=True, localns=self._types_namespace + ) + if not annotations: + # annotations is empty, happens if namedtuple_cls defined via collections.namedtuple(...) + annotations = {k: Any for k in namedtuple_cls._fields} + + if typevars_map: + annotations = { + field_name: replace_types(annotation, typevars_map) + for field_name, annotation in annotations.items() + } + + arguments_schema = core_schema.arguments_schema( + [ + self._generate_parameter_schema( + field_name, annotation, default=namedtuple_cls._field_defaults.get(field_name, Parameter.empty) + ) + for field_name, annotation in annotations.items() + ], + metadata=build_metadata_dict(js_prefer_positional_arguments=True), + ) + return core_schema.call_schema(arguments_schema, namedtuple_cls, ref=namedtuple_ref) + + def _generate_parameter_schema( + self, + name: str, + annotation: type[Any], + default: Any = Parameter.empty, + mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only'] | None = None, + ) -> core_schema.ArgumentsParameter: + """Prepare a ArgumentsParameter to represent a field in a namedtuple or function signature.""" + from ..fields import FieldInfo + + if default is Parameter.empty: + field = FieldInfo.from_annotation(annotation) + else: + field = FieldInfo.from_annotated_attribute(annotation, default) + assert field.annotation is not None, 'field.annotation should not be None when generating a schema' + source_type, annotations = field.annotation, field.metadata + with self.field_name_stack.push(name): + schema = self._apply_annotations(source_type, annotations) + + if not field.is_required(): + schema = wrap_default(field, schema) + + parameter_schema = core_schema.arguments_parameter(name, schema) + if mode is not None: + parameter_schema['mode'] = mode + if field.alias is not None: + parameter_schema['alias'] = field.alias + else: + alias_generator = self._config_wrapper.alias_generator + if isinstance(alias_generator, AliasGenerator) and alias_generator.alias is not None: + parameter_schema['alias'] = alias_generator.alias(name) + elif isinstance(alias_generator, Callable): + parameter_schema['alias'] = alias_generator(name) + return parameter_schema + + def _tuple_schema(self, tuple_type: Any) -> core_schema.CoreSchema: + """Generate schema for a Tuple, e.g. `tuple[int, str]` or `tuple[int, ...]`.""" + # TODO: do we really need to resolve type vars here? + typevars_map = get_standard_typevars_map(tuple_type) + params = self._get_args_resolving_forward_refs(tuple_type) + + if typevars_map and params: + params = tuple(replace_types(param, typevars_map) for param in params) + + # NOTE: subtle difference: `tuple[()]` gives `params=()`, whereas `typing.Tuple[()]` gives `params=((),)` + # This is only true for <3.11, on Python 3.11+ `typing.Tuple[()]` gives `params=()` + if not params: + if tuple_type in TUPLE_TYPES: + return core_schema.tuple_schema([core_schema.any_schema()], variadic_item_index=0) + else: + # special case for `tuple[()]` which means `tuple[]` - an empty tuple + return core_schema.tuple_schema([]) + elif params[-1] is Ellipsis: + if len(params) == 2: + return core_schema.tuple_schema([self.generate_schema(params[0])], variadic_item_index=0) + else: + # TODO: something like https://github.com/pydantic/pydantic/issues/5952 + raise ValueError('Variable tuples can only have one type') + elif len(params) == 1 and params[0] == (): + # special case for `Tuple[()]` which means `Tuple[]` - an empty tuple + # NOTE: This conditional can be removed when we drop support for Python 3.10. + return core_schema.tuple_schema([]) + else: + return core_schema.tuple_schema([self.generate_schema(param) for param in params]) + + def _type_schema(self) -> core_schema.CoreSchema: + return core_schema.custom_error_schema( + core_schema.is_instance_schema(type), + custom_error_type='is_type', + custom_error_message='Input should be a type', + ) + + def _union_is_subclass_schema(self, union_type: Any) -> core_schema.CoreSchema: + """Generate schema for `Type[Union[X, ...]]`.""" + args = self._get_args_resolving_forward_refs(union_type, required=True) + return core_schema.union_schema([self.generate_schema(typing.Type[args]) for args in args]) + + def _subclass_schema(self, type_: Any) -> core_schema.CoreSchema: + """Generate schema for a Type, e.g. `Type[int]`.""" + type_param = self._get_first_arg_or_any(type_) + if type_param == Any: + return self._type_schema() + elif isinstance(type_param, typing.TypeVar): + if type_param.__bound__: + if _typing_extra.origin_is_union(get_origin(type_param.__bound__)): + return self._union_is_subclass_schema(type_param.__bound__) + return core_schema.is_subclass_schema(type_param.__bound__) + elif type_param.__constraints__: + return core_schema.union_schema( + [self.generate_schema(typing.Type[c]) for c in type_param.__constraints__] + ) + else: + return self._type_schema() + elif _typing_extra.origin_is_union(get_origin(type_param)): + return self._union_is_subclass_schema(type_param) + else: + return core_schema.is_subclass_schema(type_param) + + def _sequence_schema(self, sequence_type: Any) -> core_schema.CoreSchema: + """Generate schema for a Sequence, e.g. `Sequence[int]`.""" + from ._std_types_schema import serialize_sequence_via_list + + item_type = self._get_first_arg_or_any(sequence_type) + item_type_schema = self.generate_schema(item_type) + list_schema = core_schema.list_schema(item_type_schema) + + python_schema = core_schema.is_instance_schema(typing.Sequence, cls_repr='Sequence') + if item_type != Any: + from ._validators import sequence_validator + + python_schema = core_schema.chain_schema( + [python_schema, core_schema.no_info_wrap_validator_function(sequence_validator, list_schema)], + ) + + serialization = core_schema.wrap_serializer_function_ser_schema( + serialize_sequence_via_list, schema=item_type_schema, info_arg=True + ) + return core_schema.json_or_python_schema( + json_schema=list_schema, python_schema=python_schema, serialization=serialization + ) + + def _iterable_schema(self, type_: Any) -> core_schema.GeneratorSchema: + """Generate a schema for an `Iterable`.""" + item_type = self._get_first_arg_or_any(type_) + + return core_schema.generator_schema(self.generate_schema(item_type)) + + def _pattern_schema(self, pattern_type: Any) -> core_schema.CoreSchema: + from . import _validators + + metadata = build_metadata_dict(js_functions=[lambda _1, _2: {'type': 'string', 'format': 'regex'}]) + ser = core_schema.plain_serializer_function_ser_schema( + attrgetter('pattern'), when_used='json', return_schema=core_schema.str_schema() + ) + if pattern_type == typing.Pattern or pattern_type == re.Pattern: + # bare type + return core_schema.no_info_plain_validator_function( + _validators.pattern_either_validator, serialization=ser, metadata=metadata + ) + + param = self._get_args_resolving_forward_refs( + pattern_type, + required=True, + )[0] + if param == str: + return core_schema.no_info_plain_validator_function( + _validators.pattern_str_validator, serialization=ser, metadata=metadata + ) + elif param == bytes: + return core_schema.no_info_plain_validator_function( + _validators.pattern_bytes_validator, serialization=ser, metadata=metadata + ) + else: + raise PydanticSchemaGenerationError(f'Unable to generate pydantic-core schema for {pattern_type!r}.') + + def _hashable_schema(self) -> core_schema.CoreSchema: + return core_schema.custom_error_schema( + core_schema.is_instance_schema(collections.abc.Hashable), + custom_error_type='is_hashable', + custom_error_message='Input should be hashable', + ) + + def _dataclass_schema( + self, dataclass: type[StandardDataclass], origin: type[StandardDataclass] | None + ) -> core_schema.CoreSchema: + """Generate schema for a dataclass.""" + with self.model_type_stack.push(dataclass), self.defs.get_schema_or_ref(dataclass) as ( + dataclass_ref, + maybe_schema, + ): + if maybe_schema is not None: + return maybe_schema + + typevars_map = get_standard_typevars_map(dataclass) + if origin is not None: + dataclass = origin + + with ExitStack() as dataclass_bases_stack: + # Pushing a namespace prioritises items already in the stack, so iterate though the MRO forwards + for dataclass_base in dataclass.__mro__: + if dataclasses.is_dataclass(dataclass_base): + dataclass_bases_stack.enter_context(self._types_namespace_stack.push(dataclass_base)) + + # Pushing a config overwrites the previous config, so iterate though the MRO backwards + for dataclass_base in reversed(dataclass.__mro__): + if dataclasses.is_dataclass(dataclass_base): + config = getattr(dataclass_base, '__pydantic_config__', None) + dataclass_bases_stack.enter_context(self._config_wrapper_stack.push(config)) + + core_config = self._config_wrapper.core_config(dataclass) + + self = self._current_generate_schema + + from ..dataclasses import is_pydantic_dataclass + + if is_pydantic_dataclass(dataclass): + fields = deepcopy(dataclass.__pydantic_fields__) + if typevars_map: + for field in fields.values(): + field.apply_typevars_map(typevars_map, self._types_namespace) + else: + fields = collect_dataclass_fields( + dataclass, + self._types_namespace, + typevars_map=typevars_map, + ) + + # disallow combination of init=False on a dataclass field and extra='allow' on a dataclass + if self._config_wrapper_stack.tail.extra == 'allow': + # disallow combination of init=False on a dataclass field and extra='allow' on a dataclass + for field_name, field in fields.items(): + if field.init is False: + raise PydanticUserError( + f'Field {field_name} has `init=False` and dataclass has config setting `extra="allow"`. ' + f'This combination is not allowed.', + code='dataclass-init-false-extra-allow', + ) + + decorators = dataclass.__dict__.get('__pydantic_decorators__') or DecoratorInfos.build(dataclass) + # Move kw_only=False args to the start of the list, as this is how vanilla dataclasses work. + # Note that when kw_only is missing or None, it is treated as equivalent to kw_only=True + args = sorted( + (self._generate_dc_field_schema(k, v, decorators) for k, v in fields.items()), + key=lambda a: a.get('kw_only') is not False, + ) + has_post_init = hasattr(dataclass, '__post_init__') + has_slots = hasattr(dataclass, '__slots__') + + args_schema = core_schema.dataclass_args_schema( + dataclass.__name__, + args, + computed_fields=[ + self._computed_field_schema(d, decorators.field_serializers) + for d in decorators.computed_fields.values() + ], + collect_init_only=has_post_init, + ) + + inner_schema = apply_validators(args_schema, decorators.root_validators.values(), None) + + model_validators = decorators.model_validators.values() + inner_schema = apply_model_validators(inner_schema, model_validators, 'inner') + + dc_schema = core_schema.dataclass_schema( + dataclass, + inner_schema, + post_init=has_post_init, + ref=dataclass_ref, + fields=[field.name for field in dataclasses.fields(dataclass)], + slots=has_slots, + config=core_config, + ) + schema = self._apply_model_serializers(dc_schema, decorators.model_serializers.values()) + schema = apply_model_validators(schema, model_validators, 'outer') + self.defs.definitions[dataclass_ref] = schema + return core_schema.definition_reference_schema(dataclass_ref) + + # Type checkers seem to assume ExitStack may suppress exceptions and therefore + # control flow can exit the `with` block without returning. + assert False, 'Unreachable' + + def _callable_schema(self, function: Callable[..., Any]) -> core_schema.CallSchema: + """Generate schema for a Callable. + + TODO support functional validators once we support them in Config + """ + sig = signature(function) + + type_hints = _typing_extra.get_function_type_hints(function) + + mode_lookup: dict[_ParameterKind, Literal['positional_only', 'positional_or_keyword', 'keyword_only']] = { + Parameter.POSITIONAL_ONLY: 'positional_only', + Parameter.POSITIONAL_OR_KEYWORD: 'positional_or_keyword', + Parameter.KEYWORD_ONLY: 'keyword_only', + } + + arguments_list: list[core_schema.ArgumentsParameter] = [] + var_args_schema: core_schema.CoreSchema | None = None + var_kwargs_schema: core_schema.CoreSchema | None = None + + for name, p in sig.parameters.items(): + if p.annotation is sig.empty: + annotation = Any + else: + annotation = type_hints[name] + + parameter_mode = mode_lookup.get(p.kind) + if parameter_mode is not None: + arg_schema = self._generate_parameter_schema(name, annotation, p.default, parameter_mode) + arguments_list.append(arg_schema) + elif p.kind == Parameter.VAR_POSITIONAL: + var_args_schema = self.generate_schema(annotation) + else: + assert p.kind == Parameter.VAR_KEYWORD, p.kind + var_kwargs_schema = self.generate_schema(annotation) + + return_schema: core_schema.CoreSchema | None = None + config_wrapper = self._config_wrapper + if config_wrapper.validate_return: + return_hint = type_hints.get('return') + if return_hint is not None: + return_schema = self.generate_schema(return_hint) + + return core_schema.call_schema( + core_schema.arguments_schema( + arguments_list, + var_args_schema=var_args_schema, + var_kwargs_schema=var_kwargs_schema, + populate_by_name=config_wrapper.populate_by_name, + ), + function, + return_schema=return_schema, + ) + + def _unsubstituted_typevar_schema(self, typevar: typing.TypeVar) -> core_schema.CoreSchema: + assert isinstance(typevar, typing.TypeVar) + + bound = typevar.__bound__ + constraints = typevar.__constraints__ + default = getattr(typevar, '__default__', None) + + if (bound is not None) + (len(constraints) != 0) + (default is not None) > 1: + raise NotImplementedError( + 'Pydantic does not support mixing more than one of TypeVar bounds, constraints and defaults' + ) + + if default is not None: + return self.generate_schema(default) + elif constraints: + return self._union_schema(typing.Union[constraints]) # type: ignore + elif bound: + schema = self.generate_schema(bound) + schema['serialization'] = core_schema.wrap_serializer_function_ser_schema( + lambda x, h: h(x), schema=core_schema.any_schema() + ) + return schema + else: + return core_schema.any_schema() + + def _computed_field_schema( + self, + d: Decorator[ComputedFieldInfo], + field_serializers: dict[str, Decorator[FieldSerializerDecoratorInfo]], + ) -> core_schema.ComputedField: + try: + return_type = _decorators.get_function_return_type(d.func, d.info.return_type, self._types_namespace) + except NameError as e: + raise PydanticUndefinedAnnotation.from_name_error(e) from e + if return_type is PydanticUndefined: + raise PydanticUserError( + 'Computed field is missing return type annotation or specifying `return_type`' + ' to the `@computed_field` decorator (e.g. `@computed_field(return_type=int|str)`)', + code='model-field-missing-annotation', + ) + + return_type = replace_types(return_type, self._typevars_map) + # Create a new ComputedFieldInfo so that different type parametrizations of the same + # generic model's computed field can have different return types. + d.info = dataclasses.replace(d.info, return_type=return_type) + return_type_schema = self.generate_schema(return_type) + # Apply serializers to computed field if there exist + return_type_schema = self._apply_field_serializers( + return_type_schema, + filter_field_decorator_info_by_field(field_serializers.values(), d.cls_var_name), + computed_field=True, + ) + + alias_generator = self._config_wrapper.alias_generator + if alias_generator is not None: + self._apply_alias_generator_to_computed_field_info( + alias_generator=alias_generator, computed_field_info=d.info, computed_field_name=d.cls_var_name + ) + + def set_computed_field_metadata(schema: CoreSchemaOrField, handler: GetJsonSchemaHandler) -> JsonSchemaValue: + json_schema = handler(schema) + + json_schema['readOnly'] = True + + title = d.info.title + if title is not None: + json_schema['title'] = title + + description = d.info.description + if description is not None: + json_schema['description'] = description + + if d.info.deprecated or d.info.deprecated == '': + json_schema['deprecated'] = True + + examples = d.info.examples + if examples is not None: + json_schema['examples'] = to_jsonable_python(examples) + + json_schema_extra = d.info.json_schema_extra + if json_schema_extra is not None: + add_json_schema_extra(json_schema, json_schema_extra) + + return json_schema + + metadata = build_metadata_dict(js_annotation_functions=[set_computed_field_metadata]) + return core_schema.computed_field( + d.cls_var_name, return_schema=return_type_schema, alias=d.info.alias, metadata=metadata + ) + + def _annotated_schema(self, annotated_type: Any) -> core_schema.CoreSchema: + """Generate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.""" + from ..fields import FieldInfo + + source_type, *annotations = self._get_args_resolving_forward_refs( + annotated_type, + required=True, + ) + schema = self._apply_annotations(source_type, annotations) + # put the default validator last so that TypeAdapter.get_default_value() works + # even if there are function validators involved + for annotation in annotations: + if isinstance(annotation, FieldInfo): + schema = wrap_default(annotation, schema) + return schema + + def _get_prepare_pydantic_annotations_for_known_type( + self, obj: Any, annotations: tuple[Any, ...] + ) -> tuple[Any, list[Any]] | None: + from ._std_types_schema import PREPARE_METHODS + + # Check for hashability + try: + hash(obj) + except TypeError: + # obj is definitely not a known type if this fails + return None + + for gen in PREPARE_METHODS: + res = gen(obj, annotations, self._config_wrapper.config_dict) + if res is not None: + return res + + return None + + def _apply_annotations( + self, + source_type: Any, + annotations: list[Any], + transform_inner_schema: Callable[[CoreSchema], CoreSchema] = lambda x: x, + ) -> CoreSchema: + """Apply arguments from `Annotated` or from `FieldInfo` to a schema. + + This gets called by `GenerateSchema._annotated_schema` but differs from it in that it does + not expect `source_type` to be an `Annotated` object, it expects it to be the first argument of that + (in other words, `GenerateSchema._annotated_schema` just unpacks `Annotated`, this process it). + """ + annotations = list(_known_annotated_metadata.expand_grouped_metadata(annotations)) + res = self._get_prepare_pydantic_annotations_for_known_type(source_type, tuple(annotations)) + if res is not None: + source_type, annotations = res + + pydantic_js_annotation_functions: list[GetJsonSchemaFunction] = [] + + def inner_handler(obj: Any) -> CoreSchema: + from_property = self._generate_schema_from_property(obj, obj) + if from_property is None: + schema = self._generate_schema_inner(obj) + else: + schema = from_property + metadata_js_function = _extract_get_pydantic_json_schema(obj, schema) + if metadata_js_function is not None: + metadata_schema = resolve_original_schema(schema, self.defs.definitions) + if metadata_schema is not None: + self._add_js_function(metadata_schema, metadata_js_function) + return transform_inner_schema(schema) + + get_inner_schema = CallbackGetCoreSchemaHandler(inner_handler, self) + + for annotation in annotations: + if annotation is None: + continue + get_inner_schema = self._get_wrapped_inner_schema( + get_inner_schema, annotation, pydantic_js_annotation_functions + ) + + schema = get_inner_schema(source_type) + if pydantic_js_annotation_functions: + metadata = CoreMetadataHandler(schema).metadata + metadata.setdefault('pydantic_js_annotation_functions', []).extend(pydantic_js_annotation_functions) + return _add_custom_serialization_from_json_encoders(self._config_wrapper.json_encoders, source_type, schema) + + def _apply_single_annotation(self, schema: core_schema.CoreSchema, metadata: Any) -> core_schema.CoreSchema: + from ..fields import FieldInfo + + if isinstance(metadata, FieldInfo): + for field_metadata in metadata.metadata: + schema = self._apply_single_annotation(schema, field_metadata) + + if metadata.discriminator is not None: + schema = self._apply_discriminator_to_union(schema, metadata.discriminator) + return schema + + if schema['type'] == 'nullable': + # for nullable schemas, metadata is automatically applied to the inner schema + inner = schema.get('schema', core_schema.any_schema()) + inner = self._apply_single_annotation(inner, metadata) + if inner: + schema['schema'] = inner + return schema + + original_schema = schema + ref = schema.get('ref', None) + if ref is not None: + schema = schema.copy() + new_ref = ref + f'_{repr(metadata)}' + if new_ref in self.defs.definitions: + return self.defs.definitions[new_ref] + schema['ref'] = new_ref # type: ignore + elif schema['type'] == 'definition-ref': + ref = schema['schema_ref'] + if ref in self.defs.definitions: + schema = self.defs.definitions[ref].copy() + new_ref = ref + f'_{repr(metadata)}' + if new_ref in self.defs.definitions: + return self.defs.definitions[new_ref] + schema['ref'] = new_ref # type: ignore + + maybe_updated_schema = _known_annotated_metadata.apply_known_metadata(metadata, schema.copy()) + + if maybe_updated_schema is not None: + return maybe_updated_schema + return original_schema + + def _apply_single_annotation_json_schema( + self, schema: core_schema.CoreSchema, metadata: Any + ) -> core_schema.CoreSchema: + from ..fields import FieldInfo + + if isinstance(metadata, FieldInfo): + for field_metadata in metadata.metadata: + schema = self._apply_single_annotation_json_schema(schema, field_metadata) + json_schema_update: JsonSchemaValue = {} + if metadata.title: + json_schema_update['title'] = metadata.title + if metadata.description: + json_schema_update['description'] = metadata.description + if metadata.examples: + json_schema_update['examples'] = to_jsonable_python(metadata.examples) + + json_schema_extra = metadata.json_schema_extra + if json_schema_update or json_schema_extra: + CoreMetadataHandler(schema).metadata.setdefault('pydantic_js_annotation_functions', []).append( + get_json_schema_update_func(json_schema_update, json_schema_extra) + ) + return schema + + def _get_wrapped_inner_schema( + self, + get_inner_schema: GetCoreSchemaHandler, + annotation: Any, + pydantic_js_annotation_functions: list[GetJsonSchemaFunction], + ) -> CallbackGetCoreSchemaHandler: + metadata_get_schema: GetCoreSchemaFunction = getattr(annotation, '__get_pydantic_core_schema__', None) or ( + lambda source, handler: handler(source) + ) + + def new_handler(source: Any) -> core_schema.CoreSchema: + schema = metadata_get_schema(source, get_inner_schema) + schema = self._apply_single_annotation(schema, annotation) + schema = self._apply_single_annotation_json_schema(schema, annotation) + + metadata_js_function = _extract_get_pydantic_json_schema(annotation, schema) + if metadata_js_function is not None: + pydantic_js_annotation_functions.append(metadata_js_function) + return schema + + return CallbackGetCoreSchemaHandler(new_handler, self) + + def _apply_field_serializers( + self, + schema: core_schema.CoreSchema, + serializers: list[Decorator[FieldSerializerDecoratorInfo]], + computed_field: bool = False, + ) -> core_schema.CoreSchema: + """Apply field serializers to a schema.""" + if serializers: + schema = copy(schema) + if schema['type'] == 'definitions': + inner_schema = schema['schema'] + schema['schema'] = self._apply_field_serializers(inner_schema, serializers) + return schema + else: + ref = typing.cast('str|None', schema.get('ref', None)) + if ref is not None: + schema = core_schema.definition_reference_schema(ref) + + # use the last serializer to make it easy to override a serializer set on a parent model + serializer = serializers[-1] + is_field_serializer, info_arg = inspect_field_serializer( + serializer.func, serializer.info.mode, computed_field=computed_field + ) + + try: + return_type = _decorators.get_function_return_type( + serializer.func, serializer.info.return_type, self._types_namespace + ) + except NameError as e: + raise PydanticUndefinedAnnotation.from_name_error(e) from e + + if return_type is PydanticUndefined: + return_schema = None + else: + return_schema = self.generate_schema(return_type) + + if serializer.info.mode == 'wrap': + schema['serialization'] = core_schema.wrap_serializer_function_ser_schema( + serializer.func, + is_field_serializer=is_field_serializer, + info_arg=info_arg, + return_schema=return_schema, + when_used=serializer.info.when_used, + ) + else: + assert serializer.info.mode == 'plain' + schema['serialization'] = core_schema.plain_serializer_function_ser_schema( + serializer.func, + is_field_serializer=is_field_serializer, + info_arg=info_arg, + return_schema=return_schema, + when_used=serializer.info.when_used, + ) + return schema + + def _apply_model_serializers( + self, schema: core_schema.CoreSchema, serializers: Iterable[Decorator[ModelSerializerDecoratorInfo]] + ) -> core_schema.CoreSchema: + """Apply model serializers to a schema.""" + ref: str | None = schema.pop('ref', None) # type: ignore + if serializers: + serializer = list(serializers)[-1] + info_arg = inspect_model_serializer(serializer.func, serializer.info.mode) + + try: + return_type = _decorators.get_function_return_type( + serializer.func, serializer.info.return_type, self._types_namespace + ) + except NameError as e: + raise PydanticUndefinedAnnotation.from_name_error(e) from e + if return_type is PydanticUndefined: + return_schema = None + else: + return_schema = self.generate_schema(return_type) + + if serializer.info.mode == 'wrap': + ser_schema: core_schema.SerSchema = core_schema.wrap_serializer_function_ser_schema( + serializer.func, + info_arg=info_arg, + return_schema=return_schema, + when_used=serializer.info.when_used, + ) + else: + # plain + ser_schema = core_schema.plain_serializer_function_ser_schema( + serializer.func, + info_arg=info_arg, + return_schema=return_schema, + when_used=serializer.info.when_used, + ) + schema['serialization'] = ser_schema + if ref: + schema['ref'] = ref # type: ignore + return schema + + +_VALIDATOR_F_MATCH: Mapping[ + tuple[FieldValidatorModes, Literal['no-info', 'with-info']], + Callable[[Callable[..., Any], core_schema.CoreSchema, str | None], core_schema.CoreSchema], +] = { + ('before', 'no-info'): lambda f, schema, _: core_schema.no_info_before_validator_function(f, schema), + ('after', 'no-info'): lambda f, schema, _: core_schema.no_info_after_validator_function(f, schema), + ('plain', 'no-info'): lambda f, _1, _2: core_schema.no_info_plain_validator_function(f), + ('wrap', 'no-info'): lambda f, schema, _: core_schema.no_info_wrap_validator_function(f, schema), + ('before', 'with-info'): lambda f, schema, field_name: core_schema.with_info_before_validator_function( + f, schema, field_name=field_name + ), + ('after', 'with-info'): lambda f, schema, field_name: core_schema.with_info_after_validator_function( + f, schema, field_name=field_name + ), + ('plain', 'with-info'): lambda f, _, field_name: core_schema.with_info_plain_validator_function( + f, field_name=field_name + ), + ('wrap', 'with-info'): lambda f, schema, field_name: core_schema.with_info_wrap_validator_function( + f, schema, field_name=field_name + ), +} + + +def apply_validators( + schema: core_schema.CoreSchema, + validators: Iterable[Decorator[RootValidatorDecoratorInfo]] + | Iterable[Decorator[ValidatorDecoratorInfo]] + | Iterable[Decorator[FieldValidatorDecoratorInfo]], + field_name: str | None, +) -> core_schema.CoreSchema: + """Apply validators to a schema. + + Args: + schema: The schema to apply validators on. + validators: An iterable of validators. + field_name: The name of the field if validators are being applied to a model field. + + Returns: + The updated schema. + """ + for validator in validators: + info_arg = inspect_validator(validator.func, validator.info.mode) + val_type = 'with-info' if info_arg else 'no-info' + + schema = _VALIDATOR_F_MATCH[(validator.info.mode, val_type)](validator.func, schema, field_name) + return schema + + +def _validators_require_validate_default(validators: Iterable[Decorator[ValidatorDecoratorInfo]]) -> bool: + """In v1, if any of the validators for a field had `always=True`, the default value would be validated. + + This serves as an auxiliary function for re-implementing that logic, by looping over a provided + collection of (v1-style) ValidatorDecoratorInfo's and checking if any of them have `always=True`. + + We should be able to drop this function and the associated logic calling it once we drop support + for v1-style validator decorators. (Or we can extend it and keep it if we add something equivalent + to the v1-validator `always` kwarg to `field_validator`.) + """ + for validator in validators: + if validator.info.always: + return True + return False + + +def apply_model_validators( + schema: core_schema.CoreSchema, + validators: Iterable[Decorator[ModelValidatorDecoratorInfo]], + mode: Literal['inner', 'outer', 'all'], +) -> core_schema.CoreSchema: + """Apply model validators to a schema. + + If mode == 'inner', only "before" validators are applied + If mode == 'outer', validators other than "before" are applied + If mode == 'all', all validators are applied + + Args: + schema: The schema to apply validators on. + validators: An iterable of validators. + mode: The validator mode. + + Returns: + The updated schema. + """ + ref: str | None = schema.pop('ref', None) # type: ignore + for validator in validators: + if mode == 'inner' and validator.info.mode != 'before': + continue + if mode == 'outer' and validator.info.mode == 'before': + continue + info_arg = inspect_validator(validator.func, validator.info.mode) + if validator.info.mode == 'wrap': + if info_arg: + schema = core_schema.with_info_wrap_validator_function(function=validator.func, schema=schema) + else: + schema = core_schema.no_info_wrap_validator_function(function=validator.func, schema=schema) + elif validator.info.mode == 'before': + if info_arg: + schema = core_schema.with_info_before_validator_function(function=validator.func, schema=schema) + else: + schema = core_schema.no_info_before_validator_function(function=validator.func, schema=schema) + else: + assert validator.info.mode == 'after' + if info_arg: + schema = core_schema.with_info_after_validator_function(function=validator.func, schema=schema) + else: + schema = core_schema.no_info_after_validator_function(function=validator.func, schema=schema) + if ref: + schema['ref'] = ref # type: ignore + return schema + + +def wrap_default(field_info: FieldInfo, schema: core_schema.CoreSchema) -> core_schema.CoreSchema: + """Wrap schema with default schema if default value or `default_factory` are available. + + Args: + field_info: The field info object. + schema: The schema to apply default on. + + Returns: + Updated schema by default value or `default_factory`. + """ + if field_info.default_factory: + return core_schema.with_default_schema( + schema, default_factory=field_info.default_factory, validate_default=field_info.validate_default + ) + elif field_info.default is not PydanticUndefined: + return core_schema.with_default_schema( + schema, default=field_info.default, validate_default=field_info.validate_default + ) + else: + return schema + + +def _extract_get_pydantic_json_schema(tp: Any, schema: CoreSchema) -> GetJsonSchemaFunction | None: + """Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.""" + js_modify_function = getattr(tp, '__get_pydantic_json_schema__', None) + + if hasattr(tp, '__modify_schema__'): + from pydantic import BaseModel # circular reference + + has_custom_v2_modify_js_func = ( + js_modify_function is not None + and BaseModel.__get_pydantic_json_schema__.__func__ # type: ignore + not in (js_modify_function, getattr(js_modify_function, '__func__', None)) + ) + + if not has_custom_v2_modify_js_func: + cls_name = getattr(tp, '__name__', None) + raise PydanticUserError( + f'The `__modify_schema__` method is not supported in Pydantic v2. ' + f'Use `__get_pydantic_json_schema__` instead{f" in class `{cls_name}`" if cls_name else ""}.', + code='custom-json-schema', + ) + + # handle GenericAlias' but ignore Annotated which "lies" about its origin (in this case it would be `int`) + if hasattr(tp, '__origin__') and not isinstance(tp, type(Annotated[int, 'placeholder'])): + return _extract_get_pydantic_json_schema(tp.__origin__, schema) + + if js_modify_function is None: + return None + + return js_modify_function + + +def get_json_schema_update_func( + json_schema_update: JsonSchemaValue, json_schema_extra: JsonDict | typing.Callable[[JsonDict], None] | None +) -> GetJsonSchemaFunction: + def json_schema_update_func( + core_schema_or_field: CoreSchemaOrField, handler: GetJsonSchemaHandler + ) -> JsonSchemaValue: + json_schema = {**handler(core_schema_or_field), **json_schema_update} + add_json_schema_extra(json_schema, json_schema_extra) + return json_schema + + return json_schema_update_func + + +def add_json_schema_extra( + json_schema: JsonSchemaValue, json_schema_extra: JsonDict | typing.Callable[[JsonDict], None] | None +): + if isinstance(json_schema_extra, dict): + json_schema.update(to_jsonable_python(json_schema_extra)) + elif callable(json_schema_extra): + json_schema_extra(json_schema) + + +class _CommonField(TypedDict): + schema: core_schema.CoreSchema + validation_alias: str | list[str | int] | list[list[str | int]] | None + serialization_alias: str | None + serialization_exclude: bool | None + frozen: bool | None + metadata: dict[str, Any] + + +def _common_field( + schema: core_schema.CoreSchema, + *, + validation_alias: str | list[str | int] | list[list[str | int]] | None = None, + serialization_alias: str | None = None, + serialization_exclude: bool | None = None, + frozen: bool | None = None, + metadata: Any = None, +) -> _CommonField: + return { + 'schema': schema, + 'validation_alias': validation_alias, + 'serialization_alias': serialization_alias, + 'serialization_exclude': serialization_exclude, + 'frozen': frozen, + 'metadata': metadata, + } + + +class _Definitions: + """Keeps track of references and definitions.""" + + def __init__(self) -> None: + self.seen: set[str] = set() + self.definitions: dict[str, core_schema.CoreSchema] = {} + + @contextmanager + def get_schema_or_ref(self, tp: Any) -> Iterator[tuple[str, None] | tuple[str, CoreSchema]]: + """Get a definition for `tp` if one exists. + + If a definition exists, a tuple of `(ref_string, CoreSchema)` is returned. + If no definition exists yet, a tuple of `(ref_string, None)` is returned. + + Note that the returned `CoreSchema` will always be a `DefinitionReferenceSchema`, + not the actual definition itself. + + This should be called for any type that can be identified by reference. + This includes any recursive types. + + At present the following types can be named/recursive: + + - BaseModel + - Dataclasses + - TypedDict + - TypeAliasType + """ + ref = get_type_ref(tp) + # return the reference if we're either (1) in a cycle or (2) it was already defined + if ref in self.seen or ref in self.definitions: + yield (ref, core_schema.definition_reference_schema(ref)) + else: + self.seen.add(ref) + try: + yield (ref, None) + finally: + self.seen.discard(ref) + + +def resolve_original_schema(schema: CoreSchema, definitions: dict[str, CoreSchema]) -> CoreSchema | None: + if schema['type'] == 'definition-ref': + return definitions.get(schema['schema_ref'], None) + elif schema['type'] == 'definitions': + return schema['schema'] + else: + return schema + + +class _FieldNameStack: + __slots__ = ('_stack',) + + def __init__(self) -> None: + self._stack: list[str] = [] + + @contextmanager + def push(self, field_name: str) -> Iterator[None]: + self._stack.append(field_name) + yield + self._stack.pop() + + def get(self) -> str | None: + if self._stack: + return self._stack[-1] + else: + return None + + +class _ModelTypeStack: + __slots__ = ('_stack',) + + def __init__(self) -> None: + self._stack: list[type] = [] + + @contextmanager + def push(self, type_obj: type) -> Iterator[None]: + self._stack.append(type_obj) + yield + self._stack.pop() + + def get(self) -> type | None: + if self._stack: + return self._stack[-1] + else: + return None diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_generics.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_generics.py new file mode 100644 index 0000000000000000000000000000000000000000..a24763a07ba556273b32e9314c5c1a2e11d30715 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_generics.py @@ -0,0 +1,517 @@ +from __future__ import annotations + +import sys +import types +import typing +from collections import ChainMap +from contextlib import contextmanager +from contextvars import ContextVar +from types import prepare_class +from typing import TYPE_CHECKING, Any, Iterator, List, Mapping, MutableMapping, Tuple, TypeVar +from weakref import WeakValueDictionary + +import typing_extensions + +from ._core_utils import get_type_ref +from ._forward_ref import PydanticRecursiveRef +from ._typing_extra import TypeVarType, typing_base +from ._utils import all_identical, is_model_class + +if sys.version_info >= (3, 10): + from typing import _UnionGenericAlias # type: ignore[attr-defined] + +if TYPE_CHECKING: + from ..main import BaseModel + +GenericTypesCacheKey = Tuple[Any, Any, Tuple[Any, ...]] + +# Note: We want to remove LimitedDict, but to do this, we'd need to improve the handling of generics caching. +# Right now, to handle recursive generics, we some types must remain cached for brief periods without references. +# By chaining the WeakValuesDict with a LimitedDict, we have a way to retain caching for all types with references, +# while also retaining a limited number of types even without references. This is generally enough to build +# specific recursive generic models without losing required items out of the cache. + +KT = TypeVar('KT') +VT = TypeVar('VT') +_LIMITED_DICT_SIZE = 100 +if TYPE_CHECKING: + + class LimitedDict(dict, MutableMapping[KT, VT]): + def __init__(self, size_limit: int = _LIMITED_DICT_SIZE): + ... + +else: + + class LimitedDict(dict): + """Limit the size/length of a dict used for caching to avoid unlimited increase in memory usage. + + Since the dict is ordered, and we always remove elements from the beginning, this is effectively a FIFO cache. + """ + + def __init__(self, size_limit: int = _LIMITED_DICT_SIZE): + self.size_limit = size_limit + super().__init__() + + def __setitem__(self, key: Any, value: Any, /) -> None: + super().__setitem__(key, value) + if len(self) > self.size_limit: + excess = len(self) - self.size_limit + self.size_limit // 10 + to_remove = list(self.keys())[:excess] + for k in to_remove: + del self[k] + + +# weak dictionaries allow the dynamically created parametrized versions of generic models to get collected +# once they are no longer referenced by the caller. +if sys.version_info >= (3, 9): # Typing for weak dictionaries available at 3.9 + GenericTypesCache = WeakValueDictionary[GenericTypesCacheKey, 'type[BaseModel]'] +else: + GenericTypesCache = WeakValueDictionary + +if TYPE_CHECKING: + + class DeepChainMap(ChainMap[KT, VT]): # type: ignore + ... + +else: + + class DeepChainMap(ChainMap): + """Variant of ChainMap that allows direct updates to inner scopes. + + Taken from https://docs.python.org/3/library/collections.html#collections.ChainMap, + with some light modifications for this use case. + """ + + def clear(self) -> None: + for mapping in self.maps: + mapping.clear() + + def __setitem__(self, key: KT, value: VT) -> None: + for mapping in self.maps: + mapping[key] = value + + def __delitem__(self, key: KT) -> None: + hit = False + for mapping in self.maps: + if key in mapping: + del mapping[key] + hit = True + if not hit: + raise KeyError(key) + + +# Despite the fact that LimitedDict _seems_ no longer necessary, I'm very nervous to actually remove it +# and discover later on that we need to re-add all this infrastructure... +# _GENERIC_TYPES_CACHE = DeepChainMap(GenericTypesCache(), LimitedDict()) + +_GENERIC_TYPES_CACHE = GenericTypesCache() + + +class PydanticGenericMetadata(typing_extensions.TypedDict): + origin: type[BaseModel] | None # analogous to typing._GenericAlias.__origin__ + args: tuple[Any, ...] # analogous to typing._GenericAlias.__args__ + parameters: tuple[type[Any], ...] # analogous to typing.Generic.__parameters__ + + +def create_generic_submodel( + model_name: str, origin: type[BaseModel], args: tuple[Any, ...], params: tuple[Any, ...] +) -> type[BaseModel]: + """Dynamically create a submodel of a provided (generic) BaseModel. + + This is used when producing concrete parametrizations of generic models. This function + only *creates* the new subclass; the schema/validators/serialization must be updated to + reflect a concrete parametrization elsewhere. + + Args: + model_name: The name of the newly created model. + origin: The base class for the new model to inherit from. + args: A tuple of generic metadata arguments. + params: A tuple of generic metadata parameters. + + Returns: + The created submodel. + """ + namespace: dict[str, Any] = {'__module__': origin.__module__} + bases = (origin,) + meta, ns, kwds = prepare_class(model_name, bases) + namespace.update(ns) + created_model = meta( + model_name, + bases, + namespace, + __pydantic_generic_metadata__={ + 'origin': origin, + 'args': args, + 'parameters': params, + }, + __pydantic_reset_parent_namespace__=False, + **kwds, + ) + + model_module, called_globally = _get_caller_frame_info(depth=3) + if called_globally: # create global reference and therefore allow pickling + object_by_reference = None + reference_name = model_name + reference_module_globals = sys.modules[created_model.__module__].__dict__ + while object_by_reference is not created_model: + object_by_reference = reference_module_globals.setdefault(reference_name, created_model) + reference_name += '_' + + return created_model + + +def _get_caller_frame_info(depth: int = 2) -> tuple[str | None, bool]: + """Used inside a function to check whether it was called globally. + + Args: + depth: The depth to get the frame. + + Returns: + A tuple contains `module_name` and `called_globally`. + + Raises: + RuntimeError: If the function is not called inside a function. + """ + try: + previous_caller_frame = sys._getframe(depth) + except ValueError as e: + raise RuntimeError('This function must be used inside another function') from e + except AttributeError: # sys module does not have _getframe function, so there's nothing we can do about it + return None, False + frame_globals = previous_caller_frame.f_globals + return frame_globals.get('__name__'), previous_caller_frame.f_locals is frame_globals + + +DictValues: type[Any] = {}.values().__class__ + + +def iter_contained_typevars(v: Any) -> Iterator[TypeVarType]: + """Recursively iterate through all subtypes and type args of `v` and yield any typevars that are found. + + This is inspired as an alternative to directly accessing the `__parameters__` attribute of a GenericAlias, + since __parameters__ of (nested) generic BaseModel subclasses won't show up in that list. + """ + if isinstance(v, TypeVar): + yield v + elif is_model_class(v): + yield from v.__pydantic_generic_metadata__['parameters'] + elif isinstance(v, (DictValues, list)): + for var in v: + yield from iter_contained_typevars(var) + else: + args = get_args(v) + for arg in args: + yield from iter_contained_typevars(arg) + + +def get_args(v: Any) -> Any: + pydantic_generic_metadata: PydanticGenericMetadata | None = getattr(v, '__pydantic_generic_metadata__', None) + if pydantic_generic_metadata: + return pydantic_generic_metadata.get('args') + return typing_extensions.get_args(v) + + +def get_origin(v: Any) -> Any: + pydantic_generic_metadata: PydanticGenericMetadata | None = getattr(v, '__pydantic_generic_metadata__', None) + if pydantic_generic_metadata: + return pydantic_generic_metadata.get('origin') + return typing_extensions.get_origin(v) + + +def get_standard_typevars_map(cls: type[Any]) -> dict[TypeVarType, Any] | None: + """Package a generic type's typevars and parametrization (if present) into a dictionary compatible with the + `replace_types` function. Specifically, this works with standard typing generics and typing._GenericAlias. + """ + origin = get_origin(cls) + if origin is None: + return None + if not hasattr(origin, '__parameters__'): + return None + + # In this case, we know that cls is a _GenericAlias, and origin is the generic type + # So it is safe to access cls.__args__ and origin.__parameters__ + args: tuple[Any, ...] = cls.__args__ # type: ignore + parameters: tuple[TypeVarType, ...] = origin.__parameters__ + return dict(zip(parameters, args)) + + +def get_model_typevars_map(cls: type[BaseModel]) -> dict[TypeVarType, Any] | None: + """Package a generic BaseModel's typevars and concrete parametrization (if present) into a dictionary compatible + with the `replace_types` function. + + Since BaseModel.__class_getitem__ does not produce a typing._GenericAlias, and the BaseModel generic info is + stored in the __pydantic_generic_metadata__ attribute, we need special handling here. + """ + # TODO: This could be unified with `get_standard_typevars_map` if we stored the generic metadata + # in the __origin__, __args__, and __parameters__ attributes of the model. + generic_metadata = cls.__pydantic_generic_metadata__ + origin = generic_metadata['origin'] + args = generic_metadata['args'] + return dict(zip(iter_contained_typevars(origin), args)) + + +def replace_types(type_: Any, type_map: Mapping[Any, Any] | None) -> Any: + """Return type with all occurrences of `type_map` keys recursively replaced with their values. + + Args: + type_: The class or generic alias. + type_map: Mapping from `TypeVar` instance to concrete types. + + Returns: + A new type representing the basic structure of `type_` with all + `typevar_map` keys recursively replaced. + + Example: + ```py + from typing import List, Tuple, Union + + from pydantic._internal._generics import replace_types + + replace_types(Tuple[str, Union[List[str], float]], {str: int}) + #> Tuple[int, Union[List[int], float]] + ``` + """ + if not type_map: + return type_ + + type_args = get_args(type_) + origin_type = get_origin(type_) + + if origin_type is typing_extensions.Annotated: + annotated_type, *annotations = type_args + annotated = replace_types(annotated_type, type_map) + for annotation in annotations: + annotated = typing_extensions.Annotated[annotated, annotation] + return annotated + + # Having type args is a good indicator that this is a typing module + # class instantiation or a generic alias of some sort. + if type_args: + resolved_type_args = tuple(replace_types(arg, type_map) for arg in type_args) + if all_identical(type_args, resolved_type_args): + # If all arguments are the same, there is no need to modify the + # type or create a new object at all + return type_ + if ( + origin_type is not None + and isinstance(type_, typing_base) + and not isinstance(origin_type, typing_base) + and getattr(type_, '_name', None) is not None + ): + # In python < 3.9 generic aliases don't exist so any of these like `list`, + # `type` or `collections.abc.Callable` need to be translated. + # See: https://www.python.org/dev/peps/pep-0585 + origin_type = getattr(typing, type_._name) + assert origin_type is not None + # PEP-604 syntax (Ex.: list | str) is represented with a types.UnionType object that does not have __getitem__. + # We also cannot use isinstance() since we have to compare types. + if sys.version_info >= (3, 10) and origin_type is types.UnionType: + return _UnionGenericAlias(origin_type, resolved_type_args) + # NotRequired[T] and Required[T] don't support tuple type resolved_type_args, hence the condition below + return origin_type[resolved_type_args[0] if len(resolved_type_args) == 1 else resolved_type_args] + + # We handle pydantic generic models separately as they don't have the same + # semantics as "typing" classes or generic aliases + + if not origin_type and is_model_class(type_): + parameters = type_.__pydantic_generic_metadata__['parameters'] + if not parameters: + return type_ + resolved_type_args = tuple(replace_types(t, type_map) for t in parameters) + if all_identical(parameters, resolved_type_args): + return type_ + return type_[resolved_type_args] + + # Handle special case for typehints that can have lists as arguments. + # `typing.Callable[[int, str], int]` is an example for this. + if isinstance(type_, (List, list)): + resolved_list = list(replace_types(element, type_map) for element in type_) + if all_identical(type_, resolved_list): + return type_ + return resolved_list + + # If all else fails, we try to resolve the type directly and otherwise just + # return the input with no modifications. + return type_map.get(type_, type_) + + +def has_instance_in_type(type_: Any, isinstance_target: Any) -> bool: + """Checks if the type, or any of its arbitrary nested args, satisfy + `isinstance(, isinstance_target)`. + """ + if isinstance(type_, isinstance_target): + return True + + type_args = get_args(type_) + origin_type = get_origin(type_) + + if origin_type is typing_extensions.Annotated: + annotated_type, *annotations = type_args + return has_instance_in_type(annotated_type, isinstance_target) + + # Having type args is a good indicator that this is a typing module + # class instantiation or a generic alias of some sort. + if any(has_instance_in_type(a, isinstance_target) for a in type_args): + return True + + # Handle special case for typehints that can have lists as arguments. + # `typing.Callable[[int, str], int]` is an example for this. + if isinstance(type_, (List, list)) and not isinstance(type_, typing_extensions.ParamSpec): + if any(has_instance_in_type(element, isinstance_target) for element in type_): + return True + + return False + + +def check_parameters_count(cls: type[BaseModel], parameters: tuple[Any, ...]) -> None: + """Check the generic model parameters count is equal. + + Args: + cls: The generic model. + parameters: A tuple of passed parameters to the generic model. + + Raises: + TypeError: If the passed parameters count is not equal to generic model parameters count. + """ + actual = len(parameters) + expected = len(cls.__pydantic_generic_metadata__['parameters']) + if actual != expected: + description = 'many' if actual > expected else 'few' + raise TypeError(f'Too {description} parameters for {cls}; actual {actual}, expected {expected}') + + +_generic_recursion_cache: ContextVar[set[str] | None] = ContextVar('_generic_recursion_cache', default=None) + + +@contextmanager +def generic_recursion_self_type( + origin: type[BaseModel], args: tuple[Any, ...] +) -> Iterator[PydanticRecursiveRef | None]: + """This contextmanager should be placed around the recursive calls used to build a generic type, + and accept as arguments the generic origin type and the type arguments being passed to it. + + If the same origin and arguments are observed twice, it implies that a self-reference placeholder + can be used while building the core schema, and will produce a schema_ref that will be valid in the + final parent schema. + """ + previously_seen_type_refs = _generic_recursion_cache.get() + if previously_seen_type_refs is None: + previously_seen_type_refs = set() + token = _generic_recursion_cache.set(previously_seen_type_refs) + else: + token = None + + try: + type_ref = get_type_ref(origin, args_override=args) + if type_ref in previously_seen_type_refs: + self_type = PydanticRecursiveRef(type_ref=type_ref) + yield self_type + else: + previously_seen_type_refs.add(type_ref) + yield None + finally: + if token: + _generic_recursion_cache.reset(token) + + +def recursively_defined_type_refs() -> set[str]: + visited = _generic_recursion_cache.get() + if not visited: + return set() # not in a generic recursion, so there are no types + + return visited.copy() # don't allow modifications + + +def get_cached_generic_type_early(parent: type[BaseModel], typevar_values: Any) -> type[BaseModel] | None: + """The use of a two-stage cache lookup approach was necessary to have the highest performance possible for + repeated calls to `__class_getitem__` on generic types (which may happen in tighter loops during runtime), + while still ensuring that certain alternative parametrizations ultimately resolve to the same type. + + As a concrete example, this approach was necessary to make Model[List[T]][int] equal to Model[List[int]]. + The approach could be modified to not use two different cache keys at different points, but the + _early_cache_key is optimized to be as quick to compute as possible (for repeated-access speed), and the + _late_cache_key is optimized to be as "correct" as possible, so that two types that will ultimately be the + same after resolving the type arguments will always produce cache hits. + + If we wanted to move to only using a single cache key per type, we would either need to always use the + slower/more computationally intensive logic associated with _late_cache_key, or would need to accept + that Model[List[T]][int] is a different type than Model[List[T]][int]. Because we rely on subclass relationships + during validation, I think it is worthwhile to ensure that types that are functionally equivalent are actually + equal. + """ + return _GENERIC_TYPES_CACHE.get(_early_cache_key(parent, typevar_values)) + + +def get_cached_generic_type_late( + parent: type[BaseModel], typevar_values: Any, origin: type[BaseModel], args: tuple[Any, ...] +) -> type[BaseModel] | None: + """See the docstring of `get_cached_generic_type_early` for more information about the two-stage cache lookup.""" + cached = _GENERIC_TYPES_CACHE.get(_late_cache_key(origin, args, typevar_values)) + if cached is not None: + set_cached_generic_type(parent, typevar_values, cached, origin, args) + return cached + + +def set_cached_generic_type( + parent: type[BaseModel], + typevar_values: tuple[Any, ...], + type_: type[BaseModel], + origin: type[BaseModel] | None = None, + args: tuple[Any, ...] | None = None, +) -> None: + """See the docstring of `get_cached_generic_type_early` for more information about why items are cached with + two different keys. + """ + _GENERIC_TYPES_CACHE[_early_cache_key(parent, typevar_values)] = type_ + if len(typevar_values) == 1: + _GENERIC_TYPES_CACHE[_early_cache_key(parent, typevar_values[0])] = type_ + if origin and args: + _GENERIC_TYPES_CACHE[_late_cache_key(origin, args, typevar_values)] = type_ + + +def _union_orderings_key(typevar_values: Any) -> Any: + """This is intended to help differentiate between Union types with the same arguments in different order. + + Thanks to caching internal to the `typing` module, it is not possible to distinguish between + List[Union[int, float]] and List[Union[float, int]] (and similarly for other "parent" origins besides List) + because `typing` considers Union[int, float] to be equal to Union[float, int]. + + However, you _can_ distinguish between (top-level) Union[int, float] vs. Union[float, int]. + Because we parse items as the first Union type that is successful, we get slightly more consistent behavior + if we make an effort to distinguish the ordering of items in a union. It would be best if we could _always_ + get the exact-correct order of items in the union, but that would require a change to the `typing` module itself. + (See https://github.com/python/cpython/issues/86483 for reference.) + """ + if isinstance(typevar_values, tuple): + args_data = [] + for value in typevar_values: + args_data.append(_union_orderings_key(value)) + return tuple(args_data) + elif typing_extensions.get_origin(typevar_values) is typing.Union: + return get_args(typevar_values) + else: + return () + + +def _early_cache_key(cls: type[BaseModel], typevar_values: Any) -> GenericTypesCacheKey: + """This is intended for minimal computational overhead during lookups of cached types. + + Note that this is overly simplistic, and it's possible that two different cls/typevar_values + inputs would ultimately result in the same type being created in BaseModel.__class_getitem__. + To handle this, we have a fallback _late_cache_key that is checked later if the _early_cache_key + lookup fails, and should result in a cache hit _precisely_ when the inputs to __class_getitem__ + would result in the same type. + """ + return cls, typevar_values, _union_orderings_key(typevar_values) + + +def _late_cache_key(origin: type[BaseModel], args: tuple[Any, ...], typevar_values: Any) -> GenericTypesCacheKey: + """This is intended for use later in the process of creating a new type, when we have more information + about the exact args that will be passed. If it turns out that a different set of inputs to + __class_getitem__ resulted in the same inputs to the generic type creation process, we can still + return the cached type, and update the cache with the _early_cache_key as well. + """ + # The _union_orderings_key is placed at the start here to ensure there cannot be a collision with an + # _early_cache_key, as that function will always produce a BaseModel subclass as the first item in the key, + # whereas this function will always produce a tuple as the first item in the key. + return _union_orderings_key(typevar_values), origin, args diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_git.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_git.py new file mode 100644 index 0000000000000000000000000000000000000000..9de7aaf98dd79ff6d2dc4f3d2bcc116093587a67 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_git.py @@ -0,0 +1,26 @@ +"""Git utilities, adopted from mypy's git utilities (https://github.com/python/mypy/blob/master/mypy/git.py).""" +from __future__ import annotations + +import os +import subprocess + + +def is_git_repo(dir: str) -> bool: + """Is the given directory version-controlled with git?""" + return os.path.exists(os.path.join(dir, '.git')) + + +def have_git() -> bool: + """Can we run the git executable?""" + try: + subprocess.check_output(['git', '--help']) + return True + except subprocess.CalledProcessError: + return False + except OSError: + return False + + +def git_revision(dir: str) -> str: + """Get the SHA-1 of the HEAD of a git repository.""" + return subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], cwd=dir).decode('utf-8').strip() diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_internal_dataclass.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_internal_dataclass.py new file mode 100644 index 0000000000000000000000000000000000000000..317a3d9c856821746ac601a94d8405ac9a3cc6fd --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_internal_dataclass.py @@ -0,0 +1,10 @@ +import sys +from typing import Any, Dict + +dataclass_kwargs: Dict[str, Any] + +# `slots` is available on Python >= 3.10 +if sys.version_info >= (3, 10): + slots_true = {'slots': True} +else: + slots_true = {} diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_known_annotated_metadata.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_known_annotated_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..83d85b3b12ac724a27123387550a1435fb2818a9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_known_annotated_metadata.py @@ -0,0 +1,434 @@ +from __future__ import annotations + +from collections import defaultdict +from copy import copy +from functools import partial +from typing import TYPE_CHECKING, Any, Callable, Iterable + +from pydantic_core import CoreSchema, PydanticCustomError, to_jsonable_python +from pydantic_core import core_schema as cs + +from ._fields import PydanticMetadata + +if TYPE_CHECKING: + from ..annotated_handlers import GetJsonSchemaHandler + + +STRICT = {'strict'} +SEQUENCE_CONSTRAINTS = {'min_length', 'max_length'} +INEQUALITY = {'le', 'ge', 'lt', 'gt'} +NUMERIC_CONSTRAINTS = {'multiple_of', 'allow_inf_nan', *INEQUALITY} + +STR_CONSTRAINTS = { + *SEQUENCE_CONSTRAINTS, + *STRICT, + 'strip_whitespace', + 'to_lower', + 'to_upper', + 'pattern', + 'coerce_numbers_to_str', +} +BYTES_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} + +LIST_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} +TUPLE_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} +SET_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} +DICT_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} +GENERATOR_CONSTRAINTS = {*SEQUENCE_CONSTRAINTS, *STRICT} + +FLOAT_CONSTRAINTS = {*NUMERIC_CONSTRAINTS, *STRICT} +INT_CONSTRAINTS = {*NUMERIC_CONSTRAINTS, *STRICT} +BOOL_CONSTRAINTS = STRICT +UUID_CONSTRAINTS = STRICT + +DATE_TIME_CONSTRAINTS = {*NUMERIC_CONSTRAINTS, *STRICT} +TIMEDELTA_CONSTRAINTS = {*NUMERIC_CONSTRAINTS, *STRICT} +TIME_CONSTRAINTS = {*NUMERIC_CONSTRAINTS, *STRICT} +LAX_OR_STRICT_CONSTRAINTS = STRICT +ENUM_CONSTRAINTS = STRICT + +UNION_CONSTRAINTS = {'union_mode'} +URL_CONSTRAINTS = { + 'max_length', + 'allowed_schemes', + 'host_required', + 'default_host', + 'default_port', + 'default_path', +} + +TEXT_SCHEMA_TYPES = ('str', 'bytes', 'url', 'multi-host-url') +SEQUENCE_SCHEMA_TYPES = ('list', 'tuple', 'set', 'frozenset', 'generator', *TEXT_SCHEMA_TYPES) +NUMERIC_SCHEMA_TYPES = ('float', 'int', 'date', 'time', 'timedelta', 'datetime') + +CONSTRAINTS_TO_ALLOWED_SCHEMAS: dict[str, set[str]] = defaultdict(set) +for constraint in STR_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(TEXT_SCHEMA_TYPES) +for constraint in BYTES_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('bytes',)) +for constraint in LIST_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('list',)) +for constraint in TUPLE_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('tuple',)) +for constraint in SET_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('set', 'frozenset')) +for constraint in DICT_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('dict',)) +for constraint in GENERATOR_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('generator',)) +for constraint in FLOAT_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('float',)) +for constraint in INT_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('int',)) +for constraint in DATE_TIME_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('date', 'time', 'datetime')) +for constraint in TIMEDELTA_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('timedelta',)) +for constraint in TIME_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('time',)) +for schema_type in (*TEXT_SCHEMA_TYPES, *SEQUENCE_SCHEMA_TYPES, *NUMERIC_SCHEMA_TYPES, 'typed-dict', 'model'): + CONSTRAINTS_TO_ALLOWED_SCHEMAS['strict'].add(schema_type) +for constraint in UNION_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('union',)) +for constraint in URL_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('url', 'multi-host-url')) +for constraint in BOOL_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('bool',)) +for constraint in UUID_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('uuid',)) +for constraint in LAX_OR_STRICT_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('lax-or-strict',)) +for constraint in ENUM_CONSTRAINTS: + CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint].update(('enum',)) + + +def add_js_update_schema(s: cs.CoreSchema, f: Callable[[], dict[str, Any]]) -> None: + def update_js_schema(s: cs.CoreSchema, handler: GetJsonSchemaHandler) -> dict[str, Any]: + js_schema = handler(s) + js_schema.update(f()) + return js_schema + + if 'metadata' in s: + metadata = s['metadata'] + if 'pydantic_js_functions' in s: + metadata['pydantic_js_functions'].append(update_js_schema) + else: + metadata['pydantic_js_functions'] = [update_js_schema] + else: + s['metadata'] = {'pydantic_js_functions': [update_js_schema]} + + +def as_jsonable_value(v: Any) -> Any: + if type(v) not in (int, str, float, bytes, bool, type(None)): + return to_jsonable_python(v) + return v + + +def expand_grouped_metadata(annotations: Iterable[Any]) -> Iterable[Any]: + """Expand the annotations. + + Args: + annotations: An iterable of annotations. + + Returns: + An iterable of expanded annotations. + + Example: + ```py + from annotated_types import Ge, Len + + from pydantic._internal._known_annotated_metadata import expand_grouped_metadata + + print(list(expand_grouped_metadata([Ge(4), Len(5)]))) + #> [Ge(ge=4), MinLen(min_length=5)] + ``` + """ + import annotated_types as at + + from pydantic.fields import FieldInfo # circular import + + for annotation in annotations: + if isinstance(annotation, at.GroupedMetadata): + yield from annotation + elif isinstance(annotation, FieldInfo): + yield from annotation.metadata + # this is a bit problematic in that it results in duplicate metadata + # all of our "consumers" can handle it, but it is not ideal + # we probably should split up FieldInfo into: + # - annotated types metadata + # - individual metadata known only to Pydantic + annotation = copy(annotation) + annotation.metadata = [] + yield annotation + else: + yield annotation + + +def apply_known_metadata(annotation: Any, schema: CoreSchema) -> CoreSchema | None: # noqa: C901 + """Apply `annotation` to `schema` if it is an annotation we know about (Gt, Le, etc.). + Otherwise return `None`. + + This does not handle all known annotations. If / when it does, it can always + return a CoreSchema and return the unmodified schema if the annotation should be ignored. + + Assumes that GroupedMetadata has already been expanded via `expand_grouped_metadata`. + + Args: + annotation: The annotation. + schema: The schema. + + Returns: + An updated schema with annotation if it is an annotation we know about, `None` otherwise. + + Raises: + PydanticCustomError: If `Predicate` fails. + """ + import annotated_types as at + + from . import _validators + + schema = schema.copy() + schema_update, other_metadata = collect_known_metadata([annotation]) + schema_type = schema['type'] + for constraint, value in schema_update.items(): + if constraint not in CONSTRAINTS_TO_ALLOWED_SCHEMAS: + raise ValueError(f'Unknown constraint {constraint}') + allowed_schemas = CONSTRAINTS_TO_ALLOWED_SCHEMAS[constraint] + + # if it becomes necessary to handle more than one constraint + # in this recursive case with function-after or function-wrap, we should refactor + if schema_type in {'function-before', 'function-wrap', 'function-after'} and constraint == 'strict': + schema['schema'] = apply_known_metadata(annotation, schema['schema']) # type: ignore # schema is function-after schema + return schema + + if schema_type in allowed_schemas: + if constraint == 'union_mode' and schema_type == 'union': + schema['mode'] = value # type: ignore # schema is UnionSchema + else: + schema[constraint] = value + continue + + if constraint == 'allow_inf_nan' and value is False: + return cs.no_info_after_validator_function( + _validators.forbid_inf_nan_check, + schema, + ) + elif constraint == 'pattern': + # insert a str schema to make sure the regex engine matches + return cs.chain_schema( + [ + schema, + cs.str_schema(pattern=value), + ] + ) + elif constraint == 'gt': + s = cs.no_info_after_validator_function( + partial(_validators.greater_than_validator, gt=value), + schema, + ) + add_js_update_schema(s, lambda: {'gt': as_jsonable_value(value)}) + return s + elif constraint == 'ge': + return cs.no_info_after_validator_function( + partial(_validators.greater_than_or_equal_validator, ge=value), + schema, + ) + elif constraint == 'lt': + return cs.no_info_after_validator_function( + partial(_validators.less_than_validator, lt=value), + schema, + ) + elif constraint == 'le': + return cs.no_info_after_validator_function( + partial(_validators.less_than_or_equal_validator, le=value), + schema, + ) + elif constraint == 'multiple_of': + return cs.no_info_after_validator_function( + partial(_validators.multiple_of_validator, multiple_of=value), + schema, + ) + elif constraint == 'min_length': + s = cs.no_info_after_validator_function( + partial(_validators.min_length_validator, min_length=value), + schema, + ) + add_js_update_schema(s, lambda: {'minLength': (as_jsonable_value(value))}) + return s + elif constraint == 'max_length': + s = cs.no_info_after_validator_function( + partial(_validators.max_length_validator, max_length=value), + schema, + ) + add_js_update_schema(s, lambda: {'maxLength': (as_jsonable_value(value))}) + return s + elif constraint == 'strip_whitespace': + return cs.chain_schema( + [ + schema, + cs.str_schema(strip_whitespace=True), + ] + ) + elif constraint == 'to_lower': + return cs.chain_schema( + [ + schema, + cs.str_schema(to_lower=True), + ] + ) + elif constraint == 'to_upper': + return cs.chain_schema( + [ + schema, + cs.str_schema(to_upper=True), + ] + ) + elif constraint == 'min_length': + return cs.no_info_after_validator_function( + partial(_validators.min_length_validator, min_length=annotation.min_length), + schema, + ) + elif constraint == 'max_length': + return cs.no_info_after_validator_function( + partial(_validators.max_length_validator, max_length=annotation.max_length), + schema, + ) + elif constraint == 'coerce_numbers_to_str': + return cs.chain_schema( + [ + schema, + cs.str_schema(coerce_numbers_to_str=True), # type: ignore + ] + ) + else: + raise RuntimeError(f'Unable to apply constraint {constraint} to schema {schema_type}') + + for annotation in other_metadata: + if isinstance(annotation, at.Gt): + return cs.no_info_after_validator_function( + partial(_validators.greater_than_validator, gt=annotation.gt), + schema, + ) + elif isinstance(annotation, at.Ge): + return cs.no_info_after_validator_function( + partial(_validators.greater_than_or_equal_validator, ge=annotation.ge), + schema, + ) + elif isinstance(annotation, at.Lt): + return cs.no_info_after_validator_function( + partial(_validators.less_than_validator, lt=annotation.lt), + schema, + ) + elif isinstance(annotation, at.Le): + return cs.no_info_after_validator_function( + partial(_validators.less_than_or_equal_validator, le=annotation.le), + schema, + ) + elif isinstance(annotation, at.MultipleOf): + return cs.no_info_after_validator_function( + partial(_validators.multiple_of_validator, multiple_of=annotation.multiple_of), + schema, + ) + elif isinstance(annotation, at.MinLen): + return cs.no_info_after_validator_function( + partial(_validators.min_length_validator, min_length=annotation.min_length), + schema, + ) + elif isinstance(annotation, at.MaxLen): + return cs.no_info_after_validator_function( + partial(_validators.max_length_validator, max_length=annotation.max_length), + schema, + ) + elif isinstance(annotation, at.Predicate): + predicate_name = f'{annotation.func.__qualname__} ' if hasattr(annotation.func, '__qualname__') else '' + + def val_func(v: Any) -> Any: + # annotation.func may also raise an exception, let it pass through + if not annotation.func(v): + raise PydanticCustomError( + 'predicate_failed', + f'Predicate {predicate_name}failed', # type: ignore + ) + return v + + return cs.no_info_after_validator_function(val_func, schema) + # ignore any other unknown metadata + return None + + return schema + + +def collect_known_metadata(annotations: Iterable[Any]) -> tuple[dict[str, Any], list[Any]]: + """Split `annotations` into known metadata and unknown annotations. + + Args: + annotations: An iterable of annotations. + + Returns: + A tuple contains a dict of known metadata and a list of unknown annotations. + + Example: + ```py + from annotated_types import Gt, Len + + from pydantic._internal._known_annotated_metadata import collect_known_metadata + + print(collect_known_metadata([Gt(1), Len(42), ...])) + #> ({'gt': 1, 'min_length': 42}, [Ellipsis]) + ``` + """ + import annotated_types as at + + annotations = expand_grouped_metadata(annotations) + + res: dict[str, Any] = {} + remaining: list[Any] = [] + for annotation in annotations: + # isinstance(annotation, PydanticMetadata) also covers ._fields:_PydanticGeneralMetadata + if isinstance(annotation, PydanticMetadata): + res.update(annotation.__dict__) + # we don't use dataclasses.asdict because that recursively calls asdict on the field values + elif isinstance(annotation, at.MinLen): + res.update({'min_length': annotation.min_length}) + elif isinstance(annotation, at.MaxLen): + res.update({'max_length': annotation.max_length}) + elif isinstance(annotation, at.Gt): + res.update({'gt': annotation.gt}) + elif isinstance(annotation, at.Ge): + res.update({'ge': annotation.ge}) + elif isinstance(annotation, at.Lt): + res.update({'lt': annotation.lt}) + elif isinstance(annotation, at.Le): + res.update({'le': annotation.le}) + elif isinstance(annotation, at.MultipleOf): + res.update({'multiple_of': annotation.multiple_of}) + elif isinstance(annotation, type) and issubclass(annotation, PydanticMetadata): + # also support PydanticMetadata classes being used without initialisation, + # e.g. `Annotated[int, Strict]` as well as `Annotated[int, Strict()]` + res.update({k: v for k, v in vars(annotation).items() if not k.startswith('_')}) + else: + remaining.append(annotation) + # Nones can sneak in but pydantic-core will reject them + # it'd be nice to clean things up so we don't put in None (we probably don't _need_ to, it was just easier) + # but this is simple enough to kick that can down the road + res = {k: v for k, v in res.items() if v is not None} + return res, remaining + + +def check_metadata(metadata: dict[str, Any], allowed: Iterable[str], source_type: Any) -> None: + """A small utility function to validate that the given metadata can be applied to the target. + More than saving lines of code, this gives us a consistent error message for all of our internal implementations. + + Args: + metadata: A dict of metadata. + allowed: An iterable of allowed metadata. + source_type: The source type. + + Raises: + TypeError: If there is metadatas that can't be applied on source type. + """ + unknown = metadata.keys() - set(allowed) + if unknown: + raise TypeError( + f'The following constraints cannot be applied to {source_type!r}: {", ".join([f"{k!r}" for k in unknown])}' + ) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_mock_val_ser.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_mock_val_ser.py new file mode 100644 index 0000000000000000000000000000000000000000..b303fed21dc012a9ece360f153a5f1eef272b3f0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_mock_val_ser.py @@ -0,0 +1,140 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Callable, Generic, TypeVar + +from pydantic_core import SchemaSerializer, SchemaValidator +from typing_extensions import Literal + +from ..errors import PydanticErrorCodes, PydanticUserError + +if TYPE_CHECKING: + from ..dataclasses import PydanticDataclass + from ..main import BaseModel + + +ValSer = TypeVar('ValSer', SchemaValidator, SchemaSerializer) + + +class MockValSer(Generic[ValSer]): + """Mocker for `pydantic_core.SchemaValidator` or `pydantic_core.SchemaSerializer` which optionally attempts to + rebuild the thing it's mocking when one of its methods is accessed and raises an error if that fails. + """ + + __slots__ = '_error_message', '_code', '_val_or_ser', '_attempt_rebuild' + + def __init__( + self, + error_message: str, + *, + code: PydanticErrorCodes, + val_or_ser: Literal['validator', 'serializer'], + attempt_rebuild: Callable[[], ValSer | None] | None = None, + ) -> None: + self._error_message = error_message + self._val_or_ser = SchemaValidator if val_or_ser == 'validator' else SchemaSerializer + self._code: PydanticErrorCodes = code + self._attempt_rebuild = attempt_rebuild + + def __getattr__(self, item: str) -> None: + __tracebackhide__ = True + if self._attempt_rebuild: + val_ser = self._attempt_rebuild() + if val_ser is not None: + return getattr(val_ser, item) + + # raise an AttributeError if `item` doesn't exist + getattr(self._val_or_ser, item) + raise PydanticUserError(self._error_message, code=self._code) + + def rebuild(self) -> ValSer | None: + if self._attempt_rebuild: + val_ser = self._attempt_rebuild() + if val_ser is not None: + return val_ser + else: + raise PydanticUserError(self._error_message, code=self._code) + return None + + +def set_model_mocks(cls: type[BaseModel], cls_name: str, undefined_name: str = 'all referenced types') -> None: + """Set `__pydantic_validator__` and `__pydantic_serializer__` to `MockValSer`s on a model. + + Args: + cls: The model class to set the mocks on + cls_name: Name of the model class, used in error messages + undefined_name: Name of the undefined thing, used in error messages + """ + undefined_type_error_message = ( + f'`{cls_name}` is not fully defined; you should define {undefined_name},' + f' then call `{cls_name}.model_rebuild()`.' + ) + + def attempt_rebuild_validator() -> SchemaValidator | None: + if cls.model_rebuild(raise_errors=False, _parent_namespace_depth=5) is not False: + return cls.__pydantic_validator__ + else: + return None + + cls.__pydantic_validator__ = MockValSer( # type: ignore[assignment] + undefined_type_error_message, + code='class-not-fully-defined', + val_or_ser='validator', + attempt_rebuild=attempt_rebuild_validator, + ) + + def attempt_rebuild_serializer() -> SchemaSerializer | None: + if cls.model_rebuild(raise_errors=False, _parent_namespace_depth=5) is not False: + return cls.__pydantic_serializer__ + else: + return None + + cls.__pydantic_serializer__ = MockValSer( # type: ignore[assignment] + undefined_type_error_message, + code='class-not-fully-defined', + val_or_ser='serializer', + attempt_rebuild=attempt_rebuild_serializer, + ) + + +def set_dataclass_mocks( + cls: type[PydanticDataclass], cls_name: str, undefined_name: str = 'all referenced types' +) -> None: + """Set `__pydantic_validator__` and `__pydantic_serializer__` to `MockValSer`s on a dataclass. + + Args: + cls: The model class to set the mocks on + cls_name: Name of the model class, used in error messages + undefined_name: Name of the undefined thing, used in error messages + """ + from ..dataclasses import rebuild_dataclass + + undefined_type_error_message = ( + f'`{cls_name}` is not fully defined; you should define {undefined_name},' + f' then call `pydantic.dataclasses.rebuild_dataclass({cls_name})`.' + ) + + def attempt_rebuild_validator() -> SchemaValidator | None: + if rebuild_dataclass(cls, raise_errors=False, _parent_namespace_depth=5) is not False: + return cls.__pydantic_validator__ + else: + return None + + cls.__pydantic_validator__ = MockValSer( # type: ignore[assignment] + undefined_type_error_message, + code='class-not-fully-defined', + val_or_ser='validator', + attempt_rebuild=attempt_rebuild_validator, + ) + + def attempt_rebuild_serializer() -> SchemaSerializer | None: + if rebuild_dataclass(cls, raise_errors=False, _parent_namespace_depth=5) is not False: + return cls.__pydantic_serializer__ + else: + return None + + cls.__pydantic_serializer__ = MockValSer( # type: ignore[assignment] + undefined_type_error_message, + code='class-not-fully-defined', + val_or_ser='validator', + attempt_rebuild=attempt_rebuild_serializer, + ) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.py new file mode 100644 index 0000000000000000000000000000000000000000..74766293ce125404bb25406e06ebb815330ca638 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.py @@ -0,0 +1,713 @@ +"""Private logic for creating models.""" +from __future__ import annotations as _annotations + +import builtins +import operator +import typing +import warnings +import weakref +from abc import ABCMeta +from functools import partial +from types import FunctionType +from typing import Any, Callable, Generic, NoReturn + +import typing_extensions +from pydantic_core import PydanticUndefined, SchemaSerializer +from typing_extensions import dataclass_transform, deprecated + +from ..errors import PydanticUndefinedAnnotation, PydanticUserError +from ..plugin._schema_validator import create_schema_validator +from ..warnings import GenericBeforeBaseModelWarning, PydanticDeprecatedSince20 +from ._config import ConfigWrapper +from ._decorators import DecoratorInfos, PydanticDescriptorProxy, get_attribute_from_bases, unwrap_wrapped_function +from ._fields import collect_model_fields, is_valid_field_name, is_valid_privateattr_name +from ._generate_schema import GenerateSchema +from ._generics import PydanticGenericMetadata, get_model_typevars_map +from ._mock_val_ser import MockValSer, set_model_mocks +from ._schema_generation_shared import CallbackGetCoreSchemaHandler +from ._signature import generate_pydantic_signature +from ._typing_extra import get_cls_types_namespace, is_annotated, is_classvar, parent_frame_namespace +from ._utils import ClassAttribute, SafeGetItemProxy +from ._validate_call import ValidateCallWrapper + +if typing.TYPE_CHECKING: + from ..fields import Field as PydanticModelField + from ..fields import FieldInfo, ModelPrivateAttr + from ..main import BaseModel +else: + # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915 + # and https://youtrack.jetbrains.com/issue/PY-51428 + DeprecationWarning = PydanticDeprecatedSince20 + PydanticModelField = object() + +object_setattr = object.__setattr__ + + +class _ModelNamespaceDict(dict): + """A dictionary subclass that intercepts attribute setting on model classes and + warns about overriding of decorators. + """ + + def __setitem__(self, k: str, v: object) -> None: + existing: Any = self.get(k, None) + if existing and v is not existing and isinstance(existing, PydanticDescriptorProxy): + warnings.warn(f'`{k}` overrides an existing Pydantic `{existing.decorator_info.decorator_repr}` decorator') + + return super().__setitem__(k, v) + + +@dataclass_transform(kw_only_default=True, field_specifiers=(PydanticModelField,)) +class ModelMetaclass(ABCMeta): + def __new__( + mcs, + cls_name: str, + bases: tuple[type[Any], ...], + namespace: dict[str, Any], + __pydantic_generic_metadata__: PydanticGenericMetadata | None = None, + __pydantic_reset_parent_namespace__: bool = True, + _create_model_module: str | None = None, + **kwargs: Any, + ) -> type: + """Metaclass for creating Pydantic models. + + Args: + cls_name: The name of the class to be created. + bases: The base classes of the class to be created. + namespace: The attribute dictionary of the class to be created. + __pydantic_generic_metadata__: Metadata for generic models. + __pydantic_reset_parent_namespace__: Reset parent namespace. + _create_model_module: The module of the class to be created, if created by `create_model`. + **kwargs: Catch-all for any other keyword arguments. + + Returns: + The new class created by the metaclass. + """ + # Note `ModelMetaclass` refers to `BaseModel`, but is also used to *create* `BaseModel`, so we rely on the fact + # that `BaseModel` itself won't have any bases, but any subclass of it will, to determine whether the `__new__` + # call we're in the middle of is for the `BaseModel` class. + if bases: + base_field_names, class_vars, base_private_attributes = mcs._collect_bases_data(bases) + + config_wrapper = ConfigWrapper.for_model(bases, namespace, kwargs) + namespace['model_config'] = config_wrapper.config_dict + private_attributes = inspect_namespace( + namespace, config_wrapper.ignored_types, class_vars, base_field_names + ) + if private_attributes or base_private_attributes: + original_model_post_init = get_model_post_init(namespace, bases) + if original_model_post_init is not None: + # if there are private_attributes and a model_post_init function, we handle both + + def wrapped_model_post_init(self: BaseModel, __context: Any) -> None: + """We need to both initialize private attributes and call the user-defined model_post_init + method. + """ + init_private_attributes(self, __context) + original_model_post_init(self, __context) + + namespace['model_post_init'] = wrapped_model_post_init + else: + namespace['model_post_init'] = init_private_attributes + + namespace['__class_vars__'] = class_vars + namespace['__private_attributes__'] = {**base_private_attributes, **private_attributes} + + cls: type[BaseModel] = super().__new__(mcs, cls_name, bases, namespace, **kwargs) # type: ignore + + from ..main import BaseModel + + mro = cls.__mro__ + if Generic in mro and mro.index(Generic) < mro.index(BaseModel): + warnings.warn( + GenericBeforeBaseModelWarning( + 'Classes should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) ' + 'for pydantic generics to work properly.' + ), + stacklevel=2, + ) + + cls.__pydantic_custom_init__ = not getattr(cls.__init__, '__pydantic_base_init__', False) + cls.__pydantic_post_init__ = None if cls.model_post_init is BaseModel.model_post_init else 'model_post_init' + + cls.__pydantic_decorators__ = DecoratorInfos.build(cls) + + # Use the getattr below to grab the __parameters__ from the `typing.Generic` parent class + if __pydantic_generic_metadata__: + cls.__pydantic_generic_metadata__ = __pydantic_generic_metadata__ + else: + parent_parameters = getattr(cls, '__pydantic_generic_metadata__', {}).get('parameters', ()) + parameters = getattr(cls, '__parameters__', None) or parent_parameters + if parameters and parent_parameters and not all(x in parameters for x in parent_parameters): + from ..root_model import RootModelRootType + + missing_parameters = tuple(x for x in parameters if x not in parent_parameters) + if RootModelRootType in parent_parameters and RootModelRootType not in parameters: + # This is a special case where the user has subclassed `RootModel`, but has not parametrized + # RootModel with the generic type identifiers being used. Ex: + # class MyModel(RootModel, Generic[T]): + # root: T + # Should instead just be: + # class MyModel(RootModel[T]): + # root: T + parameters_str = ', '.join([x.__name__ for x in missing_parameters]) + error_message = ( + f'{cls.__name__} is a subclass of `RootModel`, but does not include the generic type identifier(s) ' + f'{parameters_str} in its parameters. ' + f'You should parametrize RootModel directly, e.g., `class {cls.__name__}(RootModel[{parameters_str}]): ...`.' + ) + else: + combined_parameters = parent_parameters + missing_parameters + parameters_str = ', '.join([str(x) for x in combined_parameters]) + generic_type_label = f'typing.Generic[{parameters_str}]' + error_message = ( + f'All parameters must be present on typing.Generic;' + f' you should inherit from {generic_type_label}.' + ) + if Generic not in bases: # pragma: no cover + # We raise an error here not because it is desirable, but because some cases are mishandled. + # It would be nice to remove this error and still have things behave as expected, it's just + # challenging because we are using a custom `__class_getitem__` to parametrize generic models, + # and not returning a typing._GenericAlias from it. + bases_str = ', '.join([x.__name__ for x in bases] + [generic_type_label]) + error_message += ( + f' Note: `typing.Generic` must go last: `class {cls.__name__}({bases_str}): ...`)' + ) + raise TypeError(error_message) + + cls.__pydantic_generic_metadata__ = { + 'origin': None, + 'args': (), + 'parameters': parameters, + } + + cls.__pydantic_complete__ = False # Ensure this specific class gets completed + + # preserve `__set_name__` protocol defined in https://peps.python.org/pep-0487 + # for attributes not in `new_namespace` (e.g. private attributes) + for name, obj in private_attributes.items(): + obj.__set_name__(cls, name) + + if __pydantic_reset_parent_namespace__: + cls.__pydantic_parent_namespace__ = build_lenient_weakvaluedict(parent_frame_namespace()) + parent_namespace = getattr(cls, '__pydantic_parent_namespace__', None) + if isinstance(parent_namespace, dict): + parent_namespace = unpack_lenient_weakvaluedict(parent_namespace) + + types_namespace = get_cls_types_namespace(cls, parent_namespace) + set_model_fields(cls, bases, config_wrapper, types_namespace) + + if config_wrapper.frozen and '__hash__' not in namespace: + set_default_hash_func(cls, bases) + + complete_model_class( + cls, + cls_name, + config_wrapper, + raise_errors=False, + types_namespace=types_namespace, + create_model_module=_create_model_module, + ) + + # If this is placed before the complete_model_class call above, + # the generic computed fields return type is set to PydanticUndefined + cls.model_computed_fields = {k: v.info for k, v in cls.__pydantic_decorators__.computed_fields.items()} + + set_deprecated_descriptors(cls) + + # using super(cls, cls) on the next line ensures we only call the parent class's __pydantic_init_subclass__ + # I believe the `type: ignore` is only necessary because mypy doesn't realize that this code branch is + # only hit for _proper_ subclasses of BaseModel + super(cls, cls).__pydantic_init_subclass__(**kwargs) # type: ignore[misc] + return cls + else: + # this is the BaseModel class itself being created, no logic required + return super().__new__(mcs, cls_name, bases, namespace, **kwargs) + + if not typing.TYPE_CHECKING: # pragma: no branch + # We put `__getattr__` in a non-TYPE_CHECKING block because otherwise, mypy allows arbitrary attribute access + + def __getattr__(self, item: str) -> Any: + """This is necessary to keep attribute access working for class attribute access.""" + private_attributes = self.__dict__.get('__private_attributes__') + if private_attributes and item in private_attributes: + return private_attributes[item] + if item == '__pydantic_core_schema__': + # This means the class didn't get a schema generated for it, likely because there was an undefined reference + maybe_mock_validator = getattr(self, '__pydantic_validator__', None) + if isinstance(maybe_mock_validator, MockValSer): + rebuilt_validator = maybe_mock_validator.rebuild() + if rebuilt_validator is not None: + # In this case, a validator was built, and so `__pydantic_core_schema__` should now be set + return getattr(self, '__pydantic_core_schema__') + raise AttributeError(item) + + @classmethod + def __prepare__(cls, *args: Any, **kwargs: Any) -> dict[str, object]: + return _ModelNamespaceDict() + + def __instancecheck__(self, instance: Any) -> bool: + """Avoid calling ABC _abc_subclasscheck unless we're pretty sure. + + See #3829 and python/cpython#92810 + """ + return hasattr(instance, '__pydantic_validator__') and super().__instancecheck__(instance) + + @staticmethod + def _collect_bases_data(bases: tuple[type[Any], ...]) -> tuple[set[str], set[str], dict[str, ModelPrivateAttr]]: + from ..main import BaseModel + + field_names: set[str] = set() + class_vars: set[str] = set() + private_attributes: dict[str, ModelPrivateAttr] = {} + for base in bases: + if issubclass(base, BaseModel) and base is not BaseModel: + # model_fields might not be defined yet in the case of generics, so we use getattr here: + field_names.update(getattr(base, 'model_fields', {}).keys()) + class_vars.update(base.__class_vars__) + private_attributes.update(base.__private_attributes__) + return field_names, class_vars, private_attributes + + @property + @deprecated('The `__fields__` attribute is deprecated, use `model_fields` instead.', category=None) + def __fields__(self) -> dict[str, FieldInfo]: + warnings.warn( + 'The `__fields__` attribute is deprecated, use `model_fields` instead.', PydanticDeprecatedSince20 + ) + return self.model_fields # type: ignore + + def __dir__(self) -> list[str]: + attributes = list(super().__dir__()) + if '__fields__' in attributes: + attributes.remove('__fields__') + return attributes + + +def init_private_attributes(self: BaseModel, __context: Any) -> None: + """This function is meant to behave like a BaseModel method to initialise private attributes. + + It takes context as an argument since that's what pydantic-core passes when calling it. + + Args: + self: The BaseModel instance. + __context: The context. + """ + if getattr(self, '__pydantic_private__', None) is None: + pydantic_private = {} + for name, private_attr in self.__private_attributes__.items(): + default = private_attr.get_default() + if default is not PydanticUndefined: + pydantic_private[name] = default + object_setattr(self, '__pydantic_private__', pydantic_private) + + +def get_model_post_init(namespace: dict[str, Any], bases: tuple[type[Any], ...]) -> Callable[..., Any] | None: + """Get the `model_post_init` method from the namespace or the class bases, or `None` if not defined.""" + if 'model_post_init' in namespace: + return namespace['model_post_init'] + + from ..main import BaseModel + + model_post_init = get_attribute_from_bases(bases, 'model_post_init') + if model_post_init is not BaseModel.model_post_init: + return model_post_init + + +def inspect_namespace( # noqa C901 + namespace: dict[str, Any], + ignored_types: tuple[type[Any], ...], + base_class_vars: set[str], + base_class_fields: set[str], +) -> dict[str, ModelPrivateAttr]: + """Iterate over the namespace and: + * gather private attributes + * check for items which look like fields but are not (e.g. have no annotation) and warn. + + Args: + namespace: The attribute dictionary of the class to be created. + ignored_types: A tuple of ignore types. + base_class_vars: A set of base class class variables. + base_class_fields: A set of base class fields. + + Returns: + A dict contains private attributes info. + + Raises: + TypeError: If there is a `__root__` field in model. + NameError: If private attribute name is invalid. + PydanticUserError: + - If a field does not have a type annotation. + - If a field on base class was overridden by a non-annotated attribute. + """ + from ..fields import FieldInfo, ModelPrivateAttr, PrivateAttr + + all_ignored_types = ignored_types + default_ignored_types() + + private_attributes: dict[str, ModelPrivateAttr] = {} + raw_annotations = namespace.get('__annotations__', {}) + + if '__root__' in raw_annotations or '__root__' in namespace: + raise TypeError("To define root models, use `pydantic.RootModel` rather than a field called '__root__'") + + ignored_names: set[str] = set() + for var_name, value in list(namespace.items()): + if var_name == 'model_config': + continue + elif ( + isinstance(value, type) + and value.__module__ == namespace['__module__'] + and '__qualname__' in namespace + and value.__qualname__.startswith(namespace['__qualname__']) + ): + # `value` is a nested type defined in this namespace; don't error + continue + elif isinstance(value, all_ignored_types) or value.__class__.__module__ == 'functools': + ignored_names.add(var_name) + continue + elif isinstance(value, ModelPrivateAttr): + if var_name.startswith('__'): + raise NameError( + 'Private attributes must not use dunder names;' + f' use a single underscore prefix instead of {var_name!r}.' + ) + elif is_valid_field_name(var_name): + raise NameError( + 'Private attributes must not use valid field names;' + f' use sunder names, e.g. {"_" + var_name!r} instead of {var_name!r}.' + ) + private_attributes[var_name] = value + del namespace[var_name] + elif isinstance(value, FieldInfo) and not is_valid_field_name(var_name): + suggested_name = var_name.lstrip('_') or 'my_field' # don't suggest '' for all-underscore name + raise NameError( + f'Fields must not use names with leading underscores;' + f' e.g., use {suggested_name!r} instead of {var_name!r}.' + ) + + elif var_name.startswith('__'): + continue + elif is_valid_privateattr_name(var_name): + if var_name not in raw_annotations or not is_classvar(raw_annotations[var_name]): + private_attributes[var_name] = PrivateAttr(default=value) + del namespace[var_name] + elif var_name in base_class_vars: + continue + elif var_name not in raw_annotations: + if var_name in base_class_fields: + raise PydanticUserError( + f'Field {var_name!r} defined on a base class was overridden by a non-annotated attribute. ' + f'All field definitions, including overrides, require a type annotation.', + code='model-field-overridden', + ) + elif isinstance(value, FieldInfo): + raise PydanticUserError( + f'Field {var_name!r} requires a type annotation', code='model-field-missing-annotation' + ) + else: + raise PydanticUserError( + f'A non-annotated attribute was detected: `{var_name} = {value!r}`. All model fields require a ' + f'type annotation; if `{var_name}` is not meant to be a field, you may be able to resolve this ' + f"error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.", + code='model-field-missing-annotation', + ) + + for ann_name, ann_type in raw_annotations.items(): + if ( + is_valid_privateattr_name(ann_name) + and ann_name not in private_attributes + and ann_name not in ignored_names + and not is_classvar(ann_type) + and ann_type not in all_ignored_types + and getattr(ann_type, '__module__', None) != 'functools' + ): + if is_annotated(ann_type): + _, *metadata = typing_extensions.get_args(ann_type) + private_attr = next((v for v in metadata if isinstance(v, ModelPrivateAttr)), None) + if private_attr is not None: + private_attributes[ann_name] = private_attr + continue + private_attributes[ann_name] = PrivateAttr() + + return private_attributes + + +def set_default_hash_func(cls: type[BaseModel], bases: tuple[type[Any], ...]) -> None: + base_hash_func = get_attribute_from_bases(bases, '__hash__') + new_hash_func = make_hash_func(cls) + if base_hash_func in {None, object.__hash__} or getattr(base_hash_func, '__code__', None) == new_hash_func.__code__: + # If `__hash__` is some default, we generate a hash function. + # It will be `None` if not overridden from BaseModel. + # It may be `object.__hash__` if there is another + # parent class earlier in the bases which doesn't override `__hash__` (e.g. `typing.Generic`). + # It may be a value set by `set_default_hash_func` if `cls` is a subclass of another frozen model. + # In the last case we still need a new hash function to account for new `model_fields`. + cls.__hash__ = new_hash_func + + +def make_hash_func(cls: type[BaseModel]) -> Any: + getter = operator.itemgetter(*cls.model_fields.keys()) if cls.model_fields else lambda _: 0 + + def hash_func(self: Any) -> int: + try: + return hash(getter(self.__dict__)) + except KeyError: + # In rare cases (such as when using the deprecated copy method), the __dict__ may not contain + # all model fields, which is how we can get here. + # getter(self.__dict__) is much faster than any 'safe' method that accounts for missing keys, + # and wrapping it in a `try` doesn't slow things down much in the common case. + return hash(getter(SafeGetItemProxy(self.__dict__))) + + return hash_func + + +def set_model_fields( + cls: type[BaseModel], bases: tuple[type[Any], ...], config_wrapper: ConfigWrapper, types_namespace: dict[str, Any] +) -> None: + """Collect and set `cls.model_fields` and `cls.__class_vars__`. + + Args: + cls: BaseModel or dataclass. + bases: Parents of the class, generally `cls.__bases__`. + config_wrapper: The config wrapper instance. + types_namespace: Optional extra namespace to look for types in. + """ + typevars_map = get_model_typevars_map(cls) + fields, class_vars = collect_model_fields(cls, bases, config_wrapper, types_namespace, typevars_map=typevars_map) + + cls.model_fields = fields + cls.__class_vars__.update(class_vars) + + for k in class_vars: + # Class vars should not be private attributes + # We remove them _here_ and not earlier because we rely on inspecting the class to determine its classvars, + # but private attributes are determined by inspecting the namespace _prior_ to class creation. + # In the case that a classvar with a leading-'_' is defined via a ForwardRef (e.g., when using + # `__future__.annotations`), we want to remove the private attribute which was detected _before_ we knew it + # evaluated to a classvar + + value = cls.__private_attributes__.pop(k, None) + if value is not None and value.default is not PydanticUndefined: + setattr(cls, k, value.default) + + +def complete_model_class( + cls: type[BaseModel], + cls_name: str, + config_wrapper: ConfigWrapper, + *, + raise_errors: bool = True, + types_namespace: dict[str, Any] | None, + create_model_module: str | None = None, +) -> bool: + """Finish building a model class. + + This logic must be called after class has been created since validation functions must be bound + and `get_type_hints` requires a class object. + + Args: + cls: BaseModel or dataclass. + cls_name: The model or dataclass name. + config_wrapper: The config wrapper instance. + raise_errors: Whether to raise errors. + types_namespace: Optional extra namespace to look for types in. + create_model_module: The module of the class to be created, if created by `create_model`. + + Returns: + `True` if the model is successfully completed, else `False`. + + Raises: + PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` + and `raise_errors=True`. + """ + typevars_map = get_model_typevars_map(cls) + gen_schema = GenerateSchema( + config_wrapper, + types_namespace, + typevars_map, + ) + + handler = CallbackGetCoreSchemaHandler( + partial(gen_schema.generate_schema, from_dunder_get_core_schema=False), + gen_schema, + ref_mode='unpack', + ) + + if config_wrapper.defer_build: + set_model_mocks(cls, cls_name) + return False + + try: + schema = cls.__get_pydantic_core_schema__(cls, handler) + except PydanticUndefinedAnnotation as e: + if raise_errors: + raise + set_model_mocks(cls, cls_name, f'`{e.name}`') + return False + + core_config = config_wrapper.core_config(cls) + + try: + schema = gen_schema.clean_schema(schema) + except gen_schema.CollectedInvalid: + set_model_mocks(cls, cls_name) + return False + + # debug(schema) + cls.__pydantic_core_schema__ = schema + + cls.__pydantic_validator__ = create_schema_validator( + schema, + cls, + create_model_module or cls.__module__, + cls.__qualname__, + 'create_model' if create_model_module else 'BaseModel', + core_config, + config_wrapper.plugin_settings, + ) + cls.__pydantic_serializer__ = SchemaSerializer(schema, core_config) + cls.__pydantic_complete__ = True + + # set __signature__ attr only for model class, but not for its instances + cls.__signature__ = ClassAttribute( + '__signature__', + generate_pydantic_signature(init=cls.__init__, fields=cls.model_fields, config_wrapper=config_wrapper), + ) + return True + + +def set_deprecated_descriptors(cls: type[BaseModel]) -> None: + """Set data descriptors on the class for deprecated fields.""" + for field, field_info in cls.model_fields.items(): + if (msg := field_info.deprecation_message) is not None: + desc = _DeprecatedFieldDescriptor(msg) + desc.__set_name__(cls, field) + setattr(cls, field, desc) + + for field, computed_field_info in cls.model_computed_fields.items(): + if ( + (msg := computed_field_info.deprecation_message) is not None + # Avoid having two warnings emitted: + and not hasattr(unwrap_wrapped_function(computed_field_info.wrapped_property), '__deprecated__') + ): + desc = _DeprecatedFieldDescriptor(msg, computed_field_info.wrapped_property) + desc.__set_name__(cls, field) + setattr(cls, field, desc) + + +class _DeprecatedFieldDescriptor: + """Data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. + + Attributes: + msg: The deprecation message to be emitted. + wrapped_property: The property instance if the deprecated field is a computed field, or `None`. + field_name: The name of the field being deprecated. + """ + + field_name: str + + def __init__(self, msg: str, wrapped_property: property | None = None) -> None: + self.msg = msg + self.wrapped_property = wrapped_property + + def __set_name__(self, cls: type[BaseModel], name: str) -> None: + self.field_name = name + + def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any: + if obj is None: + raise AttributeError(self.field_name) + + warnings.warn(self.msg, builtins.DeprecationWarning, stacklevel=2) + + if self.wrapped_property is not None: + return self.wrapped_property.__get__(obj, obj_type) + return obj.__dict__[self.field_name] + + # Defined to take precedence over the instance's dictionary + # Note that it will not be called when setting a value on a model instance + # as `BaseModel.__setattr__` is defined and takes priority. + def __set__(self, obj: Any, value: Any) -> NoReturn: + raise AttributeError(self.field_name) + + +class _PydanticWeakRef: + """Wrapper for `weakref.ref` that enables `pickle` serialization. + + Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related + to abstract base classes (`abc.ABC`). This class works around the issue by wrapping + `weakref.ref` instead of subclassing it. + + See https://github.com/pydantic/pydantic/issues/6763 for context. + + Semantics: + - If not pickled, behaves the same as a `weakref.ref`. + - If pickled along with the referenced object, the same `weakref.ref` behavior + will be maintained between them after unpickling. + - If pickled without the referenced object, after unpickling the underlying + reference will be cleared (`__call__` will always return `None`). + """ + + def __init__(self, obj: Any): + if obj is None: + # The object will be `None` upon deserialization if the serialized weakref + # had lost its underlying object. + self._wr = None + else: + self._wr = weakref.ref(obj) + + def __call__(self) -> Any: + if self._wr is None: + return None + else: + return self._wr() + + def __reduce__(self) -> tuple[Callable, tuple[weakref.ReferenceType | None]]: + return _PydanticWeakRef, (self(),) + + +def build_lenient_weakvaluedict(d: dict[str, Any] | None) -> dict[str, Any] | None: + """Takes an input dictionary, and produces a new value that (invertibly) replaces the values with weakrefs. + + We can't just use a WeakValueDictionary because many types (including int, str, etc.) can't be stored as values + in a WeakValueDictionary. + + The `unpack_lenient_weakvaluedict` function can be used to reverse this operation. + """ + if d is None: + return None + result = {} + for k, v in d.items(): + try: + proxy = _PydanticWeakRef(v) + except TypeError: + proxy = v + result[k] = proxy + return result + + +def unpack_lenient_weakvaluedict(d: dict[str, Any] | None) -> dict[str, Any] | None: + """Inverts the transform performed by `build_lenient_weakvaluedict`.""" + if d is None: + return None + + result = {} + for k, v in d.items(): + if isinstance(v, _PydanticWeakRef): + v = v() + if v is not None: + result[k] = v + else: + result[k] = v + return result + + +def default_ignored_types() -> tuple[type[Any], ...]: + from ..fields import ComputedFieldInfo + + return ( + FunctionType, + property, + classmethod, + staticmethod, + PydanticDescriptorProxy, + ComputedFieldInfo, + ValidateCallWrapper, + ) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_repr.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_repr.py new file mode 100644 index 0000000000000000000000000000000000000000..479b4479851c96997382c77147dfe0286c1f6e37 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_repr.py @@ -0,0 +1,117 @@ +"""Tools to provide pretty/human-readable display of objects.""" +from __future__ import annotations as _annotations + +import types +import typing +from typing import Any + +import typing_extensions + +from . import _typing_extra + +if typing.TYPE_CHECKING: + ReprArgs: typing_extensions.TypeAlias = 'typing.Iterable[tuple[str | None, Any]]' + RichReprResult: typing_extensions.TypeAlias = ( + 'typing.Iterable[Any | tuple[Any] | tuple[str, Any] | tuple[str, Any, Any]]' + ) + + +class PlainRepr(str): + """String class where repr doesn't include quotes. Useful with Representation when you want to return a string + representation of something that is valid (or pseudo-valid) python. + """ + + def __repr__(self) -> str: + return str(self) + + +class Representation: + # Mixin to provide `__str__`, `__repr__`, and `__pretty__` and `__rich_repr__` methods. + # `__pretty__` is used by [devtools](https://python-devtools.helpmanual.io/). + # `__rich_repr__` is used by [rich](https://rich.readthedocs.io/en/stable/pretty.html). + # (this is not a docstring to avoid adding a docstring to classes which inherit from Representation) + + # we don't want to use a type annotation here as it can break get_type_hints + __slots__ = tuple() # type: typing.Collection[str] + + def __repr_args__(self) -> ReprArgs: + """Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden. + + Can either return: + * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]` + * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]` + """ + attrs_names = self.__slots__ + if not attrs_names and hasattr(self, '__dict__'): + attrs_names = self.__dict__.keys() + attrs = ((s, getattr(self, s)) for s in attrs_names) + return [(a, v) for a, v in attrs if v is not None] + + def __repr_name__(self) -> str: + """Name of the instance's class, used in __repr__.""" + return self.__class__.__name__ + + def __repr_str__(self, join_str: str) -> str: + return join_str.join(repr(v) if a is None else f'{a}={v!r}' for a, v in self.__repr_args__()) + + def __pretty__(self, fmt: typing.Callable[[Any], Any], **kwargs: Any) -> typing.Generator[Any, None, None]: + """Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.""" + yield self.__repr_name__() + '(' + yield 1 + for name, value in self.__repr_args__(): + if name is not None: + yield name + '=' + yield fmt(value) + yield ',' + yield 0 + yield -1 + yield ')' + + def __rich_repr__(self) -> RichReprResult: + """Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.""" + for name, field_repr in self.__repr_args__(): + if name is None: + yield field_repr + else: + yield name, field_repr + + def __str__(self) -> str: + return self.__repr_str__(' ') + + def __repr__(self) -> str: + return f'{self.__repr_name__()}({self.__repr_str__(", ")})' + + +def display_as_type(obj: Any) -> str: + """Pretty representation of a type, should be as close as possible to the original type definition string. + + Takes some logic from `typing._type_repr`. + """ + if isinstance(obj, types.FunctionType): + return obj.__name__ + elif obj is ...: + return '...' + elif isinstance(obj, Representation): + return repr(obj) + elif isinstance(obj, typing_extensions.TypeAliasType): + return str(obj) + + if not isinstance(obj, (_typing_extra.typing_base, _typing_extra.WithArgsTypes, type)): + obj = obj.__class__ + + if _typing_extra.origin_is_union(typing_extensions.get_origin(obj)): + args = ', '.join(map(display_as_type, typing_extensions.get_args(obj))) + return f'Union[{args}]' + elif isinstance(obj, _typing_extra.WithArgsTypes): + if typing_extensions.get_origin(obj) == typing_extensions.Literal: + args = ', '.join(map(repr, typing_extensions.get_args(obj))) + else: + args = ', '.join(map(display_as_type, typing_extensions.get_args(obj))) + try: + return f'{obj.__qualname__}[{args}]' + except AttributeError: + return str(obj) # handles TypeAliasType in 3.12 + elif isinstance(obj, type): + return obj.__qualname__ + else: + return repr(obj).replace('typing.', '').replace('typing_extensions.', '') diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_schema_generation_shared.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_schema_generation_shared.py new file mode 100644 index 0000000000000000000000000000000000000000..2cf01c669f139f1ff794d573301a389c340e6b87 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_schema_generation_shared.py @@ -0,0 +1,124 @@ +"""Types and utility functions used by various other internal tools.""" +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Callable + +from pydantic_core import core_schema +from typing_extensions import Literal + +from ..annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler + +if TYPE_CHECKING: + from ..json_schema import GenerateJsonSchema, JsonSchemaValue + from ._core_utils import CoreSchemaOrField + from ._generate_schema import GenerateSchema + + GetJsonSchemaFunction = Callable[[CoreSchemaOrField, GetJsonSchemaHandler], JsonSchemaValue] + HandlerOverride = Callable[[CoreSchemaOrField], JsonSchemaValue] + + +class GenerateJsonSchemaHandler(GetJsonSchemaHandler): + """JsonSchemaHandler implementation that doesn't do ref unwrapping by default. + + This is used for any Annotated metadata so that we don't end up with conflicting + modifications to the definition schema. + + Used internally by Pydantic, please do not rely on this implementation. + See `GetJsonSchemaHandler` for the handler API. + """ + + def __init__(self, generate_json_schema: GenerateJsonSchema, handler_override: HandlerOverride | None) -> None: + self.generate_json_schema = generate_json_schema + self.handler = handler_override or generate_json_schema.generate_inner + self.mode = generate_json_schema.mode + + def __call__(self, core_schema: CoreSchemaOrField, /) -> JsonSchemaValue: + return self.handler(core_schema) + + def resolve_ref_schema(self, maybe_ref_json_schema: JsonSchemaValue) -> JsonSchemaValue: + """Resolves `$ref` in the json schema. + + This returns the input json schema if there is no `$ref` in json schema. + + Args: + maybe_ref_json_schema: The input json schema that may contains `$ref`. + + Returns: + Resolved json schema. + + Raises: + LookupError: If it can't find the definition for `$ref`. + """ + if '$ref' not in maybe_ref_json_schema: + return maybe_ref_json_schema + ref = maybe_ref_json_schema['$ref'] + json_schema = self.generate_json_schema.get_schema_from_definitions(ref) + if json_schema is None: + raise LookupError( + f'Could not find a ref for {ref}.' + ' Maybe you tried to call resolve_ref_schema from within a recursive model?' + ) + return json_schema + + +class CallbackGetCoreSchemaHandler(GetCoreSchemaHandler): + """Wrapper to use an arbitrary function as a `GetCoreSchemaHandler`. + + Used internally by Pydantic, please do not rely on this implementation. + See `GetCoreSchemaHandler` for the handler API. + """ + + def __init__( + self, + handler: Callable[[Any], core_schema.CoreSchema], + generate_schema: GenerateSchema, + ref_mode: Literal['to-def', 'unpack'] = 'to-def', + ) -> None: + self._handler = handler + self._generate_schema = generate_schema + self._ref_mode = ref_mode + + def __call__(self, source_type: Any, /) -> core_schema.CoreSchema: + schema = self._handler(source_type) + ref = schema.get('ref') + if self._ref_mode == 'to-def': + if ref is not None: + self._generate_schema.defs.definitions[ref] = schema + return core_schema.definition_reference_schema(ref) + return schema + else: # ref_mode = 'unpack + return self.resolve_ref_schema(schema) + + def _get_types_namespace(self) -> dict[str, Any] | None: + return self._generate_schema._types_namespace + + def generate_schema(self, source_type: Any, /) -> core_schema.CoreSchema: + return self._generate_schema.generate_schema(source_type) + + @property + def field_name(self) -> str | None: + return self._generate_schema.field_name_stack.get() + + def resolve_ref_schema(self, maybe_ref_schema: core_schema.CoreSchema) -> core_schema.CoreSchema: + """Resolves reference in the core schema. + + Args: + maybe_ref_schema: The input core schema that may contains reference. + + Returns: + Resolved core schema. + + Raises: + LookupError: If it can't find the definition for reference. + """ + if maybe_ref_schema['type'] == 'definition-ref': + ref = maybe_ref_schema['schema_ref'] + if ref not in self._generate_schema.defs.definitions: + raise LookupError( + f'Could not find a ref for {ref}.' + ' Maybe you tried to call resolve_ref_schema from within a recursive model?' + ) + return self._generate_schema.defs.definitions[ref] + elif maybe_ref_schema['type'] == 'definitions': + return self.resolve_ref_schema(maybe_ref_schema['schema']) + return maybe_ref_schema diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_signature.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_signature.py new file mode 100644 index 0000000000000000000000000000000000000000..816a1651b2981076b909cf11dd547b11d56ead62 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_signature.py @@ -0,0 +1,164 @@ +from __future__ import annotations + +import dataclasses +from inspect import Parameter, Signature, signature +from typing import TYPE_CHECKING, Any, Callable + +from pydantic_core import PydanticUndefined + +from ._config import ConfigWrapper +from ._utils import is_valid_identifier + +if TYPE_CHECKING: + from ..fields import FieldInfo + + +def _field_name_for_signature(field_name: str, field_info: FieldInfo) -> str: + """Extract the correct name to use for the field when generating a signature. + + Assuming the field has a valid alias, this will return the alias. Otherwise, it will return the field name. + First priority is given to the validation_alias, then the alias, then the field name. + + Args: + field_name: The name of the field + field_info: The corresponding FieldInfo object. + + Returns: + The correct name to use when generating a signature. + """ + + def _alias_if_valid(x: Any) -> str | None: + """Return the alias if it is a valid alias and identifier, else None.""" + return x if isinstance(x, str) and is_valid_identifier(x) else None + + return _alias_if_valid(field_info.alias) or _alias_if_valid(field_info.validation_alias) or field_name + + +def _process_param_defaults(param: Parameter) -> Parameter: + """Modify the signature for a parameter in a dataclass where the default value is a FieldInfo instance. + + Args: + param (Parameter): The parameter + + Returns: + Parameter: The custom processed parameter + """ + from ..fields import FieldInfo + + param_default = param.default + if isinstance(param_default, FieldInfo): + annotation = param.annotation + # Replace the annotation if appropriate + # inspect does "clever" things to show annotations as strings because we have + # `from __future__ import annotations` in main, we don't want that + if annotation == 'Any': + annotation = Any + + # Replace the field default + default = param_default.default + if default is PydanticUndefined: + if param_default.default_factory is PydanticUndefined: + default = Signature.empty + else: + # this is used by dataclasses to indicate a factory exists: + default = dataclasses._HAS_DEFAULT_FACTORY # type: ignore + return param.replace( + annotation=annotation, name=_field_name_for_signature(param.name, param_default), default=default + ) + return param + + +def _generate_signature_parameters( # noqa: C901 (ignore complexity, could use a refactor) + init: Callable[..., None], + fields: dict[str, FieldInfo], + config_wrapper: ConfigWrapper, +) -> dict[str, Parameter]: + """Generate a mapping of parameter names to Parameter objects for a pydantic BaseModel or dataclass.""" + from itertools import islice + + present_params = signature(init).parameters.values() + merged_params: dict[str, Parameter] = {} + var_kw = None + use_var_kw = False + + for param in islice(present_params, 1, None): # skip self arg + # inspect does "clever" things to show annotations as strings because we have + # `from __future__ import annotations` in main, we don't want that + if fields.get(param.name): + # exclude params with init=False + if getattr(fields[param.name], 'init', True) is False: + continue + param = param.replace(name=_field_name_for_signature(param.name, fields[param.name])) + if param.annotation == 'Any': + param = param.replace(annotation=Any) + if param.kind is param.VAR_KEYWORD: + var_kw = param + continue + merged_params[param.name] = param + + if var_kw: # if custom init has no var_kw, fields which are not declared in it cannot be passed through + allow_names = config_wrapper.populate_by_name + for field_name, field in fields.items(): + # when alias is a str it should be used for signature generation + param_name = _field_name_for_signature(field_name, field) + + if field_name in merged_params or param_name in merged_params: + continue + + if not is_valid_identifier(param_name): + if allow_names: + param_name = field_name + else: + use_var_kw = True + continue + + kwargs = {} if field.is_required() else {'default': field.get_default(call_default_factory=False)} + merged_params[param_name] = Parameter( + param_name, Parameter.KEYWORD_ONLY, annotation=field.rebuild_annotation(), **kwargs + ) + + if config_wrapper.extra == 'allow': + use_var_kw = True + + if var_kw and use_var_kw: + # Make sure the parameter for extra kwargs + # does not have the same name as a field + default_model_signature = [ + ('self', Parameter.POSITIONAL_ONLY), + ('data', Parameter.VAR_KEYWORD), + ] + if [(p.name, p.kind) for p in present_params] == default_model_signature: + # if this is the standard model signature, use extra_data as the extra args name + var_kw_name = 'extra_data' + else: + # else start from var_kw + var_kw_name = var_kw.name + + # generate a name that's definitely unique + while var_kw_name in fields: + var_kw_name += '_' + merged_params[var_kw_name] = var_kw.replace(name=var_kw_name) + + return merged_params + + +def generate_pydantic_signature( + init: Callable[..., None], fields: dict[str, FieldInfo], config_wrapper: ConfigWrapper, is_dataclass: bool = False +) -> Signature: + """Generate signature for a pydantic BaseModel or dataclass. + + Args: + init: The class init. + fields: The model fields. + config_wrapper: The config wrapper instance. + is_dataclass: Whether the model is a dataclass. + + Returns: + The dataclass/BaseModel subclass signature. + """ + merged_params = _generate_signature_parameters(init, fields, config_wrapper) + + if is_dataclass: + merged_params = {k: _process_param_defaults(v) for k, v in merged_params.items()} + + return Signature(parameters=list(merged_params.values()), return_annotation=None) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_std_types_schema.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_std_types_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..0b65a89ca04f69a24641b5f1ee9099d53e8db666 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_std_types_schema.py @@ -0,0 +1,715 @@ +"""Logic for generating pydantic-core schemas for standard library types. + +Import of this module is deferred since it contains imports of many standard library modules. +""" +from __future__ import annotations as _annotations + +import collections +import collections.abc +import dataclasses +import decimal +import inspect +import os +import typing +from enum import Enum +from functools import partial +from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network +from operator import attrgetter +from typing import Any, Callable, Iterable, Literal, TypeVar + +import typing_extensions +from pydantic_core import ( + CoreSchema, + MultiHostUrl, + PydanticCustomError, + PydanticOmit, + Url, + core_schema, +) +from typing_extensions import get_args, get_origin + +from pydantic.errors import PydanticSchemaGenerationError +from pydantic.fields import FieldInfo +from pydantic.types import Strict + +from ..config import ConfigDict +from ..json_schema import JsonSchemaValue +from . import _known_annotated_metadata, _typing_extra, _validators +from ._core_utils import get_type_ref +from ._internal_dataclass import slots_true +from ._schema_generation_shared import GetCoreSchemaHandler, GetJsonSchemaHandler + +if typing.TYPE_CHECKING: + from ._generate_schema import GenerateSchema + + StdSchemaFunction = Callable[[GenerateSchema, type[Any]], core_schema.CoreSchema] + + +@dataclasses.dataclass(**slots_true) +class SchemaTransformer: + get_core_schema: Callable[[Any, GetCoreSchemaHandler], CoreSchema] + get_json_schema: Callable[[CoreSchema, GetJsonSchemaHandler], JsonSchemaValue] + + def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema: + return self.get_core_schema(source_type, handler) + + def __get_pydantic_json_schema__(self, schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue: + return self.get_json_schema(schema, handler) + + +def get_enum_core_schema(enum_type: type[Enum], config: ConfigDict) -> CoreSchema: + cases: list[Any] = list(enum_type.__members__.values()) + + enum_ref = get_type_ref(enum_type) + description = None if not enum_type.__doc__ else inspect.cleandoc(enum_type.__doc__) + if description == 'An enumeration.': # This is the default value provided by enum.EnumMeta.__new__; don't use it + description = None + js_updates = {'title': enum_type.__name__, 'description': description} + js_updates = {k: v for k, v in js_updates.items() if v is not None} + + sub_type: Literal['str', 'int', 'float'] | None = None + if issubclass(enum_type, int): + sub_type = 'int' + value_ser_type: core_schema.SerSchema = core_schema.simple_ser_schema('int') + elif issubclass(enum_type, str): + # this handles `StrEnum` (3.11 only), and also `Foobar(str, Enum)` + sub_type = 'str' + value_ser_type = core_schema.simple_ser_schema('str') + elif issubclass(enum_type, float): + sub_type = 'float' + value_ser_type = core_schema.simple_ser_schema('float') + else: + # TODO this is an ugly hack, how do we trigger an Any schema for serialization? + value_ser_type = core_schema.plain_serializer_function_ser_schema(lambda x: x) + + if cases: + + def get_json_schema(schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue: + json_schema = handler(schema) + original_schema = handler.resolve_ref_schema(json_schema) + original_schema.update(js_updates) + return json_schema + + # we don't want to add the missing to the schema if it's the default one + default_missing = getattr(enum_type._missing_, '__func__', None) == Enum._missing_.__func__ # type: ignore + enum_schema = core_schema.enum_schema( + enum_type, + cases, + sub_type=sub_type, + missing=None if default_missing else enum_type._missing_, + ref=enum_ref, + metadata={'pydantic_js_functions': [get_json_schema]}, + ) + + if config.get('use_enum_values', False): + enum_schema = core_schema.no_info_after_validator_function( + attrgetter('value'), enum_schema, serialization=value_ser_type + ) + + return enum_schema + + else: + + def get_json_schema_no_cases(_, handler: GetJsonSchemaHandler) -> JsonSchemaValue: + json_schema = handler(core_schema.enum_schema(enum_type, cases, sub_type=sub_type, ref=enum_ref)) + original_schema = handler.resolve_ref_schema(json_schema) + original_schema.update(js_updates) + return json_schema + + # Use an isinstance check for enums with no cases. + # The most important use case for this is creating TypeVar bounds for generics that should + # be restricted to enums. This is more consistent than it might seem at first, since you can only + # subclass enum.Enum (or subclasses of enum.Enum) if all parent classes have no cases. + # We use the get_json_schema function when an Enum subclass has been declared with no cases + # so that we can still generate a valid json schema. + return core_schema.is_instance_schema( + enum_type, + metadata={'pydantic_js_functions': [get_json_schema_no_cases]}, + ) + + +@dataclasses.dataclass(**slots_true) +class InnerSchemaValidator: + """Use a fixed CoreSchema, avoiding interference from outward annotations.""" + + core_schema: CoreSchema + js_schema: JsonSchemaValue | None = None + js_core_schema: CoreSchema | None = None + js_schema_update: JsonSchemaValue | None = None + + def __get_pydantic_json_schema__(self, _schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue: + if self.js_schema is not None: + return self.js_schema + js_schema = handler(self.js_core_schema or self.core_schema) + if self.js_schema_update is not None: + js_schema.update(self.js_schema_update) + return js_schema + + def __get_pydantic_core_schema__(self, _source_type: Any, _handler: GetCoreSchemaHandler) -> CoreSchema: + return self.core_schema + + +def decimal_prepare_pydantic_annotations( + source: Any, annotations: Iterable[Any], config: ConfigDict +) -> tuple[Any, list[Any]] | None: + if source is not decimal.Decimal: + return None + + metadata, remaining_annotations = _known_annotated_metadata.collect_known_metadata(annotations) + + config_allow_inf_nan = config.get('allow_inf_nan') + if config_allow_inf_nan is not None: + metadata.setdefault('allow_inf_nan', config_allow_inf_nan) + + _known_annotated_metadata.check_metadata( + metadata, {*_known_annotated_metadata.FLOAT_CONSTRAINTS, 'max_digits', 'decimal_places'}, decimal.Decimal + ) + return source, [InnerSchemaValidator(core_schema.decimal_schema(**metadata)), *remaining_annotations] + + +def datetime_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + import datetime + + metadata, remaining_annotations = _known_annotated_metadata.collect_known_metadata(annotations) + if source_type is datetime.date: + sv = InnerSchemaValidator(core_schema.date_schema(**metadata)) + elif source_type is datetime.datetime: + sv = InnerSchemaValidator(core_schema.datetime_schema(**metadata)) + elif source_type is datetime.time: + sv = InnerSchemaValidator(core_schema.time_schema(**metadata)) + elif source_type is datetime.timedelta: + sv = InnerSchemaValidator(core_schema.timedelta_schema(**metadata)) + else: + return None + # check now that we know the source type is correct + _known_annotated_metadata.check_metadata(metadata, _known_annotated_metadata.DATE_TIME_CONSTRAINTS, source_type) + return (source_type, [sv, *remaining_annotations]) + + +def uuid_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + # UUIDs have no constraints - they are fixed length, constructing a UUID instance checks the length + + from uuid import UUID + + if source_type is not UUID: + return None + + return (source_type, [InnerSchemaValidator(core_schema.uuid_schema()), *annotations]) + + +def path_schema_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + import pathlib + + if source_type not in { + os.PathLike, + pathlib.Path, + pathlib.PurePath, + pathlib.PosixPath, + pathlib.PurePosixPath, + pathlib.PureWindowsPath, + }: + return None + + metadata, remaining_annotations = _known_annotated_metadata.collect_known_metadata(annotations) + _known_annotated_metadata.check_metadata(metadata, _known_annotated_metadata.STR_CONSTRAINTS, source_type) + + construct_path = pathlib.PurePath if source_type is os.PathLike else source_type + + def path_validator(input_value: str) -> os.PathLike[Any]: + try: + return construct_path(input_value) + except TypeError as e: + raise PydanticCustomError('path_type', 'Input is not a valid path') from e + + constrained_str_schema = core_schema.str_schema(**metadata) + + instance_schema = core_schema.json_or_python_schema( + json_schema=core_schema.no_info_after_validator_function(path_validator, constrained_str_schema), + python_schema=core_schema.is_instance_schema(source_type), + ) + + strict: bool | None = None + for annotation in annotations: + if isinstance(annotation, Strict): + strict = annotation.strict + + schema = core_schema.lax_or_strict_schema( + lax_schema=core_schema.union_schema( + [ + instance_schema, + core_schema.no_info_after_validator_function(path_validator, constrained_str_schema), + ], + custom_error_type='path_type', + custom_error_message='Input is not a valid path', + strict=True, + ), + strict_schema=instance_schema, + serialization=core_schema.to_string_ser_schema(), + strict=strict, + ) + + return ( + source_type, + [ + InnerSchemaValidator(schema, js_core_schema=constrained_str_schema, js_schema_update={'format': 'path'}), + *remaining_annotations, + ], + ) + + +def dequeue_validator( + input_value: Any, handler: core_schema.ValidatorFunctionWrapHandler, maxlen: None | int +) -> collections.deque[Any]: + if isinstance(input_value, collections.deque): + maxlens = [v for v in (input_value.maxlen, maxlen) if v is not None] + if maxlens: + maxlen = min(maxlens) + return collections.deque(handler(input_value), maxlen=maxlen) + else: + return collections.deque(handler(input_value), maxlen=maxlen) + + +def serialize_sequence_via_list( + v: Any, handler: core_schema.SerializerFunctionWrapHandler, info: core_schema.SerializationInfo +) -> Any: + items: list[Any] = [] + + mapped_origin = SEQUENCE_ORIGIN_MAP.get(type(v), None) + if mapped_origin is None: + # we shouldn't hit this branch, should probably add a serialization error or something + return v + + for index, item in enumerate(v): + try: + v = handler(item, index) + except PydanticOmit: + pass + else: + items.append(v) + + if info.mode_is_json(): + return items + else: + return mapped_origin(items) + + +@dataclasses.dataclass(**slots_true) +class SequenceValidator: + mapped_origin: type[Any] + item_source_type: type[Any] + min_length: int | None = None + max_length: int | None = None + strict: bool | None = None + + def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema: + if self.item_source_type is Any: + items_schema = None + else: + items_schema = handler.generate_schema(self.item_source_type) + + metadata = {'min_length': self.min_length, 'max_length': self.max_length, 'strict': self.strict} + + if self.mapped_origin in (list, set, frozenset): + if self.mapped_origin is list: + constrained_schema = core_schema.list_schema(items_schema, **metadata) + elif self.mapped_origin is set: + constrained_schema = core_schema.set_schema(items_schema, **metadata) + else: + assert self.mapped_origin is frozenset # safety check in case we forget to add a case + constrained_schema = core_schema.frozenset_schema(items_schema, **metadata) + + schema = constrained_schema + else: + # safety check in case we forget to add a case + assert self.mapped_origin in (collections.deque, collections.Counter) + + if self.mapped_origin is collections.deque: + # if we have a MaxLen annotation might as well set that as the default maxlen on the deque + # this lets us re-use existing metadata annotations to let users set the maxlen on a dequeue + # that e.g. comes from JSON + coerce_instance_wrap = partial( + core_schema.no_info_wrap_validator_function, + partial(dequeue_validator, maxlen=metadata.get('max_length', None)), + ) + else: + coerce_instance_wrap = partial(core_schema.no_info_after_validator_function, self.mapped_origin) + + # we have to use a lax list schema here, because we need to validate the deque's + # items via a list schema, but it's ok if the deque itself is not a list (same for Counter) + metadata_with_strict_override = {**metadata, 'strict': False} + constrained_schema = core_schema.list_schema(items_schema, **metadata_with_strict_override) + + check_instance = core_schema.json_or_python_schema( + json_schema=core_schema.list_schema(), + python_schema=core_schema.is_instance_schema(self.mapped_origin), + ) + + serialization = core_schema.wrap_serializer_function_ser_schema( + serialize_sequence_via_list, schema=items_schema or core_schema.any_schema(), info_arg=True + ) + + strict = core_schema.chain_schema([check_instance, coerce_instance_wrap(constrained_schema)]) + + if metadata.get('strict', False): + schema = strict + else: + lax = coerce_instance_wrap(constrained_schema) + schema = core_schema.lax_or_strict_schema(lax_schema=lax, strict_schema=strict) + schema['serialization'] = serialization + + return schema + + +SEQUENCE_ORIGIN_MAP: dict[Any, Any] = { + typing.Deque: collections.deque, + collections.deque: collections.deque, + list: list, + typing.List: list, + set: set, + typing.AbstractSet: set, + typing.Set: set, + frozenset: frozenset, + typing.FrozenSet: frozenset, + typing.Sequence: list, + typing.MutableSequence: list, + typing.MutableSet: set, + # this doesn't handle subclasses of these + # parametrized typing.Set creates one of these + collections.abc.MutableSet: set, + collections.abc.Set: frozenset, +} + + +def identity(s: CoreSchema) -> CoreSchema: + return s + + +def sequence_like_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + origin: Any = get_origin(source_type) + + mapped_origin = SEQUENCE_ORIGIN_MAP.get(origin, None) if origin else SEQUENCE_ORIGIN_MAP.get(source_type, None) + if mapped_origin is None: + return None + + args = get_args(source_type) + + if not args: + args = (Any,) + elif len(args) != 1: + raise ValueError('Expected sequence to have exactly 1 generic parameter') + + item_source_type = args[0] + + metadata, remaining_annotations = _known_annotated_metadata.collect_known_metadata(annotations) + _known_annotated_metadata.check_metadata(metadata, _known_annotated_metadata.SEQUENCE_CONSTRAINTS, source_type) + + return (source_type, [SequenceValidator(mapped_origin, item_source_type, **metadata), *remaining_annotations]) + + +MAPPING_ORIGIN_MAP: dict[Any, Any] = { + typing.DefaultDict: collections.defaultdict, + collections.defaultdict: collections.defaultdict, + collections.OrderedDict: collections.OrderedDict, + typing_extensions.OrderedDict: collections.OrderedDict, + dict: dict, + typing.Dict: dict, + collections.Counter: collections.Counter, + typing.Counter: collections.Counter, + # this doesn't handle subclasses of these + typing.Mapping: dict, + typing.MutableMapping: dict, + # parametrized typing.{Mutable}Mapping creates one of these + collections.abc.MutableMapping: dict, + collections.abc.Mapping: dict, +} + + +def defaultdict_validator( + input_value: Any, handler: core_schema.ValidatorFunctionWrapHandler, default_default_factory: Callable[[], Any] +) -> collections.defaultdict[Any, Any]: + if isinstance(input_value, collections.defaultdict): + default_factory = input_value.default_factory + return collections.defaultdict(default_factory, handler(input_value)) + else: + return collections.defaultdict(default_default_factory, handler(input_value)) + + +def get_defaultdict_default_default_factory(values_source_type: Any) -> Callable[[], Any]: + def infer_default() -> Callable[[], Any]: + allowed_default_types: dict[Any, Any] = { + typing.Tuple: tuple, + tuple: tuple, + collections.abc.Sequence: tuple, + collections.abc.MutableSequence: list, + typing.List: list, + list: list, + typing.Sequence: list, + typing.Set: set, + set: set, + typing.MutableSet: set, + collections.abc.MutableSet: set, + collections.abc.Set: frozenset, + typing.MutableMapping: dict, + typing.Mapping: dict, + collections.abc.Mapping: dict, + collections.abc.MutableMapping: dict, + float: float, + int: int, + str: str, + bool: bool, + } + values_type_origin = get_origin(values_source_type) or values_source_type + instructions = 'set using `DefaultDict[..., Annotated[..., Field(default_factory=...)]]`' + if isinstance(values_type_origin, TypeVar): + + def type_var_default_factory() -> None: + raise RuntimeError( + 'Generic defaultdict cannot be used without a concrete value type or an' + ' explicit default factory, ' + instructions + ) + + return type_var_default_factory + elif values_type_origin not in allowed_default_types: + # a somewhat subjective set of types that have reasonable default values + allowed_msg = ', '.join([t.__name__ for t in set(allowed_default_types.values())]) + raise PydanticSchemaGenerationError( + f'Unable to infer a default factory for keys of type {values_source_type}.' + f' Only {allowed_msg} are supported, other types require an explicit default factory' + ' ' + instructions + ) + return allowed_default_types[values_type_origin] + + # Assume Annotated[..., Field(...)] + if _typing_extra.is_annotated(values_source_type): + field_info = next((v for v in get_args(values_source_type) if isinstance(v, FieldInfo)), None) + else: + field_info = None + if field_info and field_info.default_factory: + default_default_factory = field_info.default_factory + else: + default_default_factory = infer_default() + return default_default_factory + + +@dataclasses.dataclass(**slots_true) +class MappingValidator: + mapped_origin: type[Any] + keys_source_type: type[Any] + values_source_type: type[Any] + min_length: int | None = None + max_length: int | None = None + strict: bool = False + + def serialize_mapping_via_dict(self, v: Any, handler: core_schema.SerializerFunctionWrapHandler) -> Any: + return handler(v) + + def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema: + if self.keys_source_type is Any: + keys_schema = None + else: + keys_schema = handler.generate_schema(self.keys_source_type) + if self.values_source_type is Any: + values_schema = None + else: + values_schema = handler.generate_schema(self.values_source_type) + + metadata = {'min_length': self.min_length, 'max_length': self.max_length, 'strict': self.strict} + + if self.mapped_origin is dict: + schema = core_schema.dict_schema(keys_schema, values_schema, **metadata) + else: + constrained_schema = core_schema.dict_schema(keys_schema, values_schema, **metadata) + check_instance = core_schema.json_or_python_schema( + json_schema=core_schema.dict_schema(), + python_schema=core_schema.is_instance_schema(self.mapped_origin), + ) + + if self.mapped_origin is collections.defaultdict: + default_default_factory = get_defaultdict_default_default_factory(self.values_source_type) + coerce_instance_wrap = partial( + core_schema.no_info_wrap_validator_function, + partial(defaultdict_validator, default_default_factory=default_default_factory), + ) + else: + coerce_instance_wrap = partial(core_schema.no_info_after_validator_function, self.mapped_origin) + + serialization = core_schema.wrap_serializer_function_ser_schema( + self.serialize_mapping_via_dict, + schema=core_schema.dict_schema( + keys_schema or core_schema.any_schema(), values_schema or core_schema.any_schema() + ), + info_arg=False, + ) + + strict = core_schema.chain_schema([check_instance, coerce_instance_wrap(constrained_schema)]) + + if metadata.get('strict', False): + schema = strict + else: + lax = coerce_instance_wrap(constrained_schema) + schema = core_schema.lax_or_strict_schema(lax_schema=lax, strict_schema=strict) + schema['serialization'] = serialization + + return schema + + +def mapping_like_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + origin: Any = get_origin(source_type) + + mapped_origin = MAPPING_ORIGIN_MAP.get(origin, None) if origin else MAPPING_ORIGIN_MAP.get(source_type, None) + if mapped_origin is None: + return None + + args = get_args(source_type) + + if not args: + args = (Any, Any) + elif mapped_origin is collections.Counter: + # a single generic + if len(args) != 1: + raise ValueError('Expected Counter to have exactly 1 generic parameter') + args = (args[0], int) # keys are always an int + elif len(args) != 2: + raise ValueError('Expected mapping to have exactly 2 generic parameters') + + keys_source_type, values_source_type = args + + metadata, remaining_annotations = _known_annotated_metadata.collect_known_metadata(annotations) + _known_annotated_metadata.check_metadata(metadata, _known_annotated_metadata.SEQUENCE_CONSTRAINTS, source_type) + + return ( + source_type, + [ + MappingValidator(mapped_origin, keys_source_type, values_source_type, **metadata), + *remaining_annotations, + ], + ) + + +def ip_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + def make_strict_ip_schema(tp: type[Any]) -> CoreSchema: + return core_schema.json_or_python_schema( + json_schema=core_schema.no_info_after_validator_function(tp, core_schema.str_schema()), + python_schema=core_schema.is_instance_schema(tp), + ) + + if source_type is IPv4Address: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v4_address_validator), + strict_schema=make_strict_ip_schema(IPv4Address), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv4'}, + ), + *annotations, + ] + if source_type is IPv4Network: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v4_network_validator), + strict_schema=make_strict_ip_schema(IPv4Network), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv4network'}, + ), + *annotations, + ] + if source_type is IPv4Interface: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v4_interface_validator), + strict_schema=make_strict_ip_schema(IPv4Interface), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv4interface'}, + ), + *annotations, + ] + + if source_type is IPv6Address: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v6_address_validator), + strict_schema=make_strict_ip_schema(IPv6Address), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv6'}, + ), + *annotations, + ] + if source_type is IPv6Network: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v6_network_validator), + strict_schema=make_strict_ip_schema(IPv6Network), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv6network'}, + ), + *annotations, + ] + if source_type is IPv6Interface: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.lax_or_strict_schema( + lax_schema=core_schema.no_info_plain_validator_function(_validators.ip_v6_interface_validator), + strict_schema=make_strict_ip_schema(IPv6Interface), + serialization=core_schema.to_string_ser_schema(), + ), + lambda _1, _2: {'type': 'string', 'format': 'ipv6interface'}, + ), + *annotations, + ] + + return None + + +def url_prepare_pydantic_annotations( + source_type: Any, annotations: Iterable[Any], _config: ConfigDict +) -> tuple[Any, list[Any]] | None: + if source_type is Url: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.url_schema(), + lambda cs, handler: handler(cs), + ), + *annotations, + ] + if source_type is MultiHostUrl: + return source_type, [ + SchemaTransformer( + lambda _1, _2: core_schema.multi_host_url_schema(), + lambda cs, handler: handler(cs), + ), + *annotations, + ] + + +PREPARE_METHODS: tuple[Callable[[Any, Iterable[Any], ConfigDict], tuple[Any, list[Any]] | None], ...] = ( + decimal_prepare_pydantic_annotations, + sequence_like_prepare_pydantic_annotations, + datetime_prepare_pydantic_annotations, + uuid_prepare_pydantic_annotations, + path_schema_prepare_pydantic_annotations, + mapping_like_prepare_pydantic_annotations, + ip_prepare_pydantic_annotations, + url_prepare_pydantic_annotations, +) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_typing_extra.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_typing_extra.py new file mode 100644 index 0000000000000000000000000000000000000000..087353713f67a13e1f1f75231205a4ad27741a6e --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_typing_extra.py @@ -0,0 +1,494 @@ +"""Logic for interacting with type annotations, mostly extensions, shims and hacks to wrap python's typing module.""" +from __future__ import annotations as _annotations + +import dataclasses +import re +import sys +import types +import typing +import warnings +from collections.abc import Callable +from functools import partial +from types import GetSetDescriptorType +from typing import TYPE_CHECKING, Any, Final + +from typing_extensions import Annotated, Literal, TypeAliasType, TypeGuard, deprecated, get_args, get_origin + +if TYPE_CHECKING: + from ._dataclasses import StandardDataclass + +try: + from typing import _TypingBase # type: ignore[attr-defined] +except ImportError: + from typing import _Final as _TypingBase # type: ignore[attr-defined] + +typing_base = _TypingBase + + +if sys.version_info < (3, 9): + # python < 3.9 does not have GenericAlias (list[int], tuple[str, ...] and so on) + TypingGenericAlias = () +else: + from typing import GenericAlias as TypingGenericAlias # type: ignore + + +if sys.version_info < (3, 11): + from typing_extensions import NotRequired, Required +else: + from typing import NotRequired, Required # noqa: F401 + + +if sys.version_info < (3, 10): + + def origin_is_union(tp: type[Any] | None) -> bool: + return tp is typing.Union + + WithArgsTypes = (TypingGenericAlias,) + +else: + + def origin_is_union(tp: type[Any] | None) -> bool: + return tp is typing.Union or tp is types.UnionType + + WithArgsTypes = typing._GenericAlias, types.GenericAlias, types.UnionType # type: ignore[attr-defined] + + +if sys.version_info < (3, 10): + NoneType = type(None) + EllipsisType = type(Ellipsis) +else: + from types import NoneType as NoneType + + +LITERAL_TYPES: set[Any] = {Literal} +if hasattr(typing, 'Literal'): + LITERAL_TYPES.add(typing.Literal) # type: ignore + +# Check if `deprecated` is a type to prevent errors when using typing_extensions < 4.9.0 +DEPRECATED_TYPES: tuple[Any, ...] = (deprecated,) if isinstance(deprecated, type) else () +if hasattr(warnings, 'deprecated'): + DEPRECATED_TYPES = (*DEPRECATED_TYPES, warnings.deprecated) # type: ignore + +NONE_TYPES: tuple[Any, ...] = (None, NoneType, *(tp[None] for tp in LITERAL_TYPES)) + + +TypeVarType = Any # since mypy doesn't allow the use of TypeVar as a type + + +def is_none_type(type_: Any) -> bool: + return type_ in NONE_TYPES + + +def is_callable_type(type_: type[Any]) -> bool: + return type_ is Callable or get_origin(type_) is Callable + + +def is_literal_type(type_: type[Any]) -> bool: + return Literal is not None and get_origin(type_) in LITERAL_TYPES + + +def is_deprecated_instance(instance: Any) -> TypeGuard[deprecated]: + return isinstance(instance, DEPRECATED_TYPES) + + +def literal_values(type_: type[Any]) -> tuple[Any, ...]: + return get_args(type_) + + +def all_literal_values(type_: type[Any]) -> list[Any]: + """This method is used to retrieve all Literal values as + Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586) + e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`. + """ + if not is_literal_type(type_): + return [type_] + + values = literal_values(type_) + return list(x for value in values for x in all_literal_values(value)) + + +def is_annotated(ann_type: Any) -> bool: + from ._utils import lenient_issubclass + + origin = get_origin(ann_type) + return origin is not None and lenient_issubclass(origin, Annotated) + + +def is_namedtuple(type_: type[Any]) -> bool: + """Check if a given class is a named tuple. + It can be either a `typing.NamedTuple` or `collections.namedtuple`. + """ + from ._utils import lenient_issubclass + + return lenient_issubclass(type_, tuple) and hasattr(type_, '_fields') + + +test_new_type = typing.NewType('test_new_type', str) + + +def is_new_type(type_: type[Any]) -> bool: + """Check whether type_ was created using typing.NewType. + + Can't use isinstance because it fails <3.10. + """ + return isinstance(type_, test_new_type.__class__) and hasattr(type_, '__supertype__') # type: ignore[arg-type] + + +def _check_classvar(v: type[Any] | None) -> bool: + if v is None: + return False + + return v.__class__ == typing.ClassVar.__class__ and getattr(v, '_name', None) == 'ClassVar' + + +def is_classvar(ann_type: type[Any]) -> bool: + if _check_classvar(ann_type) or _check_classvar(get_origin(ann_type)): + return True + + # this is an ugly workaround for class vars that contain forward references and are therefore themselves + # forward references, see #3679 + if ann_type.__class__ == typing.ForwardRef and re.match( + r'(\w+\.)?ClassVar\[', + ann_type.__forward_arg__, # type: ignore + ): + return True + + return False + + +def _check_finalvar(v: type[Any] | None) -> bool: + """Check if a given type is a `typing.Final` type.""" + if v is None: + return False + + return v.__class__ == Final.__class__ and (sys.version_info < (3, 8) or getattr(v, '_name', None) == 'Final') + + +def is_finalvar(ann_type: Any) -> bool: + return _check_finalvar(ann_type) or _check_finalvar(get_origin(ann_type)) + + +def parent_frame_namespace(*, parent_depth: int = 2) -> dict[str, Any] | None: + """We allow use of items in parent namespace to get around the issue with `get_type_hints` only looking in the + global module namespace. See https://github.com/pydantic/pydantic/issues/2678#issuecomment-1008139014 -> Scope + and suggestion at the end of the next comment by @gvanrossum. + + WARNING 1: it matters exactly where this is called. By default, this function will build a namespace from the + parent of where it is called. + + WARNING 2: this only looks in the parent namespace, not other parents since (AFAIK) there's no way to collect a + dict of exactly what's in scope. Using `f_back` would work sometimes but would be very wrong and confusing in many + other cases. See https://discuss.python.org/t/is-there-a-way-to-access-parent-nested-namespaces/20659. + """ + frame = sys._getframe(parent_depth) + # if f_back is None, it's the global module namespace and we don't need to include it here + if frame.f_back is None: + return None + else: + return frame.f_locals + + +def add_module_globals(obj: Any, globalns: dict[str, Any] | None = None) -> dict[str, Any]: + module_name = getattr(obj, '__module__', None) + if module_name: + try: + module_globalns = sys.modules[module_name].__dict__ + except KeyError: + # happens occasionally, see https://github.com/pydantic/pydantic/issues/2363 + pass + else: + if globalns: + return {**module_globalns, **globalns} + else: + # copy module globals to make sure it can't be updated later + return module_globalns.copy() + + return globalns or {} + + +def get_cls_types_namespace(cls: type[Any], parent_namespace: dict[str, Any] | None = None) -> dict[str, Any]: + ns = add_module_globals(cls, parent_namespace) + ns[cls.__name__] = cls + return ns + + +def get_cls_type_hints_lenient(obj: Any, globalns: dict[str, Any] | None = None) -> dict[str, Any]: + """Collect annotations from a class, including those from parent classes. + + Unlike `typing.get_type_hints`, this function will not error if a forward reference is not resolvable. + """ + hints = {} + for base in reversed(obj.__mro__): + ann = base.__dict__.get('__annotations__') + localns = dict(vars(base)) + if ann is not None and ann is not GetSetDescriptorType: + for name, value in ann.items(): + hints[name] = eval_type_lenient(value, globalns, localns) + return hints + + +def eval_type_lenient(value: Any, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None) -> Any: + """Behaves like typing._eval_type, except it won't raise an error if a forward reference can't be resolved.""" + if value is None: + value = NoneType + elif isinstance(value, str): + value = _make_forward_ref(value, is_argument=False, is_class=True) + + try: + return eval_type_backport(value, globalns, localns) + except NameError: + # the point of this function is to be tolerant to this case + return value + + +def eval_type_backport( + value: Any, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None +) -> Any: + """Like `typing._eval_type`, but falls back to the `eval_type_backport` package if it's + installed to let older Python versions use newer typing features. + Specifically, this transforms `X | Y` into `typing.Union[X, Y]` + and `list[X]` into `typing.List[X]` etc. (for all the types made generic in PEP 585) + if the original syntax is not supported in the current Python version. + """ + try: + return typing._eval_type( # type: ignore + value, globalns, localns + ) + except TypeError as e: + if not (isinstance(value, typing.ForwardRef) and is_backport_fixable_error(e)): + raise + try: + from eval_type_backport import eval_type_backport + except ImportError: + raise TypeError( + f'You have a type annotation {value.__forward_arg__!r} ' + f'which makes use of newer typing features than are supported in your version of Python. ' + f'To handle this error, you should either remove the use of new syntax ' + f'or install the `eval_type_backport` package.' + ) from e + + return eval_type_backport(value, globalns, localns, try_default=False) + + +def is_backport_fixable_error(e: TypeError) -> bool: + msg = str(e) + return msg.startswith('unsupported operand type(s) for |: ') or "' object is not subscriptable" in msg + + +def get_function_type_hints( + function: Callable[..., Any], *, include_keys: set[str] | None = None, types_namespace: dict[str, Any] | None = None +) -> dict[str, Any]: + """Like `typing.get_type_hints`, but doesn't convert `X` to `Optional[X]` if the default value is `None`, also + copes with `partial`. + """ + try: + if isinstance(function, partial): + annotations = function.func.__annotations__ + else: + annotations = function.__annotations__ + except AttributeError: + type_hints = get_type_hints(function) + if isinstance(function, type): + type_hints.setdefault('return', type) + return type_hints + + globalns = add_module_globals(function) + type_hints = {} + for name, value in annotations.items(): + if include_keys is not None and name not in include_keys: + continue + if value is None: + value = NoneType + elif isinstance(value, str): + value = _make_forward_ref(value) + + type_hints[name] = eval_type_backport(value, globalns, types_namespace) + + return type_hints + + +if sys.version_info < (3, 9, 8) or (3, 10) <= sys.version_info < (3, 10, 1): + + def _make_forward_ref( + arg: Any, + is_argument: bool = True, + *, + is_class: bool = False, + ) -> typing.ForwardRef: + """Wrapper for ForwardRef that accounts for the `is_class` argument missing in older versions. + The `module` argument is omitted as it breaks <3.9.8, =3.10.0 and isn't used in the calls below. + + See https://github.com/python/cpython/pull/28560 for some background. + The backport happened on 3.9.8, see: + https://github.com/pydantic/pydantic/discussions/6244#discussioncomment-6275458, + and on 3.10.1 for the 3.10 branch, see: + https://github.com/pydantic/pydantic/issues/6912 + + Implemented as EAFP with memory. + """ + return typing.ForwardRef(arg, is_argument) + +else: + _make_forward_ref = typing.ForwardRef + + +if sys.version_info >= (3, 10): + get_type_hints = typing.get_type_hints + +else: + """ + For older versions of python, we have a custom implementation of `get_type_hints` which is a close as possible to + the implementation in CPython 3.10.8. + """ + + @typing.no_type_check + def get_type_hints( # noqa: C901 + obj: Any, + globalns: dict[str, Any] | None = None, + localns: dict[str, Any] | None = None, + include_extras: bool = False, + ) -> dict[str, Any]: # pragma: no cover + """Taken verbatim from python 3.10.8 unchanged, except: + * type annotations of the function definition above. + * prefixing `typing.` where appropriate + * Use `_make_forward_ref` instead of `typing.ForwardRef` to handle the `is_class` argument. + + https://github.com/python/cpython/blob/aaaf5174241496afca7ce4d4584570190ff972fe/Lib/typing.py#L1773-L1875 + + DO NOT CHANGE THIS METHOD UNLESS ABSOLUTELY NECESSARY. + ====================================================== + + Return type hints for an object. + + This is often the same as obj.__annotations__, but it handles + forward references encoded as string literals, adds Optional[t] if a + default value equal to None is set and recursively replaces all + 'Annotated[T, ...]' with 'T' (unless 'include_extras=True'). + + The argument may be a module, class, method, or function. The annotations + are returned as a dictionary. For classes, annotations include also + inherited members. + + TypeError is raised if the argument is not of a type that can contain + annotations, and an empty dictionary is returned if no annotations are + present. + + BEWARE -- the behavior of globalns and localns is counterintuitive + (unless you are familiar with how eval() and exec() work). The + search order is locals first, then globals. + + - If no dict arguments are passed, an attempt is made to use the + globals from obj (or the respective module's globals for classes), + and these are also used as the locals. If the object does not appear + to have globals, an empty dictionary is used. For classes, the search + order is globals first then locals. + + - If one dict argument is passed, it is used for both globals and + locals. + + - If two dict arguments are passed, they specify globals and + locals, respectively. + """ + if getattr(obj, '__no_type_check__', None): + return {} + # Classes require a special treatment. + if isinstance(obj, type): + hints = {} + for base in reversed(obj.__mro__): + if globalns is None: + base_globals = getattr(sys.modules.get(base.__module__, None), '__dict__', {}) + else: + base_globals = globalns + ann = base.__dict__.get('__annotations__', {}) + if isinstance(ann, types.GetSetDescriptorType): + ann = {} + base_locals = dict(vars(base)) if localns is None else localns + if localns is None and globalns is None: + # This is surprising, but required. Before Python 3.10, + # get_type_hints only evaluated the globalns of + # a class. To maintain backwards compatibility, we reverse + # the globalns and localns order so that eval() looks into + # *base_globals* first rather than *base_locals*. + # This only affects ForwardRefs. + base_globals, base_locals = base_locals, base_globals + for name, value in ann.items(): + if value is None: + value = type(None) + if isinstance(value, str): + value = _make_forward_ref(value, is_argument=False, is_class=True) + + value = eval_type_backport(value, base_globals, base_locals) + hints[name] = value + if not include_extras and hasattr(typing, '_strip_annotations'): + return { + k: typing._strip_annotations(t) # type: ignore + for k, t in hints.items() + } + else: + return hints + + if globalns is None: + if isinstance(obj, types.ModuleType): + globalns = obj.__dict__ + else: + nsobj = obj + # Find globalns for the unwrapped object. + while hasattr(nsobj, '__wrapped__'): + nsobj = nsobj.__wrapped__ + globalns = getattr(nsobj, '__globals__', {}) + if localns is None: + localns = globalns + elif localns is None: + localns = globalns + hints = getattr(obj, '__annotations__', None) + if hints is None: + # Return empty annotations for something that _could_ have them. + if isinstance(obj, typing._allowed_types): # type: ignore + return {} + else: + raise TypeError(f'{obj!r} is not a module, class, method, ' 'or function.') + defaults = typing._get_defaults(obj) # type: ignore + hints = dict(hints) + for name, value in hints.items(): + if value is None: + value = type(None) + if isinstance(value, str): + # class-level forward refs were handled above, this must be either + # a module-level annotation or a function argument annotation + + value = _make_forward_ref( + value, + is_argument=not isinstance(obj, types.ModuleType), + is_class=False, + ) + value = eval_type_backport(value, globalns, localns) + if name in defaults and defaults[name] is None: + value = typing.Optional[value] + hints[name] = value + return hints if include_extras else {k: typing._strip_annotations(t) for k, t in hints.items()} # type: ignore + + +def is_dataclass(_cls: type[Any]) -> TypeGuard[type[StandardDataclass]]: + # The dataclasses.is_dataclass function doesn't seem to provide TypeGuard functionality, + # so I created this convenience function + return dataclasses.is_dataclass(_cls) + + +def origin_is_type_alias_type(origin: Any) -> TypeGuard[TypeAliasType]: + return isinstance(origin, TypeAliasType) + + +if sys.version_info >= (3, 10): + + def is_generic_alias(type_: type[Any]) -> bool: + return isinstance(type_, (types.GenericAlias, typing._GenericAlias)) # type: ignore[attr-defined] + +else: + + def is_generic_alias(type_: type[Any]) -> bool: + return isinstance(type_, typing._GenericAlias) # type: ignore + + +def is_self_type(tp: Any) -> bool: + """Check if a given class is a Self type (from `typing` or `typing_extensions`)""" + return isinstance(tp, typing_base) and getattr(tp, '_name', None) == 'Self' diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ef8b32df6d07e55d23e2f323dc8cd17539fa90c2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.py @@ -0,0 +1,362 @@ +"""Bucket of reusable internal utilities. + +This should be reduced as much as possible with functions only used in one place, moved to that place. +""" +from __future__ import annotations as _annotations + +import dataclasses +import keyword +import typing +import weakref +from collections import OrderedDict, defaultdict, deque +from copy import deepcopy +from itertools import zip_longest +from types import BuiltinFunctionType, CodeType, FunctionType, GeneratorType, LambdaType, ModuleType +from typing import Any, Mapping, TypeVar + +from typing_extensions import TypeAlias, TypeGuard + +from . import _repr, _typing_extra + +if typing.TYPE_CHECKING: + MappingIntStrAny: TypeAlias = 'typing.Mapping[int, Any] | typing.Mapping[str, Any]' + AbstractSetIntStr: TypeAlias = 'typing.AbstractSet[int] | typing.AbstractSet[str]' + from ..main import BaseModel + + +# these are types that are returned unchanged by deepcopy +IMMUTABLE_NON_COLLECTIONS_TYPES: set[type[Any]] = { + int, + float, + complex, + str, + bool, + bytes, + type, + _typing_extra.NoneType, + FunctionType, + BuiltinFunctionType, + LambdaType, + weakref.ref, + CodeType, + # note: including ModuleType will differ from behaviour of deepcopy by not producing error. + # It might be not a good idea in general, but considering that this function used only internally + # against default values of fields, this will allow to actually have a field with module as default value + ModuleType, + NotImplemented.__class__, + Ellipsis.__class__, +} + +# these are types that if empty, might be copied with simple copy() instead of deepcopy() +BUILTIN_COLLECTIONS: set[type[Any]] = { + list, + set, + tuple, + frozenset, + dict, + OrderedDict, + defaultdict, + deque, +} + + +def sequence_like(v: Any) -> bool: + return isinstance(v, (list, tuple, set, frozenset, GeneratorType, deque)) + + +def lenient_isinstance(o: Any, class_or_tuple: type[Any] | tuple[type[Any], ...] | None) -> bool: # pragma: no cover + try: + return isinstance(o, class_or_tuple) # type: ignore[arg-type] + except TypeError: + return False + + +def lenient_issubclass(cls: Any, class_or_tuple: Any) -> bool: # pragma: no cover + try: + return isinstance(cls, type) and issubclass(cls, class_or_tuple) + except TypeError: + if isinstance(cls, _typing_extra.WithArgsTypes): + return False + raise # pragma: no cover + + +def is_model_class(cls: Any) -> TypeGuard[type[BaseModel]]: + """Returns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, + unlike raw calls to lenient_issubclass. + """ + from ..main import BaseModel + + return lenient_issubclass(cls, BaseModel) and cls is not BaseModel + + +def is_valid_identifier(identifier: str) -> bool: + """Checks that a string is a valid identifier and not a Python keyword. + :param identifier: The identifier to test. + :return: True if the identifier is valid. + """ + return identifier.isidentifier() and not keyword.iskeyword(identifier) + + +KeyType = TypeVar('KeyType') + + +def deep_update(mapping: dict[KeyType, Any], *updating_mappings: dict[KeyType, Any]) -> dict[KeyType, Any]: + updated_mapping = mapping.copy() + for updating_mapping in updating_mappings: + for k, v in updating_mapping.items(): + if k in updated_mapping and isinstance(updated_mapping[k], dict) and isinstance(v, dict): + updated_mapping[k] = deep_update(updated_mapping[k], v) + else: + updated_mapping[k] = v + return updated_mapping + + +def update_not_none(mapping: dict[Any, Any], **update: Any) -> None: + mapping.update({k: v for k, v in update.items() if v is not None}) + + +T = TypeVar('T') + + +def unique_list( + input_list: list[T] | tuple[T, ...], + *, + name_factory: typing.Callable[[T], str] = str, +) -> list[T]: + """Make a list unique while maintaining order. + We update the list if another one with the same name is set + (e.g. model validator overridden in subclass). + """ + result: list[T] = [] + result_names: list[str] = [] + for v in input_list: + v_name = name_factory(v) + if v_name not in result_names: + result_names.append(v_name) + result.append(v) + else: + result[result_names.index(v_name)] = v + + return result + + +class ValueItems(_repr.Representation): + """Class for more convenient calculation of excluded or included fields on values.""" + + __slots__ = ('_items', '_type') + + def __init__(self, value: Any, items: AbstractSetIntStr | MappingIntStrAny) -> None: + items = self._coerce_items(items) + + if isinstance(value, (list, tuple)): + items = self._normalize_indexes(items, len(value)) # type: ignore + + self._items: MappingIntStrAny = items # type: ignore + + def is_excluded(self, item: Any) -> bool: + """Check if item is fully excluded. + + :param item: key or index of a value + """ + return self.is_true(self._items.get(item)) + + def is_included(self, item: Any) -> bool: + """Check if value is contained in self._items. + + :param item: key or index of value + """ + return item in self._items + + def for_element(self, e: int | str) -> AbstractSetIntStr | MappingIntStrAny | None: + """:param e: key or index of element on value + :return: raw values for element if self._items is dict and contain needed element + """ + item = self._items.get(e) # type: ignore + return item if not self.is_true(item) else None + + def _normalize_indexes(self, items: MappingIntStrAny, v_length: int) -> dict[int | str, Any]: + """:param items: dict or set of indexes which will be normalized + :param v_length: length of sequence indexes of which will be + + >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4) + {0: True, 2: True, 3: True} + >>> self._normalize_indexes({'__all__': True}, 4) + {0: True, 1: True, 2: True, 3: True} + """ + normalized_items: dict[int | str, Any] = {} + all_items = None + for i, v in items.items(): + if not (isinstance(v, typing.Mapping) or isinstance(v, typing.AbstractSet) or self.is_true(v)): + raise TypeError(f'Unexpected type of exclude value for index "{i}" {v.__class__}') + if i == '__all__': + all_items = self._coerce_value(v) + continue + if not isinstance(i, int): + raise TypeError( + 'Excluding fields from a sequence of sub-models or dicts must be performed index-wise: ' + 'expected integer keys or keyword "__all__"' + ) + normalized_i = v_length + i if i < 0 else i + normalized_items[normalized_i] = self.merge(v, normalized_items.get(normalized_i)) + + if not all_items: + return normalized_items + if self.is_true(all_items): + for i in range(v_length): + normalized_items.setdefault(i, ...) + return normalized_items + for i in range(v_length): + normalized_item = normalized_items.setdefault(i, {}) + if not self.is_true(normalized_item): + normalized_items[i] = self.merge(all_items, normalized_item) + return normalized_items + + @classmethod + def merge(cls, base: Any, override: Any, intersect: bool = False) -> Any: + """Merge a `base` item with an `override` item. + + Both `base` and `override` are converted to dictionaries if possible. + Sets are converted to dictionaries with the sets entries as keys and + Ellipsis as values. + + Each key-value pair existing in `base` is merged with `override`, + while the rest of the key-value pairs are updated recursively with this function. + + Merging takes place based on the "union" of keys if `intersect` is + set to `False` (default) and on the intersection of keys if + `intersect` is set to `True`. + """ + override = cls._coerce_value(override) + base = cls._coerce_value(base) + if override is None: + return base + if cls.is_true(base) or base is None: + return override + if cls.is_true(override): + return base if intersect else override + + # intersection or union of keys while preserving ordering: + if intersect: + merge_keys = [k for k in base if k in override] + [k for k in override if k in base] + else: + merge_keys = list(base) + [k for k in override if k not in base] + + merged: dict[int | str, Any] = {} + for k in merge_keys: + merged_item = cls.merge(base.get(k), override.get(k), intersect=intersect) + if merged_item is not None: + merged[k] = merged_item + + return merged + + @staticmethod + def _coerce_items(items: AbstractSetIntStr | MappingIntStrAny) -> MappingIntStrAny: + if isinstance(items, typing.Mapping): + pass + elif isinstance(items, typing.AbstractSet): + items = dict.fromkeys(items, ...) # type: ignore + else: + class_name = getattr(items, '__class__', '???') + raise TypeError(f'Unexpected type of exclude value {class_name}') + return items # type: ignore + + @classmethod + def _coerce_value(cls, value: Any) -> Any: + if value is None or cls.is_true(value): + return value + return cls._coerce_items(value) + + @staticmethod + def is_true(v: Any) -> bool: + return v is True or v is ... + + def __repr_args__(self) -> _repr.ReprArgs: + return [(None, self._items)] + + +if typing.TYPE_CHECKING: + + def ClassAttribute(name: str, value: T) -> T: + ... + +else: + + class ClassAttribute: + """Hide class attribute from its instances.""" + + __slots__ = 'name', 'value' + + def __init__(self, name: str, value: Any) -> None: + self.name = name + self.value = value + + def __get__(self, instance: Any, owner: type[Any]) -> None: + if instance is None: + return self.value + raise AttributeError(f'{self.name!r} attribute of {owner.__name__!r} is class-only') + + +Obj = TypeVar('Obj') + + +def smart_deepcopy(obj: Obj) -> Obj: + """Return type as is for immutable built-in types + Use obj.copy() for built-in empty collections + Use copy.deepcopy() for non-empty collections and unknown objects. + """ + obj_type = obj.__class__ + if obj_type in IMMUTABLE_NON_COLLECTIONS_TYPES: + return obj # fastest case: obj is immutable and not collection therefore will not be copied anyway + try: + if not obj and obj_type in BUILTIN_COLLECTIONS: + # faster way for empty collections, no need to copy its members + return obj if obj_type is tuple else obj.copy() # tuple doesn't have copy method # type: ignore + except (TypeError, ValueError, RuntimeError): + # do we really dare to catch ALL errors? Seems a bit risky + pass + + return deepcopy(obj) # slowest way when we actually might need a deepcopy + + +_SENTINEL = object() + + +def all_identical(left: typing.Iterable[Any], right: typing.Iterable[Any]) -> bool: + """Check that the items of `left` are the same objects as those in `right`. + + >>> a, b = object(), object() + >>> all_identical([a, b, a], [a, b, a]) + True + >>> all_identical([a, b, [a]], [a, b, [a]]) # new list object, while "equal" is not "identical" + False + """ + for left_item, right_item in zip_longest(left, right, fillvalue=_SENTINEL): + if left_item is not right_item: + return False + return True + + +@dataclasses.dataclass(frozen=True) +class SafeGetItemProxy: + """Wrapper redirecting `__getitem__` to `get` with a sentinel value as default + + This makes is safe to use in `operator.itemgetter` when some keys may be missing + """ + + # Define __slots__manually for performances + # @dataclasses.dataclass() only support slots=True in python>=3.10 + __slots__ = ('wrapped',) + + wrapped: Mapping[str, Any] + + def __getitem__(self, key: str, /) -> Any: + return self.wrapped.get(key, _SENTINEL) + + # required to pass the object to operator.itemgetter() instances due to a quirk of typeshed + # https://github.com/python/mypy/issues/13713 + # https://github.com/python/typeshed/pull/8785 + # Since this is typing-only, hide it in a typing.TYPE_CHECKING block + if typing.TYPE_CHECKING: + + def __contains__(self, key: str, /) -> bool: + return self.wrapped.__contains__(key) diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_validate_call.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_validate_call.py new file mode 100644 index 0000000000000000000000000000000000000000..664c063013388fa9d89ad9e71553c5a408f10911 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_validate_call.py @@ -0,0 +1,84 @@ +from __future__ import annotations as _annotations + +import inspect +from functools import partial +from typing import Any, Awaitable, Callable + +import pydantic_core + +from ..config import ConfigDict +from ..plugin._schema_validator import create_schema_validator +from . import _generate_schema, _typing_extra +from ._config import ConfigWrapper + + +class ValidateCallWrapper: + """This is a wrapper around a function that validates the arguments passed to it, and optionally the return value.""" + + __slots__ = ( + '__pydantic_validator__', + '__name__', + '__qualname__', + '__annotations__', + '__dict__', # required for __module__ + ) + + def __init__(self, function: Callable[..., Any], config: ConfigDict | None, validate_return: bool): + if isinstance(function, partial): + func = function.func + schema_type = func + self.__name__ = f'partial({func.__name__})' + self.__qualname__ = f'partial({func.__qualname__})' + self.__module__ = func.__module__ + else: + schema_type = function + self.__name__ = function.__name__ + self.__qualname__ = function.__qualname__ + self.__module__ = function.__module__ + + namespace = _typing_extra.add_module_globals(function, None) + config_wrapper = ConfigWrapper(config) + gen_schema = _generate_schema.GenerateSchema(config_wrapper, namespace) + schema = gen_schema.clean_schema(gen_schema.generate_schema(function)) + core_config = config_wrapper.core_config(self) + + self.__pydantic_validator__ = create_schema_validator( + schema, + schema_type, + self.__module__, + self.__qualname__, + 'validate_call', + core_config, + config_wrapper.plugin_settings, + ) + + if validate_return: + signature = inspect.signature(function) + return_type = signature.return_annotation if signature.return_annotation is not signature.empty else Any + gen_schema = _generate_schema.GenerateSchema(config_wrapper, namespace) + schema = gen_schema.clean_schema(gen_schema.generate_schema(return_type)) + validator = create_schema_validator( + schema, + schema_type, + self.__module__, + self.__qualname__, + 'validate_call', + core_config, + config_wrapper.plugin_settings, + ) + if inspect.iscoroutinefunction(function): + + async def return_val_wrapper(aw: Awaitable[Any]) -> None: + return validator.validate_python(await aw) + + self.__return_pydantic_validator__ = return_val_wrapper + else: + self.__return_pydantic_validator__ = validator.validate_python + else: + self.__return_pydantic_validator__ = None + + def __call__(self, *args: Any, **kwargs: Any) -> Any: + res = self.__pydantic_validator__.validate_python(pydantic_core.ArgsKwargs(args, kwargs)) + if self.__return_pydantic_validator__: + return self.__return_pydantic_validator__(res) + return res diff --git a/venv/lib/python3.10/site-packages/pydantic/_internal/_validators.py b/venv/lib/python3.10/site-packages/pydantic/_internal/_validators.py new file mode 100644 index 0000000000000000000000000000000000000000..6eb9953a88ea374798cd7531042f981bf2a70576 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic/_internal/_validators.py @@ -0,0 +1,289 @@ +"""Validator functions for standard library types. + +Import of this module is deferred since it contains imports of many standard library modules. +""" + +from __future__ import annotations as _annotations + +import math +import re +import typing +from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network +from typing import Any + +from pydantic_core import PydanticCustomError, core_schema +from pydantic_core._pydantic_core import PydanticKnownError + + +def sequence_validator( + input_value: typing.Sequence[Any], + /, + validator: core_schema.ValidatorFunctionWrapHandler, +) -> typing.Sequence[Any]: + """Validator for `Sequence` types, isinstance(v, Sequence) has already been called.""" + value_type = type(input_value) + + # We don't accept any plain string as a sequence + # Relevant issue: https://github.com/pydantic/pydantic/issues/5595 + if issubclass(value_type, (str, bytes)): + raise PydanticCustomError( + 'sequence_str', + "'{type_name}' instances are not allowed as a Sequence value", + {'type_name': value_type.__name__}, + ) + + # TODO: refactor sequence validation to validate with either a list or a tuple + # schema, depending on the type of the value. + # Additionally, we should be able to remove one of either this validator or the + # SequenceValidator in _std_types_schema.py (preferably this one, while porting over some logic). + # Effectively, a refactor for sequence validation is needed. + if value_type == tuple: + input_value = list(input_value) + + v_list = validator(input_value) + + # the rest of the logic is just re-creating the original type from `v_list` + if value_type == list: + return v_list + elif issubclass(value_type, range): + # return the list as we probably can't re-create the range + return v_list + elif value_type == tuple: + return tuple(v_list) + else: + # best guess at how to re-create the original type, more custom construction logic might be required + return value_type(v_list) # type: ignore[call-arg] + + +def import_string(value: Any) -> Any: + if isinstance(value, str): + try: + return _import_string_logic(value) + except ImportError as e: + raise PydanticCustomError('import_error', 'Invalid python path: {error}', {'error': str(e)}) from e + else: + # otherwise we just return the value and let the next validator do the rest of the work + return value + + +def _import_string_logic(dotted_path: str) -> Any: + """Inspired by uvicorn — dotted paths should include a colon before the final item if that item is not a module. + (This is necessary to distinguish between a submodule and an attribute when there is a conflict.). + + If the dotted path does not include a colon and the final item is not a valid module, importing as an attribute + rather than a submodule will be attempted automatically. + + So, for example, the following values of `dotted_path` result in the following returned values: + * 'collections': + * 'collections.abc': + * 'collections.abc:Mapping': + * `collections.abc.Mapping`: (though this is a bit slower than the previous line) + + An error will be raised under any of the following scenarios: + * `dotted_path` contains more than one colon (e.g., 'collections:abc:Mapping') + * the substring of `dotted_path` before the colon is not a valid module in the environment (e.g., '123:Mapping') + * the substring of `dotted_path` after the colon is not an attribute of the module (e.g., 'collections:abc123') + """ + from importlib import import_module + + components = dotted_path.strip().split(':') + if len(components) > 2: + raise ImportError(f"Import strings should have at most one ':'; received {dotted_path!r}") + + module_path = components[0] + if not module_path: + raise ImportError(f'Import strings should have a nonempty module name; received {dotted_path!r}') + + try: + module = import_module(module_path) + except ModuleNotFoundError as e: + if '.' in module_path: + # Check if it would be valid if the final item was separated from its module with a `:` + maybe_module_path, maybe_attribute = dotted_path.strip().rsplit('.', 1) + try: + return _import_string_logic(f'{maybe_module_path}:{maybe_attribute}') + except ImportError: + pass + raise ImportError(f'No module named {module_path!r}') from e + raise e + + if len(components) > 1: + attribute = components[1] + try: + return getattr(module, attribute) + except AttributeError as e: + raise ImportError(f'cannot import name {attribute!r} from {module_path!r}') from e + else: + return module + + +def pattern_either_validator(input_value: Any, /) -> typing.Pattern[Any]: + if isinstance(input_value, typing.Pattern): + return input_value + elif isinstance(input_value, (str, bytes)): + # todo strict mode + return compile_pattern(input_value) # type: ignore + else: + raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') + + +def pattern_str_validator(input_value: Any, /) -> typing.Pattern[str]: + if isinstance(input_value, typing.Pattern): + if isinstance(input_value.pattern, str): + return input_value + else: + raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') + elif isinstance(input_value, str): + return compile_pattern(input_value) + elif isinstance(input_value, bytes): + raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') + else: + raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') + + +def pattern_bytes_validator(input_value: Any, /) -> typing.Pattern[bytes]: + if isinstance(input_value, typing.Pattern): + if isinstance(input_value.pattern, bytes): + return input_value + else: + raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') + elif isinstance(input_value, bytes): + return compile_pattern(input_value) + elif isinstance(input_value, str): + raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') + else: + raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') + + +PatternType = typing.TypeVar('PatternType', str, bytes) + + +def compile_pattern(pattern: PatternType) -> typing.Pattern[PatternType]: + try: + return re.compile(pattern) + except re.error: + raise PydanticCustomError('pattern_regex', 'Input should be a valid regular expression') + + +def ip_v4_address_validator(input_value: Any, /) -> IPv4Address: + if isinstance(input_value, IPv4Address): + return input_value + + try: + return IPv4Address(input_value) + except ValueError: + raise PydanticCustomError('ip_v4_address', 'Input is not a valid IPv4 address') + + +def ip_v6_address_validator(input_value: Any, /) -> IPv6Address: + if isinstance(input_value, IPv6Address): + return input_value + + try: + return IPv6Address(input_value) + except ValueError: + raise PydanticCustomError('ip_v6_address', 'Input is not a valid IPv6 address') + + +def ip_v4_network_validator(input_value: Any, /) -> IPv4Network: + """Assume IPv4Network initialised with a default `strict` argument. + + See more: + https://docs.python.org/library/ipaddress.html#ipaddress.IPv4Network + """ + if isinstance(input_value, IPv4Network): + return input_value + + try: + return IPv4Network(input_value) + except ValueError: + raise PydanticCustomError('ip_v4_network', 'Input is not a valid IPv4 network') + + +def ip_v6_network_validator(input_value: Any, /) -> IPv6Network: + """Assume IPv6Network initialised with a default `strict` argument. + + See more: + https://docs.python.org/library/ipaddress.html#ipaddress.IPv6Network + """ + if isinstance(input_value, IPv6Network): + return input_value + + try: + return IPv6Network(input_value) + except ValueError: + raise PydanticCustomError('ip_v6_network', 'Input is not a valid IPv6 network') + + +def ip_v4_interface_validator(input_value: Any, /) -> IPv4Interface: + if isinstance(input_value, IPv4Interface): + return input_value + + try: + return IPv4Interface(input_value) + except ValueError: + raise PydanticCustomError('ip_v4_interface', 'Input is not a valid IPv4 interface') + + +def ip_v6_interface_validator(input_value: Any, /) -> IPv6Interface: + if isinstance(input_value, IPv6Interface): + return input_value + + try: + return IPv6Interface(input_value) + except ValueError: + raise PydanticCustomError('ip_v6_interface', 'Input is not a valid IPv6 interface') + + +def greater_than_validator(x: Any, gt: Any) -> Any: + if not (x > gt): + raise PydanticKnownError('greater_than', {'gt': gt}) + return x + + +def greater_than_or_equal_validator(x: Any, ge: Any) -> Any: + if not (x >= ge): + raise PydanticKnownError('greater_than_equal', {'ge': ge}) + return x + + +def less_than_validator(x: Any, lt: Any) -> Any: + if not (x < lt): + raise PydanticKnownError('less_than', {'lt': lt}) + return x + + +def less_than_or_equal_validator(x: Any, le: Any) -> Any: + if not (x <= le): + raise PydanticKnownError('less_than_equal', {'le': le}) + return x + + +def multiple_of_validator(x: Any, multiple_of: Any) -> Any: + if not (x % multiple_of == 0): + raise PydanticKnownError('multiple_of', {'multiple_of': multiple_of}) + return x + + +def min_length_validator(x: Any, min_length: Any) -> Any: + if not (len(x) >= min_length): + raise PydanticKnownError( + 'too_short', + {'field_type': 'Value', 'min_length': min_length, 'actual_length': len(x)}, + ) + return x + + +def max_length_validator(x: Any, max_length: Any) -> Any: + if len(x) > max_length: + raise PydanticKnownError( + 'too_long', + {'field_type': 'Value', 'max_length': max_length, 'actual_length': len(x)}, + ) + return x + + +def forbid_inf_nan_check(x: Any) -> Any: + if not math.isfinite(x): + raise PydanticKnownError('finite_number') + return x diff --git a/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/error_wrappers.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/error_wrappers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f9dd0387508748a430fce2319b469a4e45ffb2d Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/error_wrappers.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/errors.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/errors.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a39469ecf2e14e84b72e6d8c82f7c4d1cb93a985 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/errors.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/json.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/json.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0599d02534effeba62aeda61b0ba1434f557e82 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/json.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/networks.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/networks.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b30a4d3fed00d8ec77632715df39e27396977aa1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/networks.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/validators.cpython-310.pyc b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/validators.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e32f788e0dae9660bddcd352687a5b35680b140 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pydantic/v1/__pycache__/validators.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/LICENSE b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..85cbbcbfe146a7d08e7e89f7005f3ca0df364201 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/LICENSE @@ -0,0 +1,6687 @@ +From PyTorch: + +Copyright (c) 2016- Facebook, Inc (Adam Paszke) +Copyright (c) 2014- Facebook, Inc (Soumith Chintala) +Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) +Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) +Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) +Copyright (c) 2011-2013 NYU (Clement Farabet) +Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) +Copyright (c) 2006 Idiap Research Institute (Samy Bengio) +Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) + +From Caffe2: + +Copyright (c) 2016-present, Facebook Inc. All rights reserved. + +All contributions by Facebook: +Copyright (c) 2016 Facebook Inc. + +All contributions by Google: +Copyright (c) 2015 Google Inc. +All rights reserved. + +All contributions by Yangqing Jia: +Copyright (c) 2015 Yangqing Jia +All rights reserved. + +All contributions by Kakao Brain: +Copyright 2019-2020 Kakao Brain + +All contributions by Cruise LLC: +Copyright (c) 2022 Cruise LLC. +All rights reserved. + +All contributions from Caffe: +Copyright(c) 2013, 2014, 2015, the respective contributors +All rights reserved. + +All other contributions: +Copyright(c) 2015, 2016 the respective contributors +All rights reserved. + +Caffe2 uses a copyright model similar to Caffe: each contributor holds +copyright over their contributions to Caffe2. The project versioning records +all such contribution and copyright details. If a contributor wants to further +mark their specific copyright on a particular contribution, they should +indicate their copyright solely in the commit message of the change when it is +committed. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories America + and IDIAP Research Institute nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + + +The Pytorch repository and source distributions bundle several libraries that are +compatibly licensed. We list these here. + +Name: DCGM +License: Apache-2.0 +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM/LICENSE + +Name: FP16 +License: MIT +Files: third_party/FP16 + For details, see the files concatenated below: third_party/FP16/LICENSE + +Name: FXdiv +License: MIT +Files: third_party/FXdiv + For details, see the files concatenated below: third_party/FXdiv/LICENSE + +Name: NNPACK +License: BSD-2-Clause +Files: third_party/NNPACK + For details, see the files concatenated below: third_party/NNPACK/LICENSE + +Name: QNNPACK +License: BSD-3-Clause +Files: third_party/QNNPACK + For details, see the files concatenated below: third_party/QNNPACK/LICENSE + +Name: VulkanMemoryAllocator +License: MIT +Files: third_party/VulkanMemoryAllocator + For details, see the files concatenated below: third_party/VulkanMemoryAllocator/LICENSE.txt + +Name: XNNPACK +License: BSD-3-Clause +Files: third_party/XNNPACK + For details, see the files concatenated below: third_party/XNNPACK/LICENSE + +Name: benchmark +License: Apache-2.0 +Files: third_party/benchmark, + third_party/onnx/third_party/benchmark, + third_party/onnx-tensorrt/third_party/onnx/third_party/benchmark, + third_party/protobuf/third_party/benchmark + For details, see the files concatenated below: third_party/benchmark/LICENSE, + third_party/onnx/third_party/benchmark/LICENSE, + third_party/onnx-tensorrt/third_party/onnx/third_party/benchmark/LICENSE, + third_party/protobuf/third_party/benchmark/LICENSE + +Name: clog +License: BSD-2-Clause +Files: third_party/QNNPACK/deps/clog, + third_party/cpuinfo/deps/clog, + third_party/fbgemm/third_party/cpuinfo/deps/clog + For details, see the files concatenated below: third_party/QNNPACK/deps/clog/LICENSE, + third_party/cpuinfo/deps/clog/LICENSE, + third_party/fbgemm/third_party/cpuinfo/deps/clog/LICENSE + +Name: colorama +License: BSD-3-Clause +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM/testing/python3/libs_3rdparty/colorama + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM/testing/python3/libs_3rdparty/colorama/LICENSE.txt + +Name: cpplint +License: BSD-3-Clause +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/json/third_party/cpplint, + third_party/nlohmann/tools/cpplint + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/json/third_party/cpplint/LICENSE, + third_party/nlohmann/tools/cpplint/LICENSE + +Name: cpr +License: MIT +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/cpr + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/cpr/LICENSE + +Name: cpuinfo +License: BSD-2-Clause +Files: third_party/cpuinfo, + third_party/fbgemm/third_party/cpuinfo + For details, see the files concatenated below: third_party/cpuinfo/LICENSE, + third_party/fbgemm/third_party/cpuinfo/LICENSE + +Name: cudnn_frontend +License: MIT +Files: third_party/cudnn_frontend + For details, see the files concatenated below: third_party/cudnn_frontend/LICENSE.txt + +Name: cutlass +License: BSD-3-Clause +Files: third_party/cutlass, + third_party/fbgemm/third_party/cutlass + For details, see the files concatenated below: third_party/cutlass/LICENSE.txt, + third_party/fbgemm/third_party/cutlass/LICENSE.txt + +Name: dart +License: Apache-2.0 +Files: third_party/flatbuffers/dart + For details, see the files concatenated below: third_party/flatbuffers/dart/LICENSE + +Name: doctest +License: MIT +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/json/test/thirdparty/doctest, + third_party/nlohmann/tests/thirdparty/doctest + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/json/test/thirdparty/doctest/LICENSE.txt, + third_party/nlohmann/tests/thirdparty/doctest/LICENSE.txt + +Name: dynolog +License: MIT +Files: third_party/kineto/libkineto/third_party/dynolog + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/LICENSE + +Name: eigen +License: BSD-3-Clause +Files: third_party/eigen + For details, see the files concatenated below: third_party/eigen/COPYING.BSD + +Name: fbgemm +License: BSD-3-Clause +Files: third_party/fbgemm + For details, see the files concatenated below: third_party/fbgemm/LICENSE + +Name: flatbuffers +License: Apache-2.0 +Files: third_party/flatbuffers + For details, see the files concatenated below: third_party/flatbuffers/LICENSE + +Name: fmt +License: MIT with exception +Files: third_party/fmt, + third_party/kineto/libkineto/third_party/dynolog/third_party/fmt, + third_party/kineto/libkineto/third_party/fmt + For details, see the files concatenated below: third_party/fmt/LICENSE, + third_party/kineto/libkineto/third_party/dynolog/third_party/fmt/LICENSE.rst, + third_party/kineto/libkineto/third_party/fmt/LICENSE.rst + +Name: foxi +License: MIT +Files: third_party/foxi + For details, see the files concatenated below: third_party/foxi/LICENSE + +Name: gemmlowp +License: Apache-2.0 +Files: third_party/gemmlowp/gemmlowp + For details, see the files concatenated below: third_party/gemmlowp/gemmlowp/LICENSE + +Name: generator +License: Apache-2.0 +Files: third_party/fbgemm/third_party/googletest/googlemock/scripts/generator, + third_party/googletest/googlemock/scripts/generator, + third_party/kineto/libkineto/third_party/googletest/googlemock/scripts/generator, + third_party/protobuf/third_party/googletest/googlemock/scripts/generator, + third_party/tensorpipe/third_party/googletest/googlemock/scripts/generator + For details, see the files concatenated below: third_party/fbgemm/third_party/googletest/googlemock/scripts/generator/LICENSE, + third_party/googletest/googlemock/scripts/generator/LICENSE, + third_party/kineto/libkineto/third_party/googletest/googlemock/scripts/generator/LICENSE, + third_party/protobuf/third_party/googletest/googlemock/scripts/generator/LICENSE, + third_party/tensorpipe/third_party/googletest/googlemock/scripts/generator/LICENSE + +Name: gloo +License: BSD-3-Clause +Files: third_party/gloo + For details, see the files concatenated below: third_party/gloo/LICENSE + +Name: googlemock +License: BSD-3-Clause +Files: third_party/fbgemm/third_party/googletest/googlemock, + third_party/kineto/libkineto/third_party/googletest/googlemock, + third_party/protobuf/third_party/googletest/googlemock, + third_party/tensorpipe/third_party/googletest/googlemock + For details, see the files concatenated below: third_party/fbgemm/third_party/googletest/googlemock/LICENSE, + third_party/kineto/libkineto/third_party/googletest/googlemock/LICENSE, + third_party/protobuf/third_party/googletest/googlemock/LICENSE, + third_party/tensorpipe/third_party/googletest/googlemock/LICENSE + +Name: googletest +License: BSD-3-Clause +Files: third_party/fbgemm/third_party/googletest, + third_party/fbgemm/third_party/googletest/googletest, + third_party/googletest, + third_party/kineto/libkineto/third_party/dynolog/third_party/googletest, + third_party/kineto/libkineto/third_party/googletest, + third_party/kineto/libkineto/third_party/googletest/googletest, + third_party/protobuf/third_party/googletest, + third_party/protobuf/third_party/googletest/googletest, + third_party/tensorpipe/third_party/googletest, + third_party/tensorpipe/third_party/googletest/googletest + For details, see the files concatenated below: third_party/fbgemm/third_party/googletest/LICENSE, + third_party/fbgemm/third_party/googletest/googletest/LICENSE, + third_party/googletest/LICENSE, + third_party/kineto/libkineto/third_party/dynolog/third_party/googletest/LICENSE, + third_party/kineto/libkineto/third_party/googletest/LICENSE, + third_party/kineto/libkineto/third_party/googletest/googletest/LICENSE, + third_party/protobuf/third_party/googletest/LICENSE, + third_party/protobuf/third_party/googletest/googletest/LICENSE, + third_party/tensorpipe/third_party/googletest/LICENSE, + third_party/tensorpipe/third_party/googletest/googletest/LICENSE + +Name: gtest +License: BSD-3-Clause +Files: third_party/ideep/mkl-dnn/tests/gtests/gtest + For details, see the files concatenated below: third_party/ideep/mkl-dnn/tests/gtests/gtest/LICENSE + +Name: hipify_torch +License: MIT +Files: third_party/fbgemm/third_party/hipify_torch + For details, see the files concatenated below: third_party/fbgemm/third_party/hipify_torch/LICENSE.txt + +Name: ideep +License: MIT +Files: third_party/ideep + For details, see the files concatenated below: third_party/ideep/LICENSE + +Name: ios-cmake +License: BSD-3-Clause +Files: third_party/ios-cmake + For details, see the files concatenated below: third_party/ios-cmake/LICENSE + +Name: kineto +License: BSD-3-Clause +Files: third_party/kineto + For details, see the files concatenated below: third_party/kineto/LICENSE + +Name: libnop +License: Apache-2.0 +Files: third_party/tensorpipe/third_party/libnop + For details, see the files concatenated below: third_party/tensorpipe/third_party/libnop/LICENSE + +Name: libuv +License: MIT +Files: third_party/tensorpipe/third_party/libuv + For details, see the files concatenated below: third_party/tensorpipe/third_party/libuv/LICENSE + +Name: mimalloc +License: MIT +Files: third_party/mimalloc + For details, see the files concatenated below: third_party/mimalloc/LICENSE + +Name: miniz-2.1.0 +License: MIT +Files: third_party/miniz-2.1.0 + For details, see the files concatenated below: third_party/miniz-2.1.0/LICENSE + +Name: mkl-dnn +License: Apache-2.0 +Files: third_party/ideep/mkl-dnn + For details, see the files concatenated below: third_party/ideep/mkl-dnn/LICENSE + +Name: nccl +License: BSD-3-Clause +Files: third_party/nccl/nccl + For details, see the files concatenated below: third_party/nccl/nccl/LICENSE.txt + +Name: neon2sse +License: BSD-Source-Code +Files: third_party/neon2sse + For details, see the files concatenated below: third_party/neon2sse/LICENSE + +Name: onnx +License: Apache-2.0 +Files: third_party/onnx + For details, see the files concatenated below: third_party/onnx/LICENSE + +Name: onnx +License: MIT +Files: third_party/onnx-tensorrt/third_party/onnx + For details, see the files concatenated below: third_party/onnx-tensorrt/third_party/onnx/LICENSE + +Name: onnx-tensorrt +License: MIT +Files: third_party/onnx-tensorrt + For details, see the files concatenated below: third_party/onnx-tensorrt/LICENSE + +Name: pfs +License: Apache-2.0 +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/pfs + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/pfs/LICENSE + +Name: protobuf +License: BSD-3-Clause +Files: third_party/protobuf + For details, see the files concatenated below: third_party/protobuf/LICENSE + +Name: psimd +License: MIT +Files: third_party/psimd + For details, see the files concatenated below: third_party/psimd/LICENSE + +Name: pthreadpool +License: BSD-2-Clause +Files: third_party/pthreadpool + For details, see the files concatenated below: third_party/pthreadpool/LICENSE + +Name: pybind11 +License: BSD-3-Clause +Files: third_party/onnx/third_party/pybind11, + third_party/onnx-tensorrt/third_party/onnx/third_party/pybind11, + third_party/pybind11, + third_party/tensorpipe/third_party/pybind11 + For details, see the files concatenated below: third_party/onnx/third_party/pybind11/LICENSE, + third_party/onnx-tensorrt/third_party/onnx/third_party/pybind11/LICENSE, + third_party/pybind11/LICENSE, + third_party/tensorpipe/third_party/pybind11/LICENSE + +Name: python +License: BSD-3-Clause +Files: third_party/cutlass/python + For details, see the files concatenated below: third_party/cutlass/python/LICENSE.txt + +Name: python-peachpy +License: BSD-2-Clause +Files: third_party/python-peachpy + For details, see the files concatenated below: third_party/python-peachpy/LICENSE.rst + +Name: sleef +License: BSL-1.0 +Files: third_party/sleef + For details, see the files concatenated below: third_party/sleef/LICENSE.txt + +Name: swift +License: Apache-2.0 +Files: third_party/flatbuffers/swift + For details, see the files concatenated below: third_party/flatbuffers/swift/LICENSE + +Name: tb_plugin +License: BSD-3-Clause +Files: third_party/kineto/tb_plugin + For details, see the files concatenated below: third_party/kineto/tb_plugin/LICENSE + +Name: tbb +License: Apache-2.0 +Files: third_party/tbb + For details, see the files concatenated below: third_party/tbb/LICENSE + +Name: tensorpipe +License: BSD-3-Clause +Files: third_party/tensorpipe + For details, see the files concatenated below: third_party/tensorpipe/LICENSE.txt + +Name: test +License: MIT with exception +Files: third_party/kineto/libkineto/third_party/dynolog/third_party/cpr/test + For details, see the files concatenated below: third_party/kineto/libkineto/third_party/dynolog/third_party/cpr/test/LICENSE + +Name: zstd +License: BSD-3-Clause +Files: third_party/zstd + For details, see the files concatenated below: third_party/zstd/LICENSE + +third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM/LICENSE +------------------------------------------------------------------------- +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + + +third_party/FP16/LICENSE +------------------------ +The MIT License (MIT) + +Copyright (c) 2017 Facebook Inc. +Copyright (c) 2017 Georgia Institute of Technology +Copyright 2019 Google LLC + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +third_party/FXdiv/LICENSE +------------------------- +The MIT License (MIT) + +Copyright (c) 2017 Facebook Inc. +Copyright (c) 2016-2017 Marat Dukhan + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +third_party/NNPACK/LICENSE +-------------------------- +Copyright (c) 2017 Facebook Inc. +Copyright (c) 2015-2017, Georgia Institute of Technology +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/QNNPACK/LICENSE +--------------------------- +BSD License + +For QNNPACK software + +Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/VulkanMemoryAllocator/LICENSE.txt +--------------------------------------------- +Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + + +third_party/XNNPACK/LICENSE +--------------------------- +BSD License + +For XNNPACK software + +Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +Copyright 2019 Google LLC + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/benchmark/LICENSE +----------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/onnx/third_party/benchmark/LICENSE +---------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/onnx-tensorrt/third_party/onnx/third_party/benchmark/LICENSE +------------------------------------------------------------------------ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/protobuf/third_party/benchmark/LICENSE +-------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/QNNPACK/deps/clog/LICENSE +------------------------------------- +Copyright (C) 2018 Marat Dukhan +Copyright (c) 2017-2018 Facebook Inc. +Copyright (c) 2017 Georgia Institute of Technology + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/cpuinfo/deps/clog/LICENSE +------------------------------------- +Copyright (C) 2018 Marat Dukhan +Copyright (c) 2017-2018 Facebook Inc. +Copyright (c) 2017 Georgia Institute of Technology + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/cpuinfo/deps/clog/LICENSE +-------------------------------------------------------- +Copyright (C) 2018 Marat Dukhan +Copyright (c) 2017-2018 Facebook Inc. +Copyright (c) 2017 Georgia Institute of Technology + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/DCGM/testing/python3/libs_3rdparty/colorama/LICENSE.txt +-------------------------------------------------------------------------------------------------------------------- +Copyright (c) 2010 Jonathan Hartley + +Released under the New BSD license (reproduced below), or alternatively you may +use this software under any OSI approved open source license such as those at +http://opensource.org/licenses/alphabetical + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name(s) of the copyright holders, nor those of its contributors + may be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + +third_party/kineto/libkineto/third_party/dynolog/third_party/json/third_party/cpplint/LICENSE +--------------------------------------------------------------------------------------------- +cpplint.py and its corresponding unit tests are Copyright (C) 2009 Google Inc. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/nlohmann/tools/cpplint/LICENSE +------------------------------------------ +cpplint.py and its corresponding unit tests are Copyright (C) 2009 Google Inc. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/cpr/LICENSE +------------------------------------------------------------------------ +This license applies to everything except the contents of the "test" +directory and its subdirectories. + +MIT License + +Copyright (c) 2017-2021 Huu Nguyen +Copyright (c) 2022 libcpr and many other contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +third_party/cpuinfo/LICENSE +--------------------------- +Copyright (c) 2019 Google LLC +Copyright (c) 2017-2018 Facebook Inc. +Copyright (C) 2012-2017 Georgia Institute of Technology +Copyright (C) 2010-2012 Marat Dukhan + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/cpuinfo/LICENSE +---------------------------------------------- +Copyright (c) 2019 Google LLC +Copyright (c) 2017-2018 Facebook Inc. +Copyright (C) 2012-2017 Georgia Institute of Technology +Copyright (C) 2010-2012 Marat Dukhan + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/cudnn_frontend/LICENSE.txt +-------------------------------------- +/* + * Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + + +third_party/cutlass/LICENSE.txt +------------------------------- +Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +SPDX-License-Identifier: BSD-3-Clause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/cutlass/LICENSE.txt +-------------------------------------------------- +Copyright (c) 2017 - 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +SPDX-License-Identifier: BSD-3-Clause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/flatbuffers/dart/LICENSE +------------------------------------ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2014 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/json/test/thirdparty/doctest/LICENSE.txt +----------------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2016-2021 Viktor Kirilov + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/nlohmann/tests/thirdparty/doctest/LICENSE.txt +--------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2016-2021 Viktor Kirilov + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/kineto/libkineto/third_party/dynolog/LICENSE +-------------------------------------------------------- +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/eigen/COPYING.BSD +----------------------------- +/* + Copyright (c) 2011, Intel Corporation. All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +third_party/fbgemm/LICENSE +-------------------------- +BSD License + +For FBGEMM software + +Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/flatbuffers/LICENSE +------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/fmt/LICENSE +----------------------- +Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +--- Optional exception to the license --- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into a machine-executable object form of such +source code, you may redistribute such embedded portions in such object form +without including the above copyright and permission notices. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/fmt/LICENSE.rst +---------------------------------------------------------------------------- +Copyright (c) 2012 - present, Victor Zverovich + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +--- Optional exception to the license --- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into a machine-executable object form of such +source code, you may redistribute such embedded portions in such object form +without including the above copyright and permission notices. + + +third_party/kineto/libkineto/third_party/fmt/LICENSE.rst +-------------------------------------------------------- +Copyright (c) 2012 - present, Victor Zverovich + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +--- Optional exception to the license --- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into a machine-executable object form of such +source code, you may redistribute such embedded portions in such object form +without including the above copyright and permission notices. + + +third_party/foxi/LICENSE +------------------------ +MIT License + +Copyright (c) 2019 Lu Fang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/gemmlowp/gemmlowp/LICENSE +------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/fbgemm/third_party/googletest/googlemock/scripts/generator/LICENSE +------------------------------------------------------------------------------ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2007] Neal Norwitz + Portions Copyright [2007] Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/googletest/googlemock/scripts/generator/LICENSE +----------------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2007] Neal Norwitz + Portions Copyright [2007] Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/kineto/libkineto/third_party/googletest/googlemock/scripts/generator/LICENSE +---------------------------------------------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2007] Neal Norwitz + Portions Copyright [2007] Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/protobuf/third_party/googletest/googlemock/scripts/generator/LICENSE +-------------------------------------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2007] Neal Norwitz + Portions Copyright [2007] Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/tensorpipe/third_party/googletest/googlemock/scripts/generator/LICENSE +---------------------------------------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2007] Neal Norwitz + Portions Copyright [2007] Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/gloo/LICENSE +------------------------ +BSD License + +For Gloo software + +Copyright (c) 2017-present, Facebook, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/googletest/googlemock/LICENSE +------------------------------------------------------------ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/googletest/googlemock/LICENSE +---------------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/protobuf/third_party/googletest/googlemock/LICENSE +-------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/tensorpipe/third_party/googletest/googlemock/LICENSE +---------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/googletest/LICENSE +------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/googletest/googletest/LICENSE +------------------------------------------------------------ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/googletest/LICENSE +------------------------------ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/googletest/LICENSE +------------------------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/googletest/LICENSE +----------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/googletest/googletest/LICENSE +---------------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/protobuf/third_party/googletest/LICENSE +--------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/protobuf/third_party/googletest/googletest/LICENSE +-------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/tensorpipe/third_party/googletest/LICENSE +----------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/tensorpipe/third_party/googletest/googletest/LICENSE +---------------------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/ideep/mkl-dnn/tests/gtests/gtest/LICENSE +---------------------------------------------------- +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/fbgemm/third_party/hipify_torch/LICENSE.txt +------------------------------------------------------- +MIT License + +Copyright (c) 2017 AMD Compute Libraries + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/ideep/LICENSE +------------------------- +Copyright (c) 2018 Intel Corporation. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + + +third_party/ios-cmake/LICENSE +----------------------------- +Copyright (c) 2011-2014, Andrew Fischer +Copyright (c) 2016, Bogdan Cristea +Copyright (c) 2017, Yangqing Jia + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/LICENSE +-------------------------- +BSD License + +For Kineto software + +Copyright (c) Meta Platforms, Inc. and affiliates. + +All contributions by Microsoft: +Copyright (c) Microsoft Corporation. (The Azure AI Platform team) + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Meta nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/tensorpipe/third_party/libnop/LICENSE +------------------------------------------------- +Copyright 2017 The Native Object Protocols Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + + +third_party/tensorpipe/third_party/libuv/LICENSE +------------------------------------------------ +libuv is licensed for use as follows: + +==== +Copyright (c) 2015-present libuv project contributors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. +==== + +This license applies to parts of libuv originating from the +https://github.com/joyent/libuv repository: + +==== + +Copyright Joyent, Inc. and other Node contributors. All rights reserved. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. + +==== + +This license applies to all parts of libuv that are not externally +maintained libraries. + +The externally maintained libraries used by libuv are: + + - tree.h (from FreeBSD), copyright Niels Provos. Two clause BSD license. + + - inet_pton and inet_ntop implementations, contained in src/inet.c, are + copyright the Internet Systems Consortium, Inc., and licensed under the ISC + license. + + - stdint-msvc2008.h (from msinttypes), copyright Alexander Chemeris. Three + clause BSD license. + + - pthread-fixes.c, copyright Google Inc. and Sony Mobile Communications AB. + Three clause BSD license. + + - android-ifaddrs.h, android-ifaddrs.c, copyright Berkeley Software Design + Inc, Kenneth MacKay and Emergya (Cloud4all, FP7/2007-2013, grant agreement + n° 289016). Three clause BSD license. + + +third_party/mimalloc/LICENSE +---------------------------- +MIT License + +Copyright (c) 2018-2021 Microsoft Corporation, Daan Leijen + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/miniz-2.1.0/LICENSE +------------------------------- +Copyright 2013-2014 RAD Game Tools and Valve Software +Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + + +third_party/ideep/mkl-dnn/LICENSE +--------------------------------- + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + ============================================================================ + + Copyright 2016-2023 Intel Corporation + Copyright 2018 YANDEX LLC + Copyright 2019-2023 FUJITSU LIMITED + Copyright 2020-2023 Arm Ltd. and affiliates + Copyright 2020-2022 Codeplay Software Limited + Copyright 2021 Alanna Tempest + Copyright 2022-2023 IBM Corporation + Copyright 2023 KNS Group LLC (YADRO) + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + This distribution includes third party software ("third party programs"). + This third party software, even if included with the distribution of + the Intel software, may be governed by separate license terms, including + without limitation, third party license terms, other Intel software license + terms, and open source software license terms. These separate license terms + govern your use of the third party programs as set forth in the + "THIRD-PARTY-PROGRAMS" file. + + +third_party/nccl/nccl/LICENSE.txt +--------------------------------- + + Copyright (c) 2015-2020, NVIDIA CORPORATION. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of NVIDIA CORPORATION, Lawrence Berkeley National + Laboratory, the U.S. Department of Energy, nor the names of their + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + The U.S. Department of Energy funded the development of this software + under subcontract 7078610 with Lawrence Berkeley National Laboratory. + + +This code also includes files from the NVIDIA Tools Extension SDK project. + +See: + + https://github.com/NVIDIA/NVTX + +for more information and license details. + + +third_party/neon2sse/LICENSE +---------------------------- +created by Victoria Zhislina, the Senior Application Engineer, Intel Corporation, victoria.zhislina@intel.com + +*** Copyright (C) 2012-2016 Intel Corporation. All rights reserved. + +IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. + +By downloading, copying, installing or using the software you agree to this license. +If you do not agree to this license, do not download, install, copy or use the software. + + License Agreement +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * The name of the copyright holders may not be used to endorse or promote products + derived from this software without specific prior written permission. + +This software is provided by the copyright holders and contributors "as is" and +any express or implied warranties, including, but not limited to, the implied +warranties of merchantability and fitness for a particular purpose are disclaimed. +In no event shall the Intel Corporation or contributors be liable for any direct, +indirect, incidental, special, exemplary, or consequential damages +(including, but not limited to, procurement of substitute goods or services; +loss of use, data, or profits; or business interruption) however caused +and on any theory of liability, whether in contract, strict liability, +or tort (including negligence or otherwise) arising in any way out of +the use of this software, even if advised of the possibility of such damage. + + +third_party/onnx/LICENSE +------------------------ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/onnx-tensorrt/third_party/onnx/LICENSE +-------------------------------------------------- +Open Neural Network Exchange + +Copyright (c) Facebook, Inc. and Microsoft Corporation. +All rights reserved. + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +third_party/onnx-tensorrt/LICENSE +--------------------------------- +MIT License + +Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. +Copyright (c) 2018 Open Neural Network Exchange + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/pfs/LICENSE +------------------------------------------------------------------------ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + Copyright 2020-present Daniel Trugman + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/protobuf/LICENSE +---------------------------- +Copyright 2008 Google Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Code generated by the Protocol Buffer compiler is owned by the owner +of the input file used when generating it. This code is not +standalone and requires a support library to be linked with it. This +support library is itself covered by the above license. + + +third_party/psimd/LICENSE +------------------------- +The MIT License (MIT) + +Copyright (c) 2017 Facebook Inc. +Copyright (c) 2014-2017 Georgia Institute of Technology +Copyright 2019 Google LLC + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +third_party/pthreadpool/LICENSE +------------------------------- +Copyright 2019 Google LLC +Copyright (c) 2017 Facebook Inc. +Copyright (c) 2015-2017 Georgia Institute of Technology +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + +third_party/onnx/third_party/pybind11/LICENSE +--------------------------------------------- +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of +external contributions to this project including patches, pull requests, etc. + + +third_party/onnx-tensorrt/third_party/onnx/third_party/pybind11/LICENSE +----------------------------------------------------------------------- +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +You are under no obligation whatsoever to provide any bug fixes, patches, or +upgrades to the features, functionality or performance of the source code +("Enhancements") to anyone; however, if you choose to make your Enhancements +available either publicly, or directly to the author of this software, without +imposing a separate written license agreement for such Enhancements, then you +hereby grant the following license: a non-exclusive, royalty-free perpetual +license to install, use, modify, prepare derivative works, incorporate into +other computer software, distribute, and sublicense such enhancements or +derivative works thereof, in binary and source code form. + + +third_party/pybind11/LICENSE +---------------------------- +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of +external contributions to this project including patches, pull requests, etc. + + +third_party/tensorpipe/third_party/pybind11/LICENSE +--------------------------------------------------- +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Please also refer to the file CONTRIBUTING.md, which clarifies licensing of +external contributions to this project including patches, pull requests, etc. + + +third_party/cutlass/python/LICENSE.txt +-------------------------------------- +Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +SPDX-License-Identifier: BSD-3-Clause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/python-peachpy/LICENSE.rst +-------------------------------------- +============================== +PeachPy license (2-clause BSD) +============================== + +Copyright (c) 2017, Facebook Inc. +Copyright (c) 2013-2017, Georgia Institute of Technology +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/sleef/LICENSE.txt +----------------------------- +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + + +third_party/flatbuffers/swift/LICENSE +------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/kineto/tb_plugin/LICENSE +------------------------------------ +BSD License + +For Kineto software + +Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +All contributions by Microsoft: +Copyright (c) Microsoft Corporation. (The Azure AI Platform team) + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/tbb/LICENSE +----------------------- + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +third_party/tensorpipe/LICENSE.txt +---------------------------------- +BSD License + +For TensorPipe software + +Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Meta nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +third_party/kineto/libkineto/third_party/dynolog/third_party/cpr/test/LICENSE +----------------------------------------------------------------------------- +This license applies to everything inside this directory and all +subdirectories. + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + +third_party/zstd/LICENSE +------------------------ +BSD License + +For Zstandard software + +Copyright (c) 2016-present, Facebook, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3e53db84c097d0fdb0ecd40b5d3b6da5846cb056 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/METADATA @@ -0,0 +1,523 @@ +Metadata-Version: 2.1 +Name: torch +Version: 2.3.0 +Summary: Tensors and Dynamic neural networks in Python with strong GPU acceleration +Home-page: https://pytorch.org/ +Author: PyTorch Team +Author-email: packages@pytorch.org +License: BSD-3 +Download-URL: https://github.com/pytorch/pytorch/tags +Keywords: pytorch,machine learning +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: OSI Approved :: BSD License +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Programming Language :: C++ +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Requires-Python: >=3.8.0 +Description-Content-Type: text/markdown +License-File: LICENSE +License-File: NOTICE +Requires-Dist: filelock +Requires-Dist: typing-extensions (>=4.8.0) +Requires-Dist: sympy +Requires-Dist: networkx +Requires-Dist: jinja2 +Requires-Dist: fsspec +Requires-Dist: nvidia-cuda-nvrtc-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cuda-runtime-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cuda-cupti-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cudnn-cu12 (==8.9.2.26) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cublas-cu12 (==12.1.3.1) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cufft-cu12 (==11.0.2.54) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-curand-cu12 (==10.3.2.106) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cusolver-cu12 (==11.4.5.107) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-cusparse-cu12 (==12.1.0.106) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-nccl-cu12 (==2.20.5) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: nvidia-nvtx-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64" +Requires-Dist: triton (==2.3.0) ; platform_system == "Linux" and platform_machine == "x86_64" and python_version < "3.12" +Requires-Dist: mkl (<=2021.4.0,>=2021.1.1) ; platform_system == "Windows" +Provides-Extra: opt-einsum +Requires-Dist: opt-einsum (>=3.3) ; extra == 'opt-einsum' +Provides-Extra: optree +Requires-Dist: optree (>=0.9.1) ; extra == 'optree' + +![PyTorch Logo](https://github.com/pytorch/pytorch/blob/main/docs/source/_static/img/pytorch-logo-dark.png) + +-------------------------------------------------------------------------------- + +PyTorch is a Python package that provides two high-level features: +- Tensor computation (like NumPy) with strong GPU acceleration +- Deep neural networks built on a tape-based autograd system + +You can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed. + +Our trunk health (Continuous Integration signals) can be found at [hud.pytorch.org](https://hud.pytorch.org/ci/pytorch/pytorch/main). + + + +- [More About PyTorch](#more-about-pytorch) + - [A GPU-Ready Tensor Library](#a-gpu-ready-tensor-library) + - [Dynamic Neural Networks: Tape-Based Autograd](#dynamic-neural-networks-tape-based-autograd) + - [Python First](#python-first) + - [Imperative Experiences](#imperative-experiences) + - [Fast and Lean](#fast-and-lean) + - [Extensions Without Pain](#extensions-without-pain) +- [Installation](#installation) + - [Binaries](#binaries) + - [NVIDIA Jetson Platforms](#nvidia-jetson-platforms) + - [From Source](#from-source) + - [Prerequisites](#prerequisites) + - [Install Dependencies](#install-dependencies) + - [Get the PyTorch Source](#get-the-pytorch-source) + - [Install PyTorch](#install-pytorch) + - [Adjust Build Options (Optional)](#adjust-build-options-optional) + - [Docker Image](#docker-image) + - [Using pre-built images](#using-pre-built-images) + - [Building the image yourself](#building-the-image-yourself) + - [Building the Documentation](#building-the-documentation) + - [Previous Versions](#previous-versions) +- [Getting Started](#getting-started) +- [Resources](#resources) +- [Communication](#communication) +- [Releases and Contributing](#releases-and-contributing) +- [The Team](#the-team) +- [License](#license) + + + +## More About PyTorch + +[Learn the basics of PyTorch](https://pytorch.org/tutorials/beginner/basics/intro.html) + +At a granular level, PyTorch is a library that consists of the following components: + +| Component | Description | +| ---- | --- | +| [**torch**](https://pytorch.org/docs/stable/torch.html) | A Tensor library like NumPy, with strong GPU support | +| [**torch.autograd**](https://pytorch.org/docs/stable/autograd.html) | A tape-based automatic differentiation library that supports all differentiable Tensor operations in torch | +| [**torch.jit**](https://pytorch.org/docs/stable/jit.html) | A compilation stack (TorchScript) to create serializable and optimizable models from PyTorch code | +| [**torch.nn**](https://pytorch.org/docs/stable/nn.html) | A neural networks library deeply integrated with autograd designed for maximum flexibility | +| [**torch.multiprocessing**](https://pytorch.org/docs/stable/multiprocessing.html) | Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training | +| [**torch.utils**](https://pytorch.org/docs/stable/data.html) | DataLoader and other utility functions for convenience | + +Usually, PyTorch is used either as: + +- A replacement for NumPy to use the power of GPUs. +- A deep learning research platform that provides maximum flexibility and speed. + +Elaborating Further: + +### A GPU-Ready Tensor Library + +If you use NumPy, then you have used Tensors (a.k.a. ndarray). + +![Tensor illustration](./docs/source/_static/img/tensor_illustration.png) + +PyTorch provides Tensors that can live either on the CPU or the GPU and accelerates the +computation by a huge amount. + +We provide a wide variety of tensor routines to accelerate and fit your scientific computation needs +such as slicing, indexing, mathematical operations, linear algebra, reductions. +And they are fast! + +### Dynamic Neural Networks: Tape-Based Autograd + +PyTorch has a unique way of building neural networks: using and replaying a tape recorder. + +Most frameworks such as TensorFlow, Theano, Caffe, and CNTK have a static view of the world. +One has to build a neural network and reuse the same structure again and again. +Changing the way the network behaves means that one has to start from scratch. + +With PyTorch, we use a technique called reverse-mode auto-differentiation, which allows you to +change the way your network behaves arbitrarily with zero lag or overhead. Our inspiration comes +from several research papers on this topic, as well as current and past work such as +[torch-autograd](https://github.com/twitter/torch-autograd), +[autograd](https://github.com/HIPS/autograd), +[Chainer](https://chainer.org), etc. + +While this technique is not unique to PyTorch, it's one of the fastest implementations of it to date. +You get the best of speed and flexibility for your crazy research. + +![Dynamic graph](https://github.com/pytorch/pytorch/blob/main/docs/source/_static/img/dynamic_graph.gif) + +### Python First + +PyTorch is not a Python binding into a monolithic C++ framework. +It is built to be deeply integrated into Python. +You can use it naturally like you would use [NumPy](https://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](https://scikit-learn.org) etc. +You can write your new neural network layers in Python itself, using your favorite libraries +and use packages such as [Cython](https://cython.org/) and [Numba](http://numba.pydata.org/). +Our goal is to not reinvent the wheel where appropriate. + +### Imperative Experiences + +PyTorch is designed to be intuitive, linear in thought, and easy to use. +When you execute a line of code, it gets executed. There isn't an asynchronous view of the world. +When you drop into a debugger or receive error messages and stack traces, understanding them is straightforward. +The stack trace points to exactly where your code was defined. +We hope you never spend hours debugging your code because of bad stack traces or asynchronous and opaque execution engines. + +### Fast and Lean + +PyTorch has minimal framework overhead. We integrate acceleration libraries +such as [Intel MKL](https://software.intel.com/mkl) and NVIDIA ([cuDNN](https://developer.nvidia.com/cudnn), [NCCL](https://developer.nvidia.com/nccl)) to maximize speed. +At the core, its CPU and GPU Tensor and neural network backends +are mature and have been tested for years. + +Hence, PyTorch is quite fast — whether you run small or large neural networks. + +The memory usage in PyTorch is extremely efficient compared to Torch or some of the alternatives. +We've written custom memory allocators for the GPU to make sure that +your deep learning models are maximally memory efficient. +This enables you to train bigger deep learning models than before. + +### Extensions Without Pain + +Writing new neural network modules, or interfacing with PyTorch's Tensor API was designed to be straightforward +and with minimal abstractions. + +You can write new neural network layers in Python using the torch API +[or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html). + +If you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate. +No wrapper code needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp). + + +## Installation + +### Binaries +Commands to install binaries via Conda or pip wheels are on our website: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/) + + +#### NVIDIA Jetson Platforms + +Python wheels for NVIDIA's Jetson Nano, Jetson TX1/TX2, Jetson Xavier NX/AGX, and Jetson AGX Orin are provided [here](https://forums.developer.nvidia.com/t/pytorch-for-jetson-version-1-10-now-available/72048) and the L4T container is published [here](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch) + +They require JetPack 4.2 and above, and [@dusty-nv](https://github.com/dusty-nv) and [@ptrblck](https://github.com/ptrblck) are maintaining them. + + +### From Source + +#### Prerequisites +If you are installing from source, you will need: +- Python 3.8 or later (for Linux, Python 3.8.1+ is needed) +- A compiler that fully supports C++17, such as clang or gcc (gcc 9.4.0 or newer is required) + +We highly recommend installing an [Anaconda](https://www.anaconda.com/download) environment. You will get a high-quality BLAS library (MKL) and you get controlled dependency versions regardless of your Linux distro. + +If you want to compile with CUDA support, [select a supported version of CUDA from our support matrix](https://pytorch.org/get-started/locally/), then install the following: +- [NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads) +- [NVIDIA cuDNN](https://developer.nvidia.com/cudnn) v8.5 or above +- [Compiler](https://gist.github.com/ax3l/9489132) compatible with CUDA + +Note: You could refer to the [cuDNN Support Matrix](https://docs.nvidia.com/deeplearning/cudnn/reference/support-matrix.html) for cuDNN versions with the various supported CUDA, CUDA driver and NVIDIA hardware + +If you want to disable CUDA support, export the environment variable `USE_CUDA=0`. +Other potentially useful environment variables may be found in `setup.py`. + +If you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xavier), Instructions to install PyTorch for Jetson Nano are [available here](https://devtalk.nvidia.com/default/topic/1049071/jetson-nano/pytorch-for-jetson-nano/) + +If you want to compile with ROCm support, install +- [AMD ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html) 4.0 and above installation +- ROCm is currently supported only for Linux systems. + +If you want to disable ROCm support, export the environment variable `USE_ROCM=0`. +Other potentially useful environment variables may be found in `setup.py`. + +#### Install Dependencies + +**Common** + +```bash +conda install cmake ninja +# Run this command from the PyTorch directory after cloning the source code using the “Get the PyTorch Source“ section below +pip install -r requirements.txt +``` + +**On Linux** + +```bash +conda install intel::mkl-static intel::mkl-include +# CUDA only: Add LAPACK support for the GPU if needed +conda install -c pytorch magma-cuda110 # or the magma-cuda* that matches your CUDA version from https://anaconda.org/pytorch/repo + +# (optional) If using torch.compile with inductor/triton, install the matching version of triton +# Run from the pytorch directory after cloning +make triton +``` + +**On MacOS** + +```bash +# Add this package on intel x86 processor machines only +conda install intel::mkl-static intel::mkl-include +# Add these packages if torch.distributed is needed +conda install pkg-config libuv +``` + +**On Windows** + +```bash +conda install intel::mkl-static intel::mkl-include +# Add these packages if torch.distributed is needed. +# Distributed package support on Windows is a prototype feature and is subject to changes. +conda install -c conda-forge libuv=1.39 +``` + +#### Get the PyTorch Source +```bash +git clone --recursive https://github.com/pytorch/pytorch +cd pytorch +# if you are updating an existing checkout +git submodule sync +git submodule update --init --recursive +``` + +#### Install PyTorch +**On Linux** + +If you would like to compile PyTorch with [new C++ ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html) enabled, then first run this command: +```bash +export _GLIBCXX_USE_CXX11_ABI=1 +``` + +If you're compiling for AMD ROCm then first run this command: +```bash +# Only run this if you're compiling for ROCm +python tools/amd_build/build_amd.py +``` + +Install PyTorch +```bash +export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"} +python setup.py develop +``` + +> _Aside:_ If you are using [Anaconda](https://www.anaconda.com/distribution/#download-section), you may experience an error caused by the linker: +> +> ```plaintext +> build/temp.linux-x86_64-3.7/torch/csrc/stub.o: file not recognized: file format not recognized +> collect2: error: ld returned 1 exit status +> error: command 'g++' failed with exit status 1 +> ``` +> +> This is caused by `ld` from the Conda environment shadowing the system `ld`. You should use a newer version of Python that fixes this issue. The recommended Python version is 3.8.1+. + +**On macOS** + +```bash +python3 setup.py develop +``` + +**On Windows** + +Choose Correct Visual Studio Version. + +PyTorch CI uses Visual C++ BuildTools, which come with Visual Studio Enterprise, +Professional, or Community Editions. You can also install the build tools from +https://visualstudio.microsoft.com/visual-cpp-build-tools/. The build tools *do not* +come with Visual Studio Code by default. + +If you want to build legacy python code, please refer to [Building on legacy code and CUDA](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md#building-on-legacy-code-and-cuda) + +**CPU-only builds** + +In this mode PyTorch computations will run on your CPU, not your GPU + +```cmd +conda activate +python setup.py develop +``` + +Note on OpenMP: The desired OpenMP implementation is Intel OpenMP (iomp). In order to link against iomp, you'll need to manually download the library and set up the building environment by tweaking `CMAKE_INCLUDE_PATH` and `LIB`. The instruction [here](https://github.com/pytorch/pytorch/blob/main/docs/source/notes/windows.rst#building-from-source) is an example for setting up both MKL and Intel OpenMP. Without these configurations for CMake, Microsoft Visual C OpenMP runtime (vcomp) will be used. + +**CUDA based build** + +In this mode PyTorch computations will leverage your GPU via CUDA for faster number crunching + +[NVTX](https://docs.nvidia.com/gameworks/content/gameworkslibrary/nvtx/nvidia_tools_extension_library_nvtx.htm) is needed to build Pytorch with CUDA. +NVTX is a part of CUDA distributive, where it is called "Nsight Compute". To install it onto an already installed CUDA run CUDA installation once again and check the corresponding checkbox. +Make sure that CUDA with Nsight Compute is installed after Visual Studio. + +Currently, VS 2017 / 2019, and Ninja are supported as the generator of CMake. If `ninja.exe` is detected in `PATH`, then Ninja will be used as the default generator, otherwise, it will use VS 2017 / 2019. +
If Ninja is selected as the generator, the latest MSVC will get selected as the underlying toolchain. + +Additional libraries such as +[Magma](https://developer.nvidia.com/magma), [oneDNN, a.k.a. MKLDNN or DNNL](https://github.com/oneapi-src/oneDNN), and [Sccache](https://github.com/mozilla/sccache) are often needed. Please refer to the [installation-helper](https://github.com/pytorch/pytorch/tree/main/.ci/pytorch/win-test-helpers/installation-helpers) to install them. + +You can refer to the [build_pytorch.bat](https://github.com/pytorch/pytorch/blob/main/.ci/pytorch/win-test-helpers/build_pytorch.bat) script for some other environment variables configurations + + +```cmd +cmd + +:: Set the environment variables after you have downloaded and unzipped the mkl package, +:: else CMake would throw an error as `Could NOT find OpenMP`. +set CMAKE_INCLUDE_PATH={Your directory}\mkl\include +set LIB={Your directory}\mkl\lib;%LIB% + +:: Read the content in the previous section carefully before you proceed. +:: [Optional] If you want to override the underlying toolset used by Ninja and Visual Studio with CUDA, please run the following script block. +:: "Visual Studio 2019 Developer Command Prompt" will be run automatically. +:: Make sure you have CMake >= 3.12 before you do this when you use the Visual Studio generator. +set CMAKE_GENERATOR_TOOLSET_VERSION=14.27 +set DISTUTILS_USE_SDK=1 +for /f "usebackq tokens=*" %i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -version [15^,17^) -products * -latest -property installationPath`) do call "%i\VC\Auxiliary\Build\vcvarsall.bat" x64 -vcvars_ver=%CMAKE_GENERATOR_TOOLSET_VERSION% + +:: [Optional] If you want to override the CUDA host compiler +set CUDAHOSTCXX=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.27.29110\bin\HostX64\x64\cl.exe + +python setup.py develop + +``` + +##### Adjust Build Options (Optional) + +You can adjust the configuration of cmake variables optionally (without building first), by doing +the following. For example, adjusting the pre-detected directories for CuDNN or BLAS can be done +with such a step. + +On Linux +```bash +export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"} +python setup.py build --cmake-only +ccmake build # or cmake-gui build +``` + +On macOS +```bash +export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"} +MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py build --cmake-only +ccmake build # or cmake-gui build +``` + +### Docker Image + +#### Using pre-built images + +You can also pull a pre-built docker image from Docker Hub and run with docker v19.03+ + +```bash +docker run --gpus all --rm -ti --ipc=host pytorch/pytorch:latest +``` + +Please note that PyTorch uses shared memory to share data between processes, so if torch multiprocessing is used (e.g. +for multithreaded data loaders) the default shared memory segment size that container runs with is not enough, and you +should increase shared memory size either with `--ipc=host` or `--shm-size` command line options to `nvidia-docker run`. + +#### Building the image yourself + +**NOTE:** Must be built with a docker version > 18.06 + +The `Dockerfile` is supplied to build images with CUDA 11.1 support and cuDNN v8. +You can pass `PYTHON_VERSION=x.y` make variable to specify which Python version is to be used by Miniconda, or leave it +unset to use the default. + +```bash +make -f docker.Makefile +# images are tagged as docker.io/${your_docker_username}/pytorch +``` + +You can also pass the `CMAKE_VARS="..."` environment variable to specify additional CMake variables to be passed to CMake during the build. +See [setup.py](./setup.py) for the list of available variables. + +```bash +CMAKE_VARS="BUILD_CAFFE2=ON BUILD_CAFFE2_OPS=ON" make -f docker.Makefile +``` + +### Building the Documentation + +To build documentation in various formats, you will need [Sphinx](http://www.sphinx-doc.org) and the +readthedocs theme. + +```bash +cd docs/ +pip install -r requirements.txt +``` +You can then build the documentation by running `make ` from the +`docs/` folder. Run `make` to get a list of all available output formats. + +If you get a katex error run `npm install katex`. If it persists, try +`npm install -g katex` + +> Note: if you installed `nodejs` with a different package manager (e.g., +`conda`) then `npm` will probably install a version of `katex` that is not +compatible with your version of `nodejs` and doc builds will fail. +A combination of versions that is known to work is `node@6.13.1` and +`katex@0.13.18`. To install the latter with `npm` you can run +```npm install -g katex@0.13.18``` + +### Previous Versions + +Installation instructions and binaries for previous PyTorch versions may be found +on [our website](https://pytorch.org/previous-versions). + + +## Getting Started + +Three-pointers to get you started: +- [Tutorials: get you started with understanding and using PyTorch](https://pytorch.org/tutorials/) +- [Examples: easy to understand PyTorch code across all domains](https://github.com/pytorch/examples) +- [The API Reference](https://pytorch.org/docs/) +- [Glossary](https://github.com/pytorch/pytorch/blob/main/GLOSSARY.md) + +## Resources + +* [PyTorch.org](https://pytorch.org/) +* [PyTorch Tutorials](https://pytorch.org/tutorials/) +* [PyTorch Examples](https://github.com/pytorch/examples) +* [PyTorch Models](https://pytorch.org/hub/) +* [Intro to Deep Learning with PyTorch from Udacity](https://www.udacity.com/course/deep-learning-pytorch--ud188) +* [Intro to Machine Learning with PyTorch from Udacity](https://www.udacity.com/course/intro-to-machine-learning-nanodegree--nd229) +* [Deep Neural Networks with PyTorch from Coursera](https://www.coursera.org/learn/deep-neural-networks-with-pytorch) +* [PyTorch Twitter](https://twitter.com/PyTorch) +* [PyTorch Blog](https://pytorch.org/blog/) +* [PyTorch YouTube](https://www.youtube.com/channel/UCWXI5YeOsh03QvJ59PMaXFw) + +## Communication +* Forums: Discuss implementations, research, etc. https://discuss.pytorch.org +* GitHub Issues: Bug reports, feature requests, install issues, RFCs, thoughts, etc. +* Slack: The [PyTorch Slack](https://pytorch.slack.com/) hosts a primary audience of moderate to experienced PyTorch users and developers for general chat, online discussions, collaboration, etc. If you are a beginner looking for help, the primary medium is [PyTorch Forums](https://discuss.pytorch.org). If you need a slack invite, please fill this form: https://goo.gl/forms/PP1AGvNHpSaJP8to1 +* Newsletter: No-noise, a one-way email newsletter with important announcements about PyTorch. You can sign-up here: https://eepurl.com/cbG0rv +* Facebook Page: Important announcements about PyTorch. https://www.facebook.com/pytorch +* For brand guidelines, please visit our website at [pytorch.org](https://pytorch.org/) + +## Releases and Contributing + +Typically, PyTorch has three minor releases a year. Please let us know if you encounter a bug by [filing an issue](https://github.com/pytorch/pytorch/issues). + +We appreciate all contributions. If you are planning to contribute back bug-fixes, please do so without any further discussion. + +If you plan to contribute new features, utility functions, or extensions to the core, please first open an issue and discuss the feature with us. +Sending a PR without discussion might end up resulting in a rejected PR because we might be taking the core in a different direction than you might be aware of. + +To learn more about making a contribution to Pytorch, please see our [Contribution page](CONTRIBUTING.md). For more information about PyTorch releases, see [Release page](RELEASE.md). + +## The Team + +PyTorch is a community-driven project with several skillful engineers and researchers contributing to it. + +PyTorch is currently maintained by [Soumith Chintala](http://soumith.ch), [Gregory Chanan](https://github.com/gchanan), [Dmytro Dzhulgakov](https://github.com/dzhulgakov), [Edward Yang](https://github.com/ezyang), and [Nikita Shulga](https://github.com/malfet) with major contributions coming from hundreds of talented individuals in various forms and means. +A non-exhaustive but growing list needs to mention: Trevor Killeen, Sasank Chilamkurthy, Sergey Zagoruyko, Adam Lerer, Francisco Massa, Alykhan Tejani, Luca Antiga, Alban Desmaison, Andreas Koepf, James Bradbury, Zeming Lin, Yuandong Tian, Guillaume Lample, Marat Dukhan, Natalia Gimelshein, Christian Sarofeen, Martin Raison, Edward Yang, Zachary Devito. + +Note: This project is unrelated to [hughperkins/pytorch](https://github.com/hughperkins/pytorch) with the same name. Hugh is a valuable contributor to the Torch community and has helped with many things Torch and PyTorch. + +## License + +PyTorch has a BSD-style license, as found in the [LICENSE](LICENSE) file. + + diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/NOTICE b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/NOTICE new file mode 100644 index 0000000000000000000000000000000000000000..6effb8b5d70709f90835f2f5d646352fd77b6943 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/NOTICE @@ -0,0 +1,456 @@ +======================================================================= +Software under third_party +======================================================================= +Software libraries under third_party are provided as github submodule +links, and their content is not part of the Caffe2 codebase. Their +licences can be found under the respective software repositories. + +======================================================================= +Earlier BSD License +======================================================================= +Early development of Caffe2 in 2015 and early 2016 is licensed under the +BSD license. The license is attached below: + +All contributions by Facebook: +Copyright (c) 2016 Facebook Inc. + +All contributions by Google: +Copyright (c) 2015 Google Inc. +All rights reserved. + +All contributions by Yangqing Jia: +Copyright (c) 2015 Yangqing Jia +All rights reserved. + +All contributions by Kakao Brain: +Copyright 2019-2020 Kakao Brain + +All other contributions: +Copyright(c) 2015, 2016 the respective contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +======================================================================= +Caffe's BSD License +======================================================================= +Some parts of the caffe2 code is derived from the original Caffe code, which is +created by Yangqing Jia and is now a BSD-licensed open-source project. The Caffe +license is as follows: + +COPYRIGHT + +All contributions by the University of California: +Copyright (c) 2014, The Regents of the University of California (Regents) +All rights reserved. + +All other contributions: +Copyright (c) 2014, the respective contributors +All rights reserved. + +Caffe uses a shared copyright model: each contributor holds copyright over +their contributions to Caffe. The project versioning records all such +contribution and copyright details. If a contributor wants to further mark +their specific copyright on a particular contribution, they should indicate +their copyright solely in the commit message of the change when it is +committed. + +LICENSE + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +CONTRIBUTION AGREEMENT + +By contributing to the BVLC/caffe repository through pull-request, comment, +or otherwise, the contributor releases their content to the +license and copyright terms herein. + +======================================================================= +Caffe2's Apache License +======================================================================= + +This repo contains Caffe2 code, which was previously licensed under +Apache License Version 2.0: + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +======================================================================= +Cephes's 3-Clause BSD License +======================================================================= + +Code derived from implementations in the Cephes Math Library should mention +its derivation and reference the following license: + + 3-Clause BSD License for the Cephes Math Library + Copyright (c) 2018, Steven Moshier + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL Steven Moshier BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +======================================================================= +SciPy's 3-Clause BSD License +======================================================================= + +Code derived from implementations in SciPy should mention its derivation +and reference the following license: + + Copyright (c) 2001-2002 Enthought, Inc. 2003-2019, SciPy Developers. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + 3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +======================================================================= +Boost's 1.0 Software License +======================================================================= + +Code derived from implementations in Boost 1.0 should mention its +derivation and reference the following license: + + Boost Software License - Version 1.0 - August 17th, 2003 + + Permission is hereby granted, free of charge, to any person or organization + obtaining a copy of the software and accompanying documentation covered by + this license (the "Software") to use, reproduce, display, distribute, + execute, and transmit the Software, and to prepare derivative works of the + Software, and to permit third-parties to whom the Software is furnished to + do so, all subject to the following: + + The copyright notices in the Software and this entire statement, including + the above license grant, this restriction and the following disclaimer, + must be included in all copies of the Software, in whole or in part, and + all derivative works of the Software, unless such copies or derivative + works are solely in the form of machine-executable object code generated by + a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT + SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE + FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +======================================================================= +PILLOW-SIMD Software License +======================================================================= + +Code derived from implementations in PILLOW-SIMD should mention its derivation +and reference the following license: + + The Python Imaging Library (PIL) is + + Copyright © 1997-2011 by Secret Labs AB + Copyright © 1995-2011 by Fredrik Lundh + + Pillow is the friendly PIL fork. It is + + Copyright © 2010-2022 by Alex Clark and contributors + + Like PIL, Pillow is licensed under the open source HPND License: + + By obtaining, using, and/or copying this software and/or its associated + documentation, you agree that you have read, understood, and will comply + with the following terms and conditions: + + Permission to use, copy, modify, and distribute this software and its + associated documentation for any purpose and without fee is hereby granted, + provided that the above copyright notice appears in all copies, and that + both that copyright notice and this permission notice appear in supporting + documentation, and that the name of Secret Labs AB or the author not be + used in advertising or publicity pertaining to distribution of the software + without specific, written prior permission. + + SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. + IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR ANY SPECIAL, + INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE + OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..3800fcbb54e3eff4edb8b35e380ddc02bb19b408 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/RECORD @@ -0,0 +1,12375 @@ +../../../bin/convert-caffe2-to-onnx,sha256=gfPuyRMDxAUfpOvyhgVAg9bbI9K1Vzp2BRERohJLtEs,281 +../../../bin/convert-onnx-to-caffe2,sha256=tKHms-D7N47BNjB8ZWue7ocOIWQC8BG22o8YtGcg-I0,281 +../../../bin/torchrun,sha256=hSnYQU13_EsXvCLy6hH1cbYqqjRMCJj4tzueVWTpkF4,249 +functorch/_C.cpython-310-x86_64-linux-gnu.so,sha256=LK5CxmdAos030fP_EdeZldSnlgedm17DRZewXu0ThAM,320008 +functorch/__init__.py,sha256=Y28_YMDp8flLTOzgZaAImTOaN6W_7PYCFOwpiqksjcI,1036 +functorch/__pycache__/__init__.cpython-310.pyc,, +functorch/_src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +functorch/_src/__pycache__/__init__.cpython-310.pyc,, +functorch/_src/aot_autograd/__init__.py,sha256=SGo7gh6XGYcOxTGf5g-R8Y9AF95ICcJbQwQD6rFyrpQ,291 +functorch/_src/aot_autograd/__pycache__/__init__.cpython-310.pyc,, +functorch/_src/eager_transforms/__init__.py,sha256=kX_52fDvSX9YX9OAwo5bjvJtrxyjEBUJ1PueW8xgsuw,291 +functorch/_src/eager_transforms/__pycache__/__init__.cpython-310.pyc,, +functorch/_src/make_functional/__init__.py,sha256=b3y8s3KhtCqFB8lM4Pi48AwuztUt7NBK-VISZNJYYjw,235 +functorch/_src/make_functional/__pycache__/__init__.cpython-310.pyc,, +functorch/_src/vmap/__init__.py,sha256=k8r2Esz6tB5D7U_UA0_BCDaWoOmn8JNVrRqK7nG7_fM,467 +functorch/_src/vmap/__pycache__/__init__.cpython-310.pyc,, +functorch/compile/__init__.py,sha256=nGc0FPG2_i1LomWKoONviGJejMB3L--dTiu7-MoxQEA,778 +functorch/compile/__pycache__/__init__.cpython-310.pyc,, +functorch/dim/__init__.py,sha256=T1t7j-_vi5iG8WpO3VmSDGVG8x31CJ7RFgDvSELve2o,4721 +functorch/dim/__pycache__/__init__.cpython-310.pyc,, +functorch/dim/__pycache__/batch_tensor.cpython-310.pyc,, +functorch/dim/__pycache__/delayed_mul_tensor.cpython-310.pyc,, +functorch/dim/__pycache__/dim.cpython-310.pyc,, +functorch/dim/__pycache__/magic_trace.cpython-310.pyc,, +functorch/dim/__pycache__/op_properties.cpython-310.pyc,, +functorch/dim/__pycache__/reference.cpython-310.pyc,, +functorch/dim/__pycache__/tree_map.cpython-310.pyc,, +functorch/dim/__pycache__/wrap_type.cpython-310.pyc,, +functorch/dim/batch_tensor.py,sha256=Ez0WuVYen87Uwr-lNvvNS4DE4KyNePoT_iVHNqxCXcE,667 +functorch/dim/delayed_mul_tensor.py,sha256=B9pt_vOxrKeISz-MY6_qZBhnNKtrixs4GtUA792b7G0,2441 +functorch/dim/dim.py,sha256=CzFAkSX4ZGasNHjr2huoVNxuQYd0N4RCBfGRC7a0Pew,3398 +functorch/dim/magic_trace.py,sha256=oUxIOV2TPg0eIStZDoGt03_l_T2vFxGohnhBtL6SB-w,1329 +functorch/dim/op_properties.py,sha256=zIKVxfJK70djF5u4A7yirbaP0w2vJdLECTPOgzG5n8Q,6686 +functorch/dim/reference.py,sha256=-jus24wANmr5eeWo6uLQaric9iPUfCqobGQ2ljqxVDc,20340 +functorch/dim/tree_map.py,sha256=Rd_ECsBGK7Ln-DdD7xzKCE-WynJZXxd3Dno_Vk_mKo0,374 +functorch/dim/wrap_type.py,sha256=7PZ4HSK3TBXYoMOCHhdkip_o3ej23m4ihc3-eYPZMQE,1870 +functorch/einops/__init__.py,sha256=CW4zh8RmbocIdau3cQHmm4_hscNvSz1eEddiciLeI6A,58 +functorch/einops/__pycache__/__init__.cpython-310.pyc,, +functorch/einops/__pycache__/_parsing.cpython-310.pyc,, +functorch/einops/__pycache__/rearrange.cpython-310.pyc,, +functorch/einops/_parsing.py,sha256=0K3ysuPKKZnWbfe5RppFUxF59b0bC-gyA3lkjmYAO1A,12256 +functorch/einops/rearrange.py,sha256=sozTSLCV5Bwinl4pTLq7pEEY5TExknBo1dMwRIi10lY,8040 +functorch/experimental/__init__.py,sha256=vUxiLGMHBcb_WdL975-kDwVotERGu_HaRWp4CtEeYdk,274 +functorch/experimental/__pycache__/__init__.cpython-310.pyc,, +functorch/experimental/__pycache__/control_flow.cpython-310.pyc,, +functorch/experimental/__pycache__/ops.cpython-310.pyc,, +functorch/experimental/control_flow.py,sha256=9mr45aFARZRgUcGv7E5NWXARQRp313rUvUdhu0Lw3zg,234 +functorch/experimental/ops.py,sha256=kDGcckdoYwOg9fS4JqvZnsIt8Ss9O6RGeasJSyi0OUY,57 +torch-2.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +torch-2.3.0.dist-info/LICENSE,sha256=nCkW1Dsriv9qPGZi7VhLay19bc-E3XJxgd7q3FRyIU4,351851 +torch-2.3.0.dist-info/METADATA,sha256=FlftEZi7t3xSTAGPdEdc8tJBKsz3QXPGPFekK3F8SZs,26140 +torch-2.3.0.dist-info/NOTICE,sha256=wsx78MrsdlLCtGCopHC-oWd_JB5KuOQx3zTPF_Wp_sA,23632 +torch-2.3.0.dist-info/RECORD,, +torch-2.3.0.dist-info/WHEEL,sha256=oPTolxX39D9SX81DhGjP9ncZ9PHcmhO1jInNxQx689I,105 +torch-2.3.0.dist-info/entry_points.txt,sha256=xMSIP4HwaUB13rP--Tb-tzNedGSUDspggHI2VhgOsA8,297 +torch-2.3.0.dist-info/top_level.txt,sha256=MsBcfJyMU15lW1efu5w7Tzd4MenrYHiuaixbHMfAoco,25 +torch/_C.cpython-310-x86_64-linux-gnu.so,sha256=HF4NajEqWdwshYfqx5_6Pu3MQW550baIy68v_wInhHI,37857 +torch/_C/_VariableFunctions.pyi,sha256=kmuEzpodTqrBJhZhx054yhGBqizo80StmroZOGZz-dI,1137705 +torch/_C/__init__.pyi,sha256=nI1LOozrUN1RnquW0DmG1HHwKCt0kd5Xvw09WeV0kN4,396048 +torch/_C/_aoti.pyi,sha256=Hce4iUKhToHUO2K-KEfelaKwv50LrJ3JKRsqNCp-9d4,135 +torch/_C/_autograd.pyi,sha256=QWkPDwleJDoJCDdqKT2tTjC64ImkAY6PogE88EQBzBc,4116 +torch/_C/_cpu.pyi,sha256=YnxQHlk_hFTuke_1WlJZxwep_RYgzq2hvyl4aH2gYQM,112 +torch/_C/_cudnn.pyi,sha256=FwKVMtP_qbhryc7MBN6zm3XIJoLMk8pWqvvQKJSx3O4,370 +torch/_C/_distributed_autograd.pyi,sha256=q0F_4D0Euc7Pv6668CnlBoirjX-Dq6OENeq5FCq3azA,908 +torch/_C/_distributed_c10d.pyi,sha256=dQpUBPrdi92xPAl1HqzXdsQxFm4SSg4t0NAb2bj7IxQ,16332 +torch/_C/_distributed_rpc.pyi,sha256=P5bPlH2aKefOxLGB0as2BOGM0ByYm8-EWAWHCtVhjoM,6035 +torch/_C/_distributed_rpc_testing.pyi,sha256=Q8BsOlBlOHHASL8tPLHaXjQFR1S4-_NcCNvrLBQr2GE,1017 +torch/_C/_functions.pyi,sha256=vWT20CisChXAtpHwWwVR4uf4IpqEe01eDBVEnYMll2M,330 +torch/_C/_functorch.pyi,sha256=AWoWIw_YJmfnFKYQw6tgIFB95wF5388V3AGl4FO4Dfw,2946 +torch/_C/_itt.pyi,sha256=6fhhHGYgreXbGka-VtqX9FjjPaSznfOmDHPVC171DII,169 +torch/_C/_lazy.pyi,sha256=72HGDtJgNrdFelZN2ME1jAwlz78JmXy82KdDwSfUVhg,969 +torch/_C/_lazy_ts_backend.pyi,sha256=F2K8cpm-lan0FTL4bSZ28hXnGaeJguppGAIYMR4Sw9w,312 +torch/_C/_monitor.pyi,sha256=dZKJHgFroqeP9D_F1dGTJ19gSW-94zfIJTmDLeFp5_k,1053 +torch/_C/_nn.pyi,sha256=FA_JQd8LxVhSHdwsseEJASe5R16Bot3FYYdYh8kLG7w,4130 +torch/_C/_nvtx.pyi,sha256=v1D4bcM8nV28xx0_itTEoUfvOaAHYIfBrgMriuH5fzI,223 +torch/_C/_onnx.pyi,sha256=TaaFXCeuJAf_CNOQlrcM7cKCCqo2hTfM-COo72ya89E,738 +torch/_C/_profiler.pyi,sha256=JjB-70DAY8XwZq1CTmugFkWf4VeZHYO7MeHz7IUc-Ns,6176 +torch/_C/_verbose.pyi,sha256=vMdQYMqABMqBFxYykp8_VD0QBaubolczBmCEv-UcA00,134 +torch/_VF.py,sha256=6gWebiEvyG5GFiNTcMuigU7UAPEesYJmWKQTL_1GTrM,643 +torch/_VF.pyi,sha256=kmuEzpodTqrBJhZhx054yhGBqizo80StmroZOGZz-dI,1137705 +torch/__config__.py,sha256=kv8yDflHiu3B2rxjOe48upLeB2VXnTxdXKeAYcxnJ5c,553 +torch/__future__.py,sha256=yk9l_KWsfVIzUBx9cGr-OdtWmb-pI8ZhcROAm3a_FQw,3185 +torch/__init__.py,sha256=kCWXnQYOawq9ORqPg-5cLOnMwoAboxlI8PQcgqwHJzA,79997 +torch/__pycache__/_VF.cpython-310.pyc,, +torch/__pycache__/__config__.cpython-310.pyc,, +torch/__pycache__/__future__.cpython-310.pyc,, +torch/__pycache__/__init__.cpython-310.pyc,, +torch/__pycache__/_appdirs.cpython-310.pyc,, +torch/__pycache__/_classes.cpython-310.pyc,, +torch/__pycache__/_compile.cpython-310.pyc,, +torch/__pycache__/_custom_ops.cpython-310.pyc,, +torch/__pycache__/_deploy.cpython-310.pyc,, +torch/__pycache__/_guards.cpython-310.pyc,, +torch/__pycache__/_jit_internal.cpython-310.pyc,, +torch/__pycache__/_linalg_utils.cpython-310.pyc,, +torch/__pycache__/_lobpcg.cpython-310.pyc,, +torch/__pycache__/_lowrank.cpython-310.pyc,, +torch/__pycache__/_meta_registrations.cpython-310.pyc,, +torch/__pycache__/_namedtensor_internals.cpython-310.pyc,, +torch/__pycache__/_ops.cpython-310.pyc,, +torch/__pycache__/_python_dispatcher.cpython-310.pyc,, +torch/__pycache__/_sources.cpython-310.pyc,, +torch/__pycache__/_storage_docs.cpython-310.pyc,, +torch/__pycache__/_streambase.cpython-310.pyc,, +torch/__pycache__/_tensor.cpython-310.pyc,, +torch/__pycache__/_tensor_docs.cpython-310.pyc,, +torch/__pycache__/_tensor_str.cpython-310.pyc,, +torch/__pycache__/_torch_docs.cpython-310.pyc,, +torch/__pycache__/_utils.cpython-310.pyc,, +torch/__pycache__/_utils_internal.cpython-310.pyc,, +torch/__pycache__/_vmap_internals.cpython-310.pyc,, +torch/__pycache__/_weights_only_unpickler.cpython-310.pyc,, +torch/__pycache__/functional.cpython-310.pyc,, +torch/__pycache__/hub.cpython-310.pyc,, +torch/__pycache__/library.cpython-310.pyc,, +torch/__pycache__/overrides.cpython-310.pyc,, +torch/__pycache__/quasirandom.cpython-310.pyc,, +torch/__pycache__/random.cpython-310.pyc,, +torch/__pycache__/return_types.cpython-310.pyc,, +torch/__pycache__/serialization.cpython-310.pyc,, +torch/__pycache__/storage.cpython-310.pyc,, +torch/__pycache__/torch_version.cpython-310.pyc,, +torch/__pycache__/types.cpython-310.pyc,, +torch/__pycache__/version.cpython-310.pyc,, +torch/_appdirs.py,sha256=GjuBh72l3BhGE4vJSdqGj-8QHjGbkhuMYaOLchLcqOQ,26167 +torch/_awaits/__init__.py,sha256=ghtTYluOc1VWTFv0gs2t9EBjhKx6v3V5TMkAedKooSo,1683 +torch/_awaits/__pycache__/__init__.cpython-310.pyc,, +torch/_classes.py,sha256=zez2IGbpzN3f1P7Tg8s-fg3pz_ATN6hAVTxKsSqtV9o,1686 +torch/_compile.py,sha256=a2g6zXCXwnirEFu-VSiSzRfk23_-E0MgVbodLOHfjr0,1001 +torch/_custom_op/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_custom_op/__pycache__/__init__.cpython-310.pyc,, +torch/_custom_op/__pycache__/autograd.cpython-310.pyc,, +torch/_custom_op/__pycache__/functional.cpython-310.pyc,, +torch/_custom_op/__pycache__/impl.cpython-310.pyc,, +torch/_custom_op/autograd.py,sha256=OjkfNxlNwxRRAbRSFG9fG89yEVHOZMOYR8gULX01rNI,11791 +torch/_custom_op/functional.py,sha256=Oo4M7_cZvMW4p3lrzwQVXcgXqhm92pmQnnb873Bl5hc,7925 +torch/_custom_op/impl.py,sha256=f33ZEBQLc8OgpGYaQugWkz0PFAU2CQTioRhi-93NHNA,39922 +torch/_custom_ops.py,sha256=Gelu9VakzzmHLN1vg4aN1pP9OYpFzn2z3UbfWRkuUCg,12783 +torch/_decomp/__init__.py,sha256=kKGNFm5JwceiH_YIPk422ZVlGjjJx2L4d4JtuhwsiWU,16129 +torch/_decomp/__pycache__/__init__.cpython-310.pyc,, +torch/_decomp/__pycache__/decompositions.cpython-310.pyc,, +torch/_decomp/__pycache__/decompositions_for_jvp.cpython-310.pyc,, +torch/_decomp/__pycache__/decompositions_for_rng.cpython-310.pyc,, +torch/_decomp/decompositions.py,sha256=SQX8kAzylaBUvc2CWurx9302fIOw91CH96_hBCZoSiU,157559 +torch/_decomp/decompositions_for_jvp.py,sha256=_N6-Rw1qcxS3Hfi7Xb-nR8cf2rsoHfo59fjvQ3bgmTQ,10829 +torch/_decomp/decompositions_for_rng.py,sha256=kb3KaDcF5VPfhWME1YzCW86zMbFWuNg6oOeEzeCViIg,9115 +torch/_deploy.py,sha256=Cbl8J4xj6P2QuevwRm5z4nGg7tSRUS8Yx-lCLKT4o6U,3507 +torch/_dispatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_dispatch/__pycache__/__init__.cpython-310.pyc,, +torch/_dispatch/__pycache__/python.cpython-310.pyc,, +torch/_dispatch/python.py,sha256=MnGwjS68xL5ErBwASeu6Pr4ZpHQgwjqXGnur63b8Ygc,6345 +torch/_dynamo/__init__.py,sha256=ChxPY1QnioNOt1fEqhaAL_1Q30U4XwZIIKa9at2ChJw,2730 +torch/_dynamo/__pycache__/__init__.cpython-310.pyc,, +torch/_dynamo/__pycache__/_trace_wrapped_higher_order_op.cpython-310.pyc,, +torch/_dynamo/__pycache__/bytecode_analysis.cpython-310.pyc,, +torch/_dynamo/__pycache__/bytecode_transformation.cpython-310.pyc,, +torch/_dynamo/__pycache__/cache_size.cpython-310.pyc,, +torch/_dynamo/__pycache__/callback.cpython-310.pyc,, +torch/_dynamo/__pycache__/code_context.cpython-310.pyc,, +torch/_dynamo/__pycache__/codegen.cpython-310.pyc,, +torch/_dynamo/__pycache__/compiled_autograd.cpython-310.pyc,, +torch/_dynamo/__pycache__/comptime.cpython-310.pyc,, +torch/_dynamo/__pycache__/config.cpython-310.pyc,, +torch/_dynamo/__pycache__/convert_frame.cpython-310.pyc,, +torch/_dynamo/__pycache__/current_scope_id.cpython-310.pyc,, +torch/_dynamo/__pycache__/debug_utils.cpython-310.pyc,, +torch/_dynamo/__pycache__/decorators.cpython-310.pyc,, +torch/_dynamo/__pycache__/device_interface.cpython-310.pyc,, +torch/_dynamo/__pycache__/eval_frame.cpython-310.pyc,, +torch/_dynamo/__pycache__/exc.cpython-310.pyc,, +torch/_dynamo/__pycache__/external_utils.cpython-310.pyc,, +torch/_dynamo/__pycache__/funcname_cache.cpython-310.pyc,, +torch/_dynamo/__pycache__/guards.cpython-310.pyc,, +torch/_dynamo/__pycache__/hooks.cpython-310.pyc,, +torch/_dynamo/__pycache__/logging.cpython-310.pyc,, +torch/_dynamo/__pycache__/mutation_guard.cpython-310.pyc,, +torch/_dynamo/__pycache__/output_graph.cpython-310.pyc,, +torch/_dynamo/__pycache__/polyfill.cpython-310.pyc,, +torch/_dynamo/__pycache__/profiler.cpython-310.pyc,, +torch/_dynamo/__pycache__/replay_record.cpython-310.pyc,, +torch/_dynamo/__pycache__/resume_execution.cpython-310.pyc,, +torch/_dynamo/__pycache__/side_effects.cpython-310.pyc,, +torch/_dynamo/__pycache__/source.cpython-310.pyc,, +torch/_dynamo/__pycache__/symbolic_convert.cpython-310.pyc,, +torch/_dynamo/__pycache__/tensor_version_op.cpython-310.pyc,, +torch/_dynamo/__pycache__/test_case.cpython-310.pyc,, +torch/_dynamo/__pycache__/test_minifier_common.cpython-310.pyc,, +torch/_dynamo/__pycache__/testing.cpython-310.pyc,, +torch/_dynamo/__pycache__/trace_rules.cpython-310.pyc,, +torch/_dynamo/__pycache__/types.cpython-310.pyc,, +torch/_dynamo/__pycache__/utils.cpython-310.pyc,, +torch/_dynamo/_trace_wrapped_higher_order_op.py,sha256=wP5DRPG3V2PcXcox-hoMY6325w2ldZjKLkQa2uzrY0Q,4964 +torch/_dynamo/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_dynamo/backends/__pycache__/__init__.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/common.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/cudagraphs.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/debugging.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/distributed.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/inductor.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/onnxrt.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/registry.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/tensorrt.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/torchxla.cpython-310.pyc,, +torch/_dynamo/backends/__pycache__/tvm.cpython-310.pyc,, +torch/_dynamo/backends/common.py,sha256=KTaAL-IZMr-uJDBnq8O036Xwzqn5bIngXnskGBiATdk,3409 +torch/_dynamo/backends/cudagraphs.py,sha256=mhvHg0P6N-kymh7VlHWuvmgwLeT4Bj161SwFKYu0Tuc,7663 +torch/_dynamo/backends/debugging.py,sha256=I7JFZyG-O0K4hFl9BeJRIobJK4XfFHhaUXFvdQCv5S0,9399 +torch/_dynamo/backends/distributed.py,sha256=hBk7NAgXAAXXDORv5moDv6MiYmdN5dpd6G-zoFpOI_M,29029 +torch/_dynamo/backends/inductor.py,sha256=Ifkk0MeBU7qu773L9RW2mMxtFMUjrKCCMz6oyjRDiqI,404 +torch/_dynamo/backends/onnxrt.py,sha256=cGW5EsT3ds-zkiD9reA5xBZtsobaYEUvShwp6lktT_0,1571 +torch/_dynamo/backends/registry.py,sha256=pXJIWroiQ_sZhkrOEOF8LKzWizOTcJQWE54T3x_7Xto,3452 +torch/_dynamo/backends/tensorrt.py,sha256=oMtmZB2Op6yeZvFXskMDZUATwLmgRCg4xxh3OrcVqSY,406 +torch/_dynamo/backends/torchxla.py,sha256=NI26CrYxoSXrTMUGjX0_IrOUVhBKOINMmIZ5YNgIDc0,1963 +torch/_dynamo/backends/tvm.py,sha256=D70yByiG4r8pPYhx2lTmHmcvWv0Bw3tL070ezqscUtc,6383 +torch/_dynamo/bytecode_analysis.py,sha256=icVq7mo1bIMGoeHPBBZQWhqYmAAFfDCC-PGJ07cQR1k,8494 +torch/_dynamo/bytecode_transformation.py,sha256=7BARHvbehaMlC47NHZ7GHGOQYt_fMHb9Cp9QnCz6lDI,40086 +torch/_dynamo/cache_size.py,sha256=pECoSVHytZPT6ac74cxw1ugWMhKB-JKRMQnMvVGrf9A,7235 +torch/_dynamo/callback.py,sha256=vaedQNbZrvG_ICv3i67aNyfie4tI1qAuHQUNgTsN7Hk,2180 +torch/_dynamo/code_context.py,sha256=nJYn7eObIjeMFuWPy05SXFBgcYky7kcPY3RvbDCwjQ8,691 +torch/_dynamo/codegen.py,sha256=1WTVA5U0mlI_RdcLvkMQQbFBIIrZLR5eY5n-b2WIPV0,14996 +torch/_dynamo/compiled_autograd.py,sha256=uUa9N0lapFr6QjoKS-qKB8WZJZvLAZQEIJo6332HtOU,9740 +torch/_dynamo/comptime.py,sha256=bILv86HHTWqKf7scczo_VA1bWssy8B0hTdVIcgb3cbg,12606 +torch/_dynamo/config.py,sha256=mrXAm3wroA2ZU4GujsA2HNF5Y2-1FSqfAOndbQ3YVks,17875 +torch/_dynamo/convert_frame.py,sha256=LYH5vlgzqUJ82pBguXz8O_v4DP5oFBe5wmZ6csg1mN0,33199 +torch/_dynamo/current_scope_id.py,sha256=MBPMg1Ut9VSJ7GazMZj348skpSyFBdQNEMBNJnYviVc,610 +torch/_dynamo/debug_utils.py,sha256=Xq5P2sYNs9zqA_HvWf8McZaOW9lzLns27I4eQXWc_Qo,27569 +torch/_dynamo/decorators.py,sha256=nkteor2y8LgY8FSf9bQHm2CsAvVBBTQnxLy8tSp7X3c,11590 +torch/_dynamo/device_interface.py,sha256=QpnU12Xgn-UGsU1Tae1YBvLldUWSPvYr0jHr1neBLrY,6755 +torch/_dynamo/eval_frame.py,sha256=lqKK1Yy_wBAFJpZz4KmGZTGdzNWT0xgrhiU33OfC19c,58427 +torch/_dynamo/exc.py,sha256=ZFVxYDq3vwLKay8TS5e_GIZnoGaCsommq7RCyRLFZOg,10595 +torch/_dynamo/external_utils.py,sha256=eLahccp6afm_nRLtb9zuxKzKR_XPpUEFdo24rja5oqs,2700 +torch/_dynamo/funcname_cache.py,sha256=vqzngOWuppCuV5bx1_0XBaUHSoiVLH16UMVHVoFQ5vY,1750 +torch/_dynamo/guards.py,sha256=VkwUyrGRvheoQpwwTlP-ZbRkqD1hdfXTBOMjK6t4Xpc,59175 +torch/_dynamo/hooks.py,sha256=TJ7ASly13VsYGHcbSxHwFyQ7YcN_ZBlztgQNYABlxco,292 +torch/_dynamo/logging.py,sha256=_H34zW2UklOpa9rL94kZbvQq3a7I0mGxmaQeEislZwY,1568 +torch/_dynamo/mutation_guard.py,sha256=unKzRyfKVnK6NNCCRTj9m8WNpYw1-_P_75Sv4WcG-1Y,3488 +torch/_dynamo/output_graph.py,sha256=3OppEE2_DJaSo61CgI8Mve-uptm6w4Lr99KVbwOQq38,84237 +torch/_dynamo/polyfill.py,sha256=Md3t0i6Jq2ZgaMB2y5WhjVxi6CNQ_HFzoNTofAHrscw,837 +torch/_dynamo/profiler.py,sha256=cfONnFaXhYMR9oNXaRiSb50xdKPBrWsS4TcDIQIBDnA,4851 +torch/_dynamo/replay_record.py,sha256=tRwR0b1giFM85mnJct7S-WxWWXNQAuMBPzMiw9Si7Yo,3309 +torch/_dynamo/repro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_dynamo/repro/__pycache__/__init__.cpython-310.pyc,, +torch/_dynamo/repro/__pycache__/after_aot.cpython-310.pyc,, +torch/_dynamo/repro/__pycache__/after_dynamo.cpython-310.pyc,, +torch/_dynamo/repro/after_aot.py,sha256=SQHBxCUxg63KJQvf__nhjv6A5Ua9P_r35F9Xh6LQZSE,32007 +torch/_dynamo/repro/after_dynamo.py,sha256=i6PVuoYkEtfVCdp62IKM-6UD6kTl4EyIs56G-j3dRV4,18933 +torch/_dynamo/resume_execution.py,sha256=SVF9CileZ4MyaYEhhI_Zz9Lgifq3g0irTdFVVlSPymg,25300 +torch/_dynamo/side_effects.py,sha256=1uzU1h9tPv-E0enE9JD_89hjOrh_3zWHXkUxasH9cR4,22266 +torch/_dynamo/source.py,sha256=iFX6agEXzICHyE42nA3vn_FDFHshrkdObgzSEIDCiew,17173 +torch/_dynamo/symbolic_convert.py,sha256=biCPF0xm3j4MA2oEP7oh5_-A78B5GS5WcHugviw1ThI,96607 +torch/_dynamo/tensor_version_op.py,sha256=NOGcf4CigBUYsjhTATfN82MRvxeXiIntYDlyP0YLYzQ,2076 +torch/_dynamo/test_case.py,sha256=sysTPQr7PWydsmEZuimJ6z3kmlJe5Q3eGU68-Wmgyd8,2031 +torch/_dynamo/test_minifier_common.py,sha256=uCBT7901F2G6ZYqSS4Wl8ga7n2oCYnlxCoVxsTdj7-g,9737 +torch/_dynamo/testing.py,sha256=TggNqcRHcU4kdkj5pijLUFLMaj6G9vpAsD-jgdbBaVY,10964 +torch/_dynamo/trace_rules.py,sha256=9V43Ve6_6cbs-eFNNomYVgHYHz7jygiO6JfCefv2R7k,133231 +torch/_dynamo/types.py,sha256=9EnxmxaF5xV2mzm2OrjRbsivqAKkl_XvTjcmHbWppzI,2298 +torch/_dynamo/utils.py,sha256=F1GKJXyzEXlGFC5OamKutRsAUekG7sBQFEM5_MIcpA0,81182 +torch/_dynamo/variables/__init__.py,sha256=jHp4texMX6ST9W4zgXkvY7OhnmZUw_wPybLN45u_0gM,3904 +torch/_dynamo/variables/__pycache__/__init__.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/base.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/builder.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/builtin.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/constant.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/ctx_manager.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/dicts.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/distributed.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/functions.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/higher_order_ops.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/iter.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/lazy.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/lists.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/misc.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/nn_module.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/optimizer.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/sdpa.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/tensor.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/torch.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/torch_function.cpython-310.pyc,, +torch/_dynamo/variables/__pycache__/user_defined.cpython-310.pyc,, +torch/_dynamo/variables/base.py,sha256=9w9RXrQAwUOyEJVPBE4dN-n8jXySMSuHohN657LTCIc,13620 +torch/_dynamo/variables/builder.py,sha256=06NOB1MjUdGYNKlv2IlM_fNQmWTDvh8JcNQrd2gSbXc,83564 +torch/_dynamo/variables/builtin.py,sha256=NVtf5HiueOcAT9wPtcspitD5S5QnIWapHBGRC4dmNbI,66403 +torch/_dynamo/variables/constant.py,sha256=mecJwWjAWt_Iurn5j42wT0FDZsyUQWjq8BWo5HMFFmo,8190 +torch/_dynamo/variables/ctx_manager.py,sha256=WseIk9K5BN5dgtYJPh8W1u5By7Txv-WIDq1x-rnwk18,28338 +torch/_dynamo/variables/dicts.py,sha256=yJPlLC0aNemEFm2IvXtt6hj1BZtE_nE-J_VMfTOtHiI,30970 +torch/_dynamo/variables/distributed.py,sha256=8BZstUBMef4uhH8GD-qRzz3XOO3md_u7b1Y6bXRvq0k,13514 +torch/_dynamo/variables/functions.py,sha256=yj8sQrx0yHBtM1QpoI_M1mSP_i8sMxygBeZYb12T7Mc,35097 +torch/_dynamo/variables/higher_order_ops.py,sha256=sj9PIKlE0-a5K6C2o7WHa3pdjaJya4KA25kK4bdkD6U,62109 +torch/_dynamo/variables/iter.py,sha256=RFvmXryo1MDetwIwxvzhWdDiXKbdAQKiEQ6ZGKzYqKs,9600 +torch/_dynamo/variables/lazy.py,sha256=0Ot-utAOH8m0zoRxFake5fTApWaHxFnzm8XV94BWpZ0,3356 +torch/_dynamo/variables/lists.py,sha256=vjSYL2c5gpMtT7PGIUMAu0dPxS_O1xfPUjbr8otF8ZI,27405 +torch/_dynamo/variables/misc.py,sha256=6Fh9xV_uz2TWXpTVnu7ESWyxfXXjI6ckAmwjAsppLLQ,30834 +torch/_dynamo/variables/nn_module.py,sha256=7kQ6lm8gZGO454Joh4aFDjoxqc1zakgrQCCIKEkOln8,31926 +torch/_dynamo/variables/optimizer.py,sha256=wV2HJCLlbRyV_5uU-RJakA7_MlVTYKpZRnwc8SJ3Azs,9091 +torch/_dynamo/variables/sdpa.py,sha256=BG5g4mvJV7lCdCFjWUJUfporWUBIfq2EQhvdbT6VmuE,2867 +torch/_dynamo/variables/tensor.py,sha256=NydUTGrahbqBPDAKoxfxpgKjIJuUuXx_ePzUr4rR6MI,44397 +torch/_dynamo/variables/torch.py,sha256=YzzP3Q6QtACClgkunmUXO8BvlWEy9ENk04hDWIIycgI,34024 +torch/_dynamo/variables/torch_function.py,sha256=WQnD6RQnGLMOQIchu5ymMoFCFQOkZ9Me5XoGm9x_QZE,10429 +torch/_dynamo/variables/user_defined.py,sha256=6Mx6lKdUdyfwhLnbHOO22cNOR8sjmKYwoeZEOjx2pWI,35704 +torch/_export/__init__.py,sha256=ijjv_n5Gb3aEf7adk2wjiLCVMuNmuAfmVm-Qo_uCQVA,15103 +torch/_export/__pycache__/__init__.cpython-310.pyc,, +torch/_export/__pycache__/error.cpython-310.pyc,, +torch/_export/__pycache__/exported_program.cpython-310.pyc,, +torch/_export/__pycache__/non_strict_utils.cpython-310.pyc,, +torch/_export/__pycache__/pass_base.cpython-310.pyc,, +torch/_export/__pycache__/utils.cpython-310.pyc,, +torch/_export/__pycache__/verifier.cpython-310.pyc,, +torch/_export/__pycache__/wrappers.cpython-310.pyc,, +torch/_export/db/__init__.py,sha256=a3XxW1RcNAPwEVaI2g11hpnJvSHxGUFsGmDAWfDnLP8,206 +torch/_export/db/__pycache__/__init__.cpython-310.pyc,, +torch/_export/db/__pycache__/case.cpython-310.pyc,, +torch/_export/db/__pycache__/gen_example.cpython-310.pyc,, +torch/_export/db/__pycache__/logging.cpython-310.pyc,, +torch/_export/db/case.py,sha256=CYg5Q-nctcLiP4uu1t9BuvDTW36Yd4IcIggGfEWe270,5300 +torch/_export/db/examples/__init__.py,sha256=g3TlBUQ4nEIz57HbW7kgjJXi3jSg730tV-NMtFXOQUw,1264 +torch/_export/db/examples/__pycache__/__init__.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/assume_constant_result.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/autograd_function.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/class_method.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_branch_class_method.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_branch_nested_function.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_branch_nonlocal_variables.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_closed_over_variable.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_operands.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/cond_predicate.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/constrain_as_size_example.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/constrain_as_value_example.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/decorator.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dictionary.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_assert.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_constructor.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_if_guard.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_map.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_round.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_slicing.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/dynamic_shape_view.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/fn_with_kwargs.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/list_contains.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/list_unpack.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/model_attr_mutation.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/nested_function.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/null_context_manager.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/optional_input.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/pytree_flatten.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/scalar_output.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/specialized_attribute.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/static_for_loop.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/static_if.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/tensor_setattr.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/torch_sym_min.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/type_reflection_method.cpython-310.pyc,, +torch/_export/db/examples/__pycache__/user_input_mutation.cpython-310.pyc,, +torch/_export/db/examples/assume_constant_result.py,sha256=K3oo-N0f6_LoPrbW1vCpZGj2y_Npru5opdASs4ATjPM,573 +torch/_export/db/examples/autograd_function.py,sha256=i_lpenzirq3gHp_TzIJlViXRI1MPy7GWUqjcL9gW9Sg,593 +torch/_export/db/examples/class_method.py,sha256=aojP59KSeyUwpuTqhX1cZL74E1s_B4pyWox6KAceGBQ,509 +torch/_export/db/examples/cond_branch_class_method.py,sha256=Lf-R8ZCYCuiVA3KINLXLTPWem0BHVE808lYZ-5AKe9I,1342 +torch/_export/db/examples/cond_branch_nested_function.py,sha256=bJA9GIdUcEO2u6JZoQwekcPOns3YEXYPq2ABUuJ9qYw,1372 +torch/_export/db/examples/cond_branch_nonlocal_variables.py,sha256=z25uaknOqGVCpVzYJyuFKDDv33xFbn0RNXHZmn0bbwE,1909 +torch/_export/db/examples/cond_closed_over_variable.py,sha256=yUa4s3a9BiMAvZI4sRo5tg5PwK6Nb2VkRbND5psMCa0,556 +torch/_export/db/examples/cond_operands.py,sha256=_oGS8jiDEBYbMlc3R9zdzX0T5a0vAhpPFYsdYWksOCo,933 +torch/_export/db/examples/cond_predicate.py,sha256=qHlA47lXzQ5qMN9tGXFt2KAivZR0sCuatPZhVZUt15U,745 +torch/_export/db/examples/constrain_as_size_example.py,sha256=zMuV_9mOVkrO8wrk_DLCdfei-cT7SZAxv-9pkiJmSZI,697 +torch/_export/db/examples/constrain_as_value_example.py,sha256=hIzVdIemJaCKbV7N8UPZp1UuZGhDJMhGci2SGK-KFgM,763 +torch/_export/db/examples/decorator.py,sha256=2oQjjyUFc2ZFwoG_cecf4aZkznw1NggyBVoj1CJtG8A,500 +torch/_export/db/examples/dictionary.py,sha256=3AyTgM2i8NAeohHg8snZoMLPTAyo85fc_wI-efupdKI,477 +torch/_export/db/examples/dynamic_shape_assert.py,sha256=ciSV7IZICEQh0Og7kbBnZ6oZyjBrGQIcadomxJMel9o,515 +torch/_export/db/examples/dynamic_shape_constructor.py,sha256=YIXjt8FlSFHUEe0l8_YQu2TZ3HfE7QoEze00EslxGIU,455 +torch/_export/db/examples/dynamic_shape_if_guard.py,sha256=bLZUfx2sHvMWjnESh31w2UupAmhDjq7UwGPl0oDhYbA,573 +torch/_export/db/examples/dynamic_shape_map.py,sha256=cao6kTf9F0D_wHJUT-MHjEy4MwhvlxL3l2PJgVByxiQ,521 +torch/_export/db/examples/dynamic_shape_round.py,sha256=RsZpRz5e8FJW0XOOPESGnvJj2A3tVeH05orU8D4oYag,564 +torch/_export/db/examples/dynamic_shape_slicing.py,sha256=ezHB4zts7GPgqyKIlVZU9D2gic7POmpySPpQQksIYvs,453 +torch/_export/db/examples/dynamic_shape_view.py,sha256=jpShUQ3RJGaD7QQgsch3a5Jvc49JVLh2c7KtYrcQaak,512 +torch/_export/db/examples/fn_with_kwargs.py,sha256=4SjNDxiAixSpfzaNHIdNXRZE6xxGm0ubFetueTiIpbI,871 +torch/_export/db/examples/list_contains.py,sha256=4QmpoD6i1ZW7GAKSq0Mb9Uz4LFnfhovdqDBGSpua1Co,548 +torch/_export/db/examples/list_unpack.py,sha256=vPgUP37q8zPydhKirZgVOhJultlXCC_wopAHXeBiL-8,666 +torch/_export/db/examples/model_attr_mutation.py,sha256=xKOCN4sCVR8x-1_7jK6eVp9tHAxSmikKuVgdMSNskUY,635 +torch/_export/db/examples/nested_function.py,sha256=Uuolq7B9iIlEsap4V7okhUpgIsTSkhstkibacxcYWhY,559 +torch/_export/db/examples/null_context_manager.py,sha256=GmJViF9_r5NhG41zkPcTxQV7Hrbqe0MCVJoTEzr7HGY,544 +torch/_export/db/examples/optional_input.py,sha256=dYgt1m-DZ0_ndtxK5BjPBwYG8N8i-N5bkNrc0wmU66g,442 +torch/_export/db/examples/pytree_flatten.py,sha256=SD3FMHN4939QQSJLswNHug_GRa4en9UGlLUQIwYXiEY,497 +torch/_export/db/examples/scalar_output.py,sha256=sYBwkNJ9A8xLL-z7aMUiqzT-QV0m-mqvmPN76ir_dIc,556 +torch/_export/db/examples/specialized_attribute.py,sha256=D72fSMVcPZsP-whJqrID2u9Xn_2H2zGqyxUaQM7IwtM,522 +torch/_export/db/examples/static_for_loop.py,sha256=78vr9XMv1tgeQUBSnzMNJgXmVAZ6KHKkedyT6gZ03Zg,483 +torch/_export/db/examples/static_if.py,sha256=JS3n7DtzH32ed6NNfjwznPfHKxgMLCMhRQYRr8ICHlM,473 +torch/_export/db/examples/tensor_setattr.py,sha256=vDUwjDWRW5r-iHKmquJ1j1BInLovEWWqgf3E3Gp8MhA,412 +torch/_export/db/examples/torch_sym_min.py,sha256=H6CEzi8uqycH_i_EOkNhvaIAQ2NjLT2YUoThwZma69g,400 +torch/_export/db/examples/type_reflection_method.py,sha256=lOUJ9YQ367ZKYDVWLaX0IOWPG9akYH_YdwF9fuejlQQ,875 +torch/_export/db/examples/user_input_mutation.py,sha256=ayBZwdacLxkifjnVg6yu-kbXMCVRfHZJR_ZVlpeAfbw,371 +torch/_export/db/gen_example.py,sha256=5j-ObT4SYqZ_HwJJwcs1hlq2zaAw97pqUFrJPtIDntQ,582 +torch/_export/db/logging.py,sha256=0p6qpGqgBkyh1a0JFYmvwWy-qolfHUg5bZgdb42kfdk,58 +torch/_export/error.py,sha256=CbVpyPi3enGAfXPh5R0pGnY4T0B8OvQJJQrzZW9qSXU,1776 +torch/_export/exported_program.py,sha256=G_Ih-L1Hi-2fIB6XFWP7RfKdpElFBp4vTdK-E_S0ZZM,1430 +torch/_export/non_strict_utils.py,sha256=dUuSu8UENIeaif4_tpvNRYGjj0-k_v5o4kpVbWSYP4g,10212 +torch/_export/pass_base.py,sha256=VG1mHbWJJ-E-cjrjRbhBZiKW-jUKXfo0VIb90QUXbXE,17128 +torch/_export/pass_infra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_export/pass_infra/__pycache__/__init__.cpython-310.pyc,, +torch/_export/pass_infra/__pycache__/node_metadata.cpython-310.pyc,, +torch/_export/pass_infra/__pycache__/proxy_value.cpython-310.pyc,, +torch/_export/pass_infra/node_metadata.py,sha256=r0lYig_aW6VXdmVm9q4oGJywPgwt6fHuZJNfb3mCAtI,782 +torch/_export/pass_infra/proxy_value.py,sha256=-ffaCq89LS4PPdXnGhz6DA81DO-j72XTrTDoRwqlKqQ,1140 +torch/_export/passes/__init__.py,sha256=78MzFjtaVabk1z2X12WMIlmtkjYaFmgNJlDCTCepNt8,88 +torch/_export/passes/__pycache__/__init__.cpython-310.pyc,, +torch/_export/passes/__pycache__/add_runtime_assertions_for_constraints_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/collect_tracepoints_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/functionalize_side_effectful_ops_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/lift_constants_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/remove_runtime_assertions.cpython-310.pyc,, +torch/_export/passes/__pycache__/replace_set_grad_with_hop_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/replace_sym_size_ops_pass.cpython-310.pyc,, +torch/_export/passes/__pycache__/replace_view_ops_with_view_copy_ops_pass.cpython-310.pyc,, +torch/_export/passes/add_runtime_assertions_for_constraints_pass.py,sha256=AG06aUVi1Lt_3FDybmepfVWTcnAiHf9zKKCAPQsBEHQ,9760 +torch/_export/passes/collect_tracepoints_pass.py,sha256=41xJTUgRR2G4bz_RkPx8aD1wS_Y5I6bmD5cAkK5f_3A,2724 +torch/_export/passes/functionalize_side_effectful_ops_pass.py,sha256=GnA_6u6UTHFjhv0J3hGrQiJhR2iSwQDyJb0s5QKVHjc,3272 +torch/_export/passes/lift_constants_pass.py,sha256=QyDVInHv8wnATbtbbDUxIDukZYNbjTdRC4h_sUehvTM,10555 +torch/_export/passes/remove_runtime_assertions.py,sha256=RCDa_sKeyJyq35jVCBx_9r7KRGxXTI5Bb_3EBzQ_vuM,1040 +torch/_export/passes/replace_set_grad_with_hop_pass.py,sha256=xk-zBM8geBoOpDqKc6zHxKCB1KgahGzgITviBcquYQc,5204 +torch/_export/passes/replace_sym_size_ops_pass.py,sha256=GKBeMjlU_mcypH0XMlW1ozrnuRJ9WEuKJAYMI_Y4MIw,610 +torch/_export/passes/replace_view_ops_with_view_copy_ops_pass.py,sha256=US0fXUHUsPgu21Wk1onsQnMFsdbwACfOTi-7azUcDPI,2688 +torch/_export/serde/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_export/serde/__pycache__/__init__.cpython-310.pyc,, +torch/_export/serde/__pycache__/schema.cpython-310.pyc,, +torch/_export/serde/__pycache__/schema_check.cpython-310.pyc,, +torch/_export/serde/__pycache__/serialize.cpython-310.pyc,, +torch/_export/serde/__pycache__/union.cpython-310.pyc,, +torch/_export/serde/__pycache__/upgrade.cpython-310.pyc,, +torch/_export/serde/schema.py,sha256=EGwhj5lnIDQfKos69Yr8zAoaOJYOCbvlx_qD6FLPm6g,7830 +torch/_export/serde/schema.yaml,sha256=X75ni4CdCTEWVn0Y-T_o7kkBy_rpfSEdxJ3MtBPkvro,6754 +torch/_export/serde/schema_check.py,sha256=OFwdGAALiIFlz8kSduM-VS2M3Dps0Fzl-1pyWW3Vyhw,10247 +torch/_export/serde/serialize.py,sha256=Wx-Bz_cH7QAC-XsrufL0msp_qY2aEn9ryFQ1lgmHJMY,100527 +torch/_export/serde/union.py,sha256=hREneXIZHok-yrmnoxxzRonICxK1s-HlOlwJ9vUYHHQ,1987 +torch/_export/serde/upgrade.py,sha256=CO9sQvExv8wIJ7JHqTaS3-svfkveFd8rwXujNgVRC_g,10020 +torch/_export/utils.py,sha256=CFjmwf2ngvEHXiIkj8xiuFR3CznaGtAHYtXoGxJSnOs,15288 +torch/_export/verifier.py,sha256=g7LRzXtBqMU-j0cIN0gmg-vCuT55sLjwWe8qOIwrSmk,16760 +torch/_export/wrappers.py,sha256=pusrIJ_kUWHAHZ2Zaw1kmLRLSMhjE5bhk4awL5iGMUc,4039 +torch/_functorch/__init__.py,sha256=a3XxW1RcNAPwEVaI2g11hpnJvSHxGUFsGmDAWfDnLP8,206 +torch/_functorch/__pycache__/__init__.cpython-310.pyc,, +torch/_functorch/__pycache__/aot_autograd.cpython-310.pyc,, +torch/_functorch/__pycache__/apis.cpython-310.pyc,, +torch/_functorch/__pycache__/autograd_function.cpython-310.pyc,, +torch/_functorch/__pycache__/batch_norm_replacement.cpython-310.pyc,, +torch/_functorch/__pycache__/benchmark_utils.cpython-310.pyc,, +torch/_functorch/__pycache__/compile_utils.cpython-310.pyc,, +torch/_functorch/__pycache__/compilers.cpython-310.pyc,, +torch/_functorch/__pycache__/config.cpython-310.pyc,, +torch/_functorch/__pycache__/deprecated.cpython-310.pyc,, +torch/_functorch/__pycache__/eager_transforms.cpython-310.pyc,, +torch/_functorch/__pycache__/functional_call.cpython-310.pyc,, +torch/_functorch/__pycache__/fx_minifier.cpython-310.pyc,, +torch/_functorch/__pycache__/make_functional.cpython-310.pyc,, +torch/_functorch/__pycache__/partitioners.cpython-310.pyc,, +torch/_functorch/__pycache__/pyfunctorch.cpython-310.pyc,, +torch/_functorch/__pycache__/python_key.cpython-310.pyc,, +torch/_functorch/__pycache__/pytree_hacks.cpython-310.pyc,, +torch/_functorch/__pycache__/top_operators_github_usage.cpython-310.pyc,, +torch/_functorch/__pycache__/utils.cpython-310.pyc,, +torch/_functorch/__pycache__/vmap.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__init__.py,sha256=a3XxW1RcNAPwEVaI2g11hpnJvSHxGUFsGmDAWfDnLP8,206 +torch/_functorch/_aot_autograd/__pycache__/__init__.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/collect_metadata_analysis.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/dispatch_and_compile_graph.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/functional_utils.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/input_output_analysis.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/jit_compile_runtime_wrappers.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/logging_utils.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/runtime_wrappers.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/schemas.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/subclass_utils.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/traced_function_transforms.cpython-310.pyc,, +torch/_functorch/_aot_autograd/__pycache__/utils.cpython-310.pyc,, +torch/_functorch/_aot_autograd/collect_metadata_analysis.py,sha256=_vIInFqDQOUI5h-FJz3YB_K4j4NvzKA64Ymgub6KaLg,33793 +torch/_functorch/_aot_autograd/dispatch_and_compile_graph.py,sha256=Cr5apb5MlyIJ7n2iquYmk8SWmv8tYwmBMEbmY-u24e0,6922 +torch/_functorch/_aot_autograd/functional_utils.py,sha256=TuDtjBRR8YNcIoNC_7AFJcs55BIQiXzLxxwpPxqfKzI,16692 +torch/_functorch/_aot_autograd/input_output_analysis.py,sha256=I4qJndchsXI3STbQEvUcHs4sMAskY_AHbF5GSijOz1M,17804 +torch/_functorch/_aot_autograd/jit_compile_runtime_wrappers.py,sha256=-JDhpwwojb0FZ4l2wqIjpi7cv4O06fWfhiIMVnZlw8Y,43903 +torch/_functorch/_aot_autograd/logging_utils.py,sha256=Tvt0iPTDa8y3Azat-l0fCVgg83ZSibeZuqkBlShbTAI,4183 +torch/_functorch/_aot_autograd/runtime_wrappers.py,sha256=lPvcXvANWtQGG3x0Rwdgh1aHoIQ1d45zj5FxozcWPYA,44896 +torch/_functorch/_aot_autograd/schemas.py,sha256=qj8uoHqD1OPdqvPXUKDSl9vsqBVEJngwvDT8sGuVWco,29675 +torch/_functorch/_aot_autograd/subclass_utils.py,sha256=T8KMMjAZHJ8kmM3oJGJrygD19e9GDeXN1rNx5KwtgUo,13896 +torch/_functorch/_aot_autograd/traced_function_transforms.py,sha256=Fr4Rxl33jgO2C4MsUedKf0BJkLIjPM0J32wZnM6AuVc,32469 +torch/_functorch/_aot_autograd/utils.py,sha256=RVdTjw9I4ggvw2gpfjAJ0nOI6WdHv7-PgcqLpY4Peeo,8151 +torch/_functorch/aot_autograd.py,sha256=i1AZxSaBPnJpIFzMMXWoW6EpfXqD2imqxLU-NcOypBY,54757 +torch/_functorch/apis.py,sha256=rEhcttJ8egyMoEpNoBq7N_XXvHPZmC0JQiTZRzZ7GSo,18598 +torch/_functorch/autograd_function.py,sha256=lfs3s6-Xn6KCnPncJtP0xGGZP5gdrL2bCoIdvCilI4c,25873 +torch/_functorch/batch_norm_replacement.py,sha256=DJ8dkUf2WE-9SRh2vl59hrTiAcEWcEC7k50tPpLBWVo,825 +torch/_functorch/benchmark_utils.py,sha256=D6T1ra-jVhT0ZS4y053QdHeDVtBPGLTnYCL2dA62pjU,6107 +torch/_functorch/compile_utils.py,sha256=sFkwLjzlrKjJm52nav_koOEIaSs3rn4-EX__VLqAUBc,3919 +torch/_functorch/compilers.py,sha256=wqVLd9hTA2_IIwO72TvPa-Rl__jQdgV7_jnulw1XdYs,13970 +torch/_functorch/config.py,sha256=nOFwZi98i1-UvP9alQ-tqca2GA68Ap5a8KBb-l_953I,1606 +torch/_functorch/deprecated.py,sha256=37yHN1-u6o6uh7eFm1GZTrGaeTymx0UqbgSascTrJ-A,5093 +torch/_functorch/eager_transforms.py,sha256=YASVt9Rd8jUw4bg4R-pvPhQhk1qvV1NBWeE1DTU2yKk,69657 +torch/_functorch/functional_call.py,sha256=CneOm8rKSEbA8-hZOZR4plTJ9FD2WnvjWwAVBRN7IFs,10376 +torch/_functorch/fx_minifier.py,sha256=0PDvM8q_Y9NBls6mdHUrhvmeSWn0edWRQZos9v8CJ0E,16668 +torch/_functorch/make_functional.py,sha256=t1F3sIa-MJMY0CTTIn5SzVIafcSbEleGPyPMHRtx1E0,22759 +torch/_functorch/partitioners.py,sha256=M5d1pyLVbgfiZzmqhAvwlgPu8MHOu5cb0mcnsnn4z3U,41905 +torch/_functorch/pyfunctorch.py,sha256=RMRlInm860eykbMnd6rXd0IHd55lOG-RBnc80Q6iBVo,9337 +torch/_functorch/python_key.py,sha256=H9lpa27GA8NR6bAgXKh7Ze2-QCvrkGCzlMRmLN5vRWo,420 +torch/_functorch/pytree_hacks.py,sha256=7lF2bnIXIbnYAqMcgPotUxtNqdkcjudmZL6UTu7Rlq4,672 +torch/_functorch/top_operators_github_usage.py,sha256=ij_Gk5IP5OzwN9zeB7NjlHS9cj6YShBTQ1WwoZkEyb0,21384 +torch/_functorch/utils.py,sha256=IUmtwspC_5637TtJHKORvB0sU4u-4Khkby4zR2S8abA,1384 +torch/_functorch/vmap.py,sha256=izlR5PpSGM5UraCHuvONj4nhuuY-kAjjqpWlfLLdWQw,18290 +torch/_guards.py,sha256=xtYGUsK4JputEHbftJsBxMRO2_J3peBg57FPsGjMcRM,28844 +torch/_higher_order_ops/__init__.py,sha256=mkfYT6ua4AboglDivmN5oKFpeKc-nIeAIj1R10KpjNg,23 +torch/_higher_order_ops/__pycache__/__init__.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/auto_functionalize.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/cond.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/effects.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/map.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/out_dtype.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/strict_mode.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/torchbind.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/triton_kernel_wrap.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/utils.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/while_loop.cpython-310.pyc,, +torch/_higher_order_ops/__pycache__/wrap.cpython-310.pyc,, +torch/_higher_order_ops/auto_functionalize.py,sha256=YKolohnLbZSSxIM4z6F45cb3BHpOEV1CRSFKhxLh-eM,9256 +torch/_higher_order_ops/cond.py,sha256=bYcIDrXAb1VDm59hQfJUHLSqJq6yeUvyB6oGNITrtLI,13308 +torch/_higher_order_ops/effects.py,sha256=Cpi9sWKWhVLAVHdgppuyrrpSJs42DjPhBuf3tJkAoaQ,6540 +torch/_higher_order_ops/map.py,sha256=LhFEWe3MzeLOWFo9zoD06coN_L-DZhNmaidK83LRkqc,13245 +torch/_higher_order_ops/out_dtype.py,sha256=i9CwpA6os31qIBJgLtKTRhNHfR_ErQ-9ZW1quRdV8Tc,5850 +torch/_higher_order_ops/strict_mode.py,sha256=HrBAHyafrzrbRNgwISOMYkHhfuRyrNwHgT0DmzqYM-c,3022 +torch/_higher_order_ops/torchbind.py,sha256=CEF4OBb4-byEJZU_9eJbZ7WNWSMbJO7doGA3yVwNDu4,3662 +torch/_higher_order_ops/triton_kernel_wrap.py,sha256=Jz62LqQ3nlBvxhKDktt8RrXyJm4JtuHxCCCoIZBo4_g,31335 +torch/_higher_order_ops/utils.py,sha256=QtsLFNW45jjIL6cTptyymLBo6ML1dFqw_ISZP5fE3r4,6752 +torch/_higher_order_ops/while_loop.py,sha256=PonzTbpCNVvNEq3Px31dlYvH83XYnZAgTMC_f7NlBPg,8779 +torch/_higher_order_ops/wrap.py,sha256=zjAO_Nx6WMCSqKkQLsMQl9pBeWYvDtOE9ctX4kkCUXc,8500 +torch/_inductor/__init__.py,sha256=mwzOqBVoZc_pCBjbfE6RsZJtagLrLXD8TfJLR0SIzis,4376 +torch/_inductor/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/__pycache__/autotune_process.cpython-310.pyc,, +torch/_inductor/__pycache__/bounds.cpython-310.pyc,, +torch/_inductor/__pycache__/codecache.cpython-310.pyc,, +torch/_inductor/__pycache__/comm_analysis.cpython-310.pyc,, +torch/_inductor/__pycache__/comms.cpython-310.pyc,, +torch/_inductor/__pycache__/compile_fx.cpython-310.pyc,, +torch/_inductor/__pycache__/config.cpython-310.pyc,, +torch/_inductor/__pycache__/constant_folding.cpython-310.pyc,, +torch/_inductor/__pycache__/coordinate_descent_tuner.cpython-310.pyc,, +torch/_inductor/__pycache__/cudagraph_trees.cpython-310.pyc,, +torch/_inductor/__pycache__/cudagraph_utils.cpython-310.pyc,, +torch/_inductor/__pycache__/debug.cpython-310.pyc,, +torch/_inductor/__pycache__/decomposition.cpython-310.pyc,, +torch/_inductor/__pycache__/dependencies.cpython-310.pyc,, +torch/_inductor/__pycache__/exc.cpython-310.pyc,, +torch/_inductor/__pycache__/freezing.cpython-310.pyc,, +torch/_inductor/__pycache__/fx_utils.cpython-310.pyc,, +torch/_inductor/__pycache__/graph.cpython-310.pyc,, +torch/_inductor/__pycache__/hooks.cpython-310.pyc,, +torch/_inductor/__pycache__/index_propagation.cpython-310.pyc,, +torch/_inductor/__pycache__/inductor_prims.cpython-310.pyc,, +torch/_inductor/__pycache__/ir.cpython-310.pyc,, +torch/_inductor/__pycache__/lowering.cpython-310.pyc,, +torch/_inductor/__pycache__/metrics.cpython-310.pyc,, +torch/_inductor/__pycache__/ops_handler.cpython-310.pyc,, +torch/_inductor/__pycache__/optimize_indexing.cpython-310.pyc,, +torch/_inductor/__pycache__/pattern_matcher.cpython-310.pyc,, +torch/_inductor/__pycache__/quantized_lowerings.cpython-310.pyc,, +torch/_inductor/__pycache__/scheduler.cpython-310.pyc,, +torch/_inductor/__pycache__/select_algorithm.cpython-310.pyc,, +torch/_inductor/__pycache__/sizevars.cpython-310.pyc,, +torch/_inductor/__pycache__/test_case.cpython-310.pyc,, +torch/_inductor/__pycache__/test_operators.cpython-310.pyc,, +torch/_inductor/__pycache__/triton_helpers.cpython-310.pyc,, +torch/_inductor/__pycache__/triton_heuristics.cpython-310.pyc,, +torch/_inductor/__pycache__/utils.cpython-310.pyc,, +torch/_inductor/__pycache__/virtualized.cpython-310.pyc,, +torch/_inductor/__pycache__/wrapper_benchmark.cpython-310.pyc,, +torch/_inductor/autotune_process.py,sha256=KXTYVd_TglbG0eIfqH01neTRDGFFVYosqP9n7hGSKTQ,21019 +torch/_inductor/bounds.py,sha256=hKdoLGGKQMkZSZVPKwpBDalRxiee7h1R9wdJnw8smFY,5304 +torch/_inductor/codecache.py,sha256=IMRkG7tOf2CKwZ4vqhPPpDBVeqf4h_6DtNmvZECCG8I,98440 +torch/_inductor/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_inductor/codegen/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/common.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/cpp.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/cpp_wrapper_cpu.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/cpp_wrapper_cuda.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/cuda_combined_scheduling.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/memory_planning.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/multi_kernel.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/triton.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/triton_foreach.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/triton_split_scan.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/triton_utils.cpython-310.pyc,, +torch/_inductor/codegen/__pycache__/wrapper.cpython-310.pyc,, +torch/_inductor/codegen/aoti_runtime/implementation.cpp,sha256=R0tMSxOAV_i2FiyTsL-BAetlwfFh0VSNu8HR_fGJPMA,3062 +torch/_inductor/codegen/aoti_runtime/interface.cpp,sha256=kgdAcedjoKkBx6CB6rXvrc4W2qrvH9JzgqLTXrXHL_Q,12901 +torch/_inductor/codegen/common.py,sha256=cEMfUBpn7zUnqSwi73HVu5ECKyAK1qXHeqDUxrVAZcE,59807 +torch/_inductor/codegen/cpp.py,sha256=KUrOPZq5_GQQcrquj3S2HoVaGdXxOMf9jYgF8P-bMbg,154098 +torch/_inductor/codegen/cpp_prefix.h,sha256=ciiV7Qc6EM9hFN8ORfsbVw8kSvjTxl3JYVLqoQKAloo,20397 +torch/_inductor/codegen/cpp_wrapper_cpu.py,sha256=t4wxvjkOkx0C91h7FxH2oWJ_GXmkl8WQe_cYPosdxLE,79502 +torch/_inductor/codegen/cpp_wrapper_cuda.py,sha256=MTGen-1gQkLlMNIkeLoosSEf3Na4wN9Dca9KJx7t8XA,11978 +torch/_inductor/codegen/cuda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_inductor/codegen/cuda/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cuda_cpp_scheduling.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cuda_env.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cuda_kernel.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cuda_template.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cutlass_epilogue_gen.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/cutlass_utils.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/device_op_overrides.cpython-310.pyc,, +torch/_inductor/codegen/cuda/__pycache__/gemm_template.cpython-310.pyc,, +torch/_inductor/codegen/cuda/cuda_cpp_scheduling.py,sha256=qN5hl2ucctjRRDNGQrObP0oHmzpS8_prG919xbY0ox8,8917 +torch/_inductor/codegen/cuda/cuda_env.py,sha256=OrUkPTXE6gRYerpl-a4irWsanN1eORemLPHKD5Abu48,1137 +torch/_inductor/codegen/cuda/cuda_kernel.py,sha256=vuM-OSuvvgjbYt4aKV93p0_AFeWGKYa32EuHPpjcVTQ,13031 +torch/_inductor/codegen/cuda/cuda_template.py,sha256=eJU2xhmP98ls9SBGFrpKVAtChxAcPHkdF82GBNUxvaw,8472 +torch/_inductor/codegen/cuda/cutlass_epilogue_gen.py,sha256=7SR4_s6Q4K3krCzl_F7PSWgKmX3xepdl47K25U7d2yY,14456 +torch/_inductor/codegen/cuda/cutlass_lib_extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_inductor/codegen/cuda/cutlass_lib_extensions/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/codegen/cuda/cutlass_lib_extensions/__pycache__/gemm_operation_extensions.cpython-310.pyc,, +torch/_inductor/codegen/cuda/cutlass_lib_extensions/gemm_operation_extensions.py,sha256=aSG0QSRresOAba7E5cXnlssbMweQOJOnr4TsigxC5L0,9774 +torch/_inductor/codegen/cuda/cutlass_utils.py,sha256=xQZf4UjFSSPTezWENgCtjzjM7xQZQ8I6Nu26Jg4CHSg,8351 +torch/_inductor/codegen/cuda/device_op_overrides.py,sha256=zzHzCJDIs4UcAaUyNtA5M7dAlw7gGIOnMsZDjWuDw-8,564 +torch/_inductor/codegen/cuda/gemm_template.py,sha256=oroo0YsJyTPSvROJ0cECCCPkf_jgKKo_E1_sMYequgU,27473 +torch/_inductor/codegen/cuda_combined_scheduling.py,sha256=v5BPLm8MvIYRK2Hu8uZXAMLKwEVyPtfMYtJInAdkySc,2938 +torch/_inductor/codegen/memory_planning.py,sha256=ANiaTX9oNWCLU_XFjW-cdjaZvuaSgysGWcBpbiLA9Dk,25725 +torch/_inductor/codegen/multi_kernel.py,sha256=Uk4IiX1zzzcGM-uwsOk9FxIS_g5M-WgQVPP2JmrJ2Ec,14319 +torch/_inductor/codegen/triton.py,sha256=-gaT1bxKxtwavTMMV0DBaTe6god6yygtFiWhXOnJzzc,148321 +torch/_inductor/codegen/triton_foreach.py,sha256=EGahdNOTOWPLwjiNIX_jCoYxMJjVI9aq-HPcwLjXPXE,9245 +torch/_inductor/codegen/triton_split_scan.py,sha256=uYc4BPFhyoUiFFT-5QTi-usm2WwZI369DbomyISE8Hs,6429 +torch/_inductor/codegen/triton_utils.py,sha256=W6QTfvrRVmSEzbej6bAD_BVlD7k_DFogdvkN-8cEOOs,4539 +torch/_inductor/codegen/wrapper.py,sha256=1VOzTm2gWUqxJUg9k85ZvtoAE3-r1IO-sSxkOxRNG_M,58279 +torch/_inductor/comm_analysis.py,sha256=8QI-Rf5Dv9KSHXeON0w2v7Bx_1zv20fJzgMJIJCrJqU,8820 +torch/_inductor/comms.py,sha256=046hxLoV6BWHRGZJDBs-H4AY_J5WAH6K372XF0bWu-U,14728 +torch/_inductor/compile_fx.py,sha256=lJY1U4q0kc9ourwNQ8-TqZD7zm63zK9PPVp_QwKQ6cw,51555 +torch/_inductor/config.py,sha256=ClmYNR1RrPXeMxIUf3dTYkIVBQgvStzNDbu5IK5-MJA,27468 +torch/_inductor/constant_folding.py,sha256=eZNEB5uxbt82vJ3_ikAmzSksUMNonw4BbJlgkHfA2x8,8807 +torch/_inductor/coordinate_descent_tuner.py,sha256=lpdx9nWKEzV0OTQt8e9YHX8r316EgXg2Gdu5SSfocPY,10311 +torch/_inductor/cudagraph_trees.py,sha256=yXYNsXsh_Ri7h7zEKsw8CI0bKOKxBg3UeF33cIlBs9c,84477 +torch/_inductor/cudagraph_utils.py,sha256=l92tn9701F9Pbjj9ZhoipteZMcgoc92eGJxwGgzoaps,3392 +torch/_inductor/debug.py,sha256=7HLZ7dd2lHjtBHNepQoXvATUAFxziM2PaOl9NlsdtOc,21476 +torch/_inductor/decomposition.py,sha256=kPKJIi37BlAG9j2rstUEtuKgui27ixu6vAvNT0FhK1I,21649 +torch/_inductor/dependencies.py,sha256=lr3vEQbcdvxJ2Hf0eWGSfa054GE71iAoryDz5QPJ4YM,17087 +torch/_inductor/exc.py,sha256=iPPdg0Ejm6yTPfHKRU1RKEZK6__VwpC9f-gSjCdPwZA,2703 +torch/_inductor/freezing.py,sha256=XMo3DHSOoBhWjmT2XeLucs71CqgWJ7A4EFvc6y1WM8I,9812 +torch/_inductor/fx_passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_inductor/fx_passes/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/binary_folding.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/decompose_mem_bound_mm.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/dedupe_symint_uses.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/efficient_conv_bn_eval.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/freezing_patterns.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/fuse_attention.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/group_batch_fusion.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/joint_graph.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/misc_patterns.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/mkldnn_fusion.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/numeric_utils.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/pad_mm.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/post_grad.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/pre_grad.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/quantization.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/reinplace.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/replace_random.cpython-310.pyc,, +torch/_inductor/fx_passes/__pycache__/split_cat.cpython-310.pyc,, +torch/_inductor/fx_passes/binary_folding.py,sha256=-loNlEfgcGEBCS9d6AaxDXVac0v5A-gd7cCSMC0B30I,10582 +torch/_inductor/fx_passes/decompose_mem_bound_mm.py,sha256=QrRGd9WD8b-pNRmfG9t6W5cNQbdLMMM9pY6MVq1G9Ls,6525 +torch/_inductor/fx_passes/dedupe_symint_uses.py,sha256=omC0uOslEdrSQ6z575my_jtJrUxDNTsS7jc53vxWJVA,2431 +torch/_inductor/fx_passes/efficient_conv_bn_eval.py,sha256=tk3p8rlba5aviPXNUUpHNerFdpvUZnYUpRB4i2C07y8,5765 +torch/_inductor/fx_passes/freezing_patterns.py,sha256=dhzWxhbNwsOT9hBrOlG_xzt7LonWIpKy_l4chk5Fx3w,6165 +torch/_inductor/fx_passes/fuse_attention.py,sha256=C_r-im66WtlutPAWhm4RG4CjvKXsKNjtzp4S3SmRURI,25331 +torch/_inductor/fx_passes/group_batch_fusion.py,sha256=OMvrcGyNkrzjE_HrQjve4V2Leb6SXSvws9H_Rk1xB88,39546 +torch/_inductor/fx_passes/joint_graph.py,sha256=SKppTP221Jvqd8BfVZNFQ_7hCQ11HGy4DmGcxfmrc1s,11725 +torch/_inductor/fx_passes/misc_patterns.py,sha256=eVzvQI7PvtY2ZXFIJG5FyTsZ3b9N8sQD0lRFGuUWgW8,4746 +torch/_inductor/fx_passes/mkldnn_fusion.py,sha256=DQqKs6Y-NlMBVuCp0iFoK30H1C-vkRYK0rgZkCkXlhY,46731 +torch/_inductor/fx_passes/numeric_utils.py,sha256=Un4TRR3708OX_2xXF9x1cPWNXjoP_7aOIdrKEZyFozU,7208 +torch/_inductor/fx_passes/pad_mm.py,sha256=AR9v9SFjVyJNCIR5oXH5LaQPSN96jZNl80Le9sfkt80,18238 +torch/_inductor/fx_passes/post_grad.py,sha256=V0oodziSpPMJpLte9ZQJVslIbF--a8eNs-J2LVZ8PjM,34581 +torch/_inductor/fx_passes/pre_grad.py,sha256=wJ4z3LHjpsKutfHy38Teg4EoNhyh4D8JCR1rRXR98lw,22359 +torch/_inductor/fx_passes/quantization.py,sha256=j0GNdY7UcLdlKlhZmp-8Nc0rSqmFcazmqKDyfHxFTmM,71687 +torch/_inductor/fx_passes/reinplace.py,sha256=3JVnwStZebqW-ky3TgmydP7P4Cwu-9RhHYa9fwW5yKU,19882 +torch/_inductor/fx_passes/replace_random.py,sha256=4dbObj1VCbIMV2GfeFsn_GSlpU9n8vO84JLQ8422mqs,3858 +torch/_inductor/fx_passes/serialized_patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_inductor/fx_passes/serialized_patterns/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_1.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_10.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_11.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_12.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_13.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_14.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_15.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_16.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_17.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_2.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_3.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_4.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_5.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_6.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_7.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_8.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/_sfdp_pattern_9.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/__pycache__/central_index.cpython-310.pyc,, +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_1.py,sha256=jv4lL0F5PeUk2DbWc3HrOpbI8_DUuXNGD67JwTtEc0k,11723 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_10.py,sha256=Fq3xhWjTsQIafCOuvKB5Q-uXXY3IMbPfxyWAhWT9pco,14775 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_11.py,sha256=MkIFW-FBBHRPU_xUGWkZ_rGIikKdMKAoH17KYzw7vIs,14533 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_12.py,sha256=FBOPstTS_psoAZ04rWXBGtsQazxAGMMMQ6HUE2MibII,16153 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_13.py,sha256=oeGoAhchBFs5i5VPK0Nn13tjAGn3np-_JnWTwUQybUQ,8745 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_14.py,sha256=CIEdiGA5Ui77YylvAfYvkGFNagqSqAYOildHck8Wo80,14869 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_15.py,sha256=2hJTEGIKuoauIEbOEQpTrdc8sQXoBc6fvvvOJ08EYxA,16599 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_16.py,sha256=Nu5FExtThfirddyYNWpkiMwNzD46DbnJSab-PDxcn38,46243 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_17.py,sha256=iBmR62AAjPQlNjPU3lLvTPocYJFWV0VWDJOvNi4FvCo,18177 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_2.py,sha256=FvHFZ6kkzp5zPIiwRHfPdoaE_4rjg-N4amkttHhThWk,11735 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_3.py,sha256=kAcnNfy364919cTNiIQs9GPMtYQo_0G6G_nY1kUQgB8,13327 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_4.py,sha256=YlCWNizBfAu_OUG66ZPLQIFuu3MhSC5Z92vvGiTTAn8,13293 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_5.py,sha256=h26eR3620rQqZzgB1heiXkOaWMQLHiPEbuKMRHFBlAQ,11959 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_6.py,sha256=6EGrTjpVfrrRSYlZGFz2BSGEqpyyyocUpmXYdROUKjA,13521 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_7.py,sha256=THEMcFxjYAPQynQThujWTtCTQg3A_qFgAoqHnF1N8JQ,16345 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_8.py,sha256=LUyH9tbY0uansSDd9gtzesPjiS7gpzugROxuj07QvFY,14763 +torch/_inductor/fx_passes/serialized_patterns/_sfdp_pattern_9.py,sha256=xdu_p7ckx-h3rw_MnEh2yw5MjqP8VSp7zmxAskKTROQ,16353 +torch/_inductor/fx_passes/serialized_patterns/central_index.py,sha256=0FMgoRj0S6fcO-HX3QY-gtBwhtVJcTqs58d3wdLylyA,8558 +torch/_inductor/fx_passes/split_cat.py,sha256=UhUlM2MqXwwdxCx6Z-1tyrbV64VzRW4VlC7XgFZOgMg,59781 +torch/_inductor/fx_utils.py,sha256=hubUQjG4moSRHrqCk26faYQyMyTa6CXexaaxz1UEWaE,7973 +torch/_inductor/graph.py,sha256=YBIeqgBBwfmRYvwwFsnYGesPbMxUxLbjmuWPZwXYwBA,54300 +torch/_inductor/hooks.py,sha256=ooVKPAkLHKLTKJBWG_tT8zW_VIsyotoHnMgzi3Y5KUc,617 +torch/_inductor/index_propagation.py,sha256=L5ksJE0M_ORy0HUYS0GL4v54jahQmUimYE8qA1AWrlg,9855 +torch/_inductor/inductor_prims.py,sha256=1qCWz8V7oEUSDxQPEaUb12fTPk6dhz21OCCtEiyyjjs,3135 +torch/_inductor/ir.py,sha256=mSHKgWC1FNfdGHMHcA9FHLxAgPdxv4k8WopMhLcjEhI,271555 +torch/_inductor/kernel/__init__.py,sha256=H6IReWIOt8twLwq3VA3cggOOQd5_EDJ7o48hU5K0RAM,57 +torch/_inductor/kernel/__pycache__/__init__.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/bmm.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/conv.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/mm.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/mm_common.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/mm_plus_mm.cpython-310.pyc,, +torch/_inductor/kernel/__pycache__/unpack_mixed_mm.cpython-310.pyc,, +torch/_inductor/kernel/bmm.py,sha256=HGAyBPxSRzjqX_cd_v16q91Tki5Pth7o1WcU4sAnD_g,4212 +torch/_inductor/kernel/conv.py,sha256=pGBXFZUFwUTyQ57n2RKiLljf72PIZ_jHEb5AXjwo3Nc,14625 +torch/_inductor/kernel/mm.py,sha256=AqsA-VKGcXSQeJnjCDLSg248mUA9RdXauUtb6Q6MjME,10356 +torch/_inductor/kernel/mm_common.py,sha256=hHoqu2dnkURHJqiXsSIC8zgIDOEXRqOLSTUvTvzsBFw,8649 +torch/_inductor/kernel/mm_plus_mm.py,sha256=KyxQUymrFg3DGzo5T6TnpjEurgQuhkRMtwM847oLxjM,7306 +torch/_inductor/kernel/unpack_mixed_mm.py,sha256=EywEr8kS47kpbD8aDXn9zfKS4t_R8eW3wDYYW8ToV-0,2880 +torch/_inductor/lowering.py,sha256=67o1YNmM8AzJZNBmMEvO4UVT_Ts4M-kbnIpY-395O6Q,194835 +torch/_inductor/metrics.py,sha256=M-L6zTa2Kwo0ex3DxsLoMFQeBikbIUASGihky5EFB0k,12838 +torch/_inductor/ops_handler.py,sha256=pnHhrasl20TYXpezBNMYhIyGfbAPPAxcMXiOtfFSctM,18903 +torch/_inductor/optimize_indexing.py,sha256=J6igyX_ScdiJH7dc4V6tk-HqTLDyI00OtqjcELP8fQI,3915 +torch/_inductor/pattern_matcher.py,sha256=oTEMJZOsJqkRkkxU2h7fvWhZJ7BYBbFgr7W8E2NGSKk,51865 +torch/_inductor/quantized_lowerings.py,sha256=Tk_zvxnP-u1G7lVRoCqJKL-Z7SqlaE3W346PMDPRu-E,260 +torch/_inductor/scheduler.py,sha256=MoBmQOARUWePavVd5vViUC4N0uycFyZU6LqQ47-NOho,92696 +torch/_inductor/select_algorithm.py,sha256=hoJG5BGhbLRZLbq4z2s8dTyUkXyzfoqUwsLaB1YMmHQ,39756 +torch/_inductor/sizevars.py,sha256=cZFKit53s_DJo04dK4K3m0wJt4nHhVd6OHE9jft8Y_U,25965 +torch/_inductor/test_case.py,sha256=dw6PPMveafWlQZmESijKPcpe7zUPyDgwegXuiCMpGwc,1494 +torch/_inductor/test_operators.py,sha256=IjNmySY0kOChvkw2wNUdeL9Jb1FeKOaG55gzWcBzFME,683 +torch/_inductor/triton_helpers.py,sha256=pV7--LhOvn03XrsNpHO8A09mu0PF_sSQo68lr5fUPKM,9859 +torch/_inductor/triton_heuristics.py,sha256=xCg50mBqa7HRDqXis8Yl-EtapFryJUoV9SPw4UfnXms,54980 +torch/_inductor/utils.py,sha256=h1cPhrl4Y6dpoojAh3GjUGNOenMwbARzX9qa-NUJGmg,43439 +torch/_inductor/virtualized.py,sha256=Ozvqbonks9F-8nILAc7ZGL2UhbNaLX3TYccB1O2wgus,11777 +torch/_inductor/wrapper_benchmark.py,sha256=a7WMgUKqzSq10FFA2Zo-ARLoJIpquWbmlsE7VoJzI7Q,10066 +torch/_jit_internal.py,sha256=jNFTY07JYAQYlnmZHmF89P91Xlz5FemclHI8fU_umXQ,53153 +torch/_lazy/__init__.py,sha256=uk4bZGomSx86buW23tDHja_YDiltka2O_0d4r_Y5czg,1783 +torch/_lazy/__pycache__/__init__.cpython-310.pyc,, +torch/_lazy/__pycache__/closure.cpython-310.pyc,, +torch/_lazy/__pycache__/computation.cpython-310.pyc,, +torch/_lazy/__pycache__/config.cpython-310.pyc,, +torch/_lazy/__pycache__/debug.cpython-310.pyc,, +torch/_lazy/__pycache__/device_context.cpython-310.pyc,, +torch/_lazy/__pycache__/extract_compiled_graph.cpython-310.pyc,, +torch/_lazy/__pycache__/ir_cache.cpython-310.pyc,, +torch/_lazy/__pycache__/metrics.cpython-310.pyc,, +torch/_lazy/__pycache__/tensor_factory_functions.cpython-310.pyc,, +torch/_lazy/__pycache__/ts_backend.cpython-310.pyc,, +torch/_lazy/closure.py,sha256=x1Iw3ZaCZsLxSujryyJUC6ukWN3YGS17y0VQ0tJpnxQ,5417 +torch/_lazy/computation.py,sha256=laFgh2GfhgilLlUyrgGKNsr8aRfazlRnvPgftR7FB-M,892 +torch/_lazy/config.py,sha256=-IGAjlKzrMyhYMrDPYM8gPtXw1TD9wIBaDi5eXpqWdk,420 +torch/_lazy/debug.py,sha256=TbMsvBvhmQnA6lXkxH_o28gowh6y6SaueN0IIcToBik,711 +torch/_lazy/device_context.py,sha256=8xrnkY0TEHJhmYcWAe_D3PSXpEWqxhtlCim2JnV18Qc,634 +torch/_lazy/extract_compiled_graph.py,sha256=oxP2tewUmtzdR2O0mjdNKDGjl6KginjZSnYhY_5ObYk,8407 +torch/_lazy/ir_cache.py,sha256=Nrg1FSUfERhjLSh8JVfKRLxV4LqE-gnJbTCHZiNlnr0,321 +torch/_lazy/metrics.py,sha256=86HmoSDv-S_tiJB1fNYrGVhRF0hH9CDIfyR1i8p-BwE,518 +torch/_lazy/tensor_factory_functions.py,sha256=wHMqBuDC4QG-jntdqJzJaQ1WGyc1gBpMpGbK5oHOkh4,1367 +torch/_lazy/ts_backend.py,sha256=q9_bt2_isGm0LwMx7KLd0i5qj-28e5O8ghV48Ka9TcU,136 +torch/_library/__init__.py,sha256=lJY-8KHDPGj2k2R75rtC6A09haAnvVpQl6ZV_ejKPAA,102 +torch/_library/__pycache__/__init__.cpython-310.pyc,, +torch/_library/__pycache__/abstract_impl.cpython-310.pyc,, +torch/_library/__pycache__/simple_registry.cpython-310.pyc,, +torch/_library/__pycache__/utils.cpython-310.pyc,, +torch/_library/abstract_impl.py,sha256=ZQQbpezphiHQWJvlDnC6FZDog6KQXzHKEVqo6CjB11g,7852 +torch/_library/simple_registry.py,sha256=_vAPir_gU4mrvdxP4-aq7jCAK5sumw2w8PzlNE9vO88,1394 +torch/_library/utils.py,sha256=K_wxaO4A4V5nLruesKNLtD1n_JePlK9t3jYe3nI51-g,4704 +torch/_linalg_utils.py,sha256=Bb6feV4AlnxXdEjR5Goq6F3-8k4YBLs0rds_sjS7rfQ,5584 +torch/_lobpcg.py,sha256=tJNQbAGYY-PTa_bPe6YfLu0Augr2IHEFTU0VU6Mts6U,43742 +torch/_logging/__init__.py,sha256=jOLp0GYA7l-UKRQUNuDH7l2z_O80lf-9oUK3AXNj5HA,738 +torch/_logging/__pycache__/__init__.cpython-310.pyc,, +torch/_logging/__pycache__/_internal.cpython-310.pyc,, +torch/_logging/__pycache__/_registrations.cpython-310.pyc,, +torch/_logging/__pycache__/structured.cpython-310.pyc,, +torch/_logging/_internal.py,sha256=WNBgHN7o7XuAtW3DClEb8VVbsz-wxGkdI9fELihhHx8,38642 +torch/_logging/_registrations.py,sha256=wveeiHyYDB_fg7RcOuoeOf61zv4tmV4Aui_mP6kiOLA,4838 +torch/_logging/structured.py,sha256=VndrbHzHPdLk6UQNabSY64z8HqkGD0bSATFwFNXhV48,873 +torch/_lowrank.py,sha256=zZnCdDgx0QSmb-NozGXNgZ2Jsr4Bhf3OthXsnaONokw,10896 +torch/_meta_registrations.py,sha256=_K5C38cv3ogcvBL5J1tV9fzTmr1eirEIRLaJfYulO3s,192621 +torch/_namedtensor_internals.py,sha256=nXh_9wpKz9XuqXhHMMOkJ1qPpxwHovdmo-lNx0s1nj8,5262 +torch/_numpy/__init__.py,sha256=SnDBM3mHZrOJfrbK39ahT0S1Lh65v6BU9j96GQlqGEM,557 +torch/_numpy/__pycache__/__init__.cpython-310.pyc,, +torch/_numpy/__pycache__/_binary_ufuncs_impl.cpython-310.pyc,, +torch/_numpy/__pycache__/_casting_dicts.cpython-310.pyc,, +torch/_numpy/__pycache__/_dtypes.cpython-310.pyc,, +torch/_numpy/__pycache__/_dtypes_impl.cpython-310.pyc,, +torch/_numpy/__pycache__/_funcs.cpython-310.pyc,, +torch/_numpy/__pycache__/_funcs_impl.cpython-310.pyc,, +torch/_numpy/__pycache__/_getlimits.cpython-310.pyc,, +torch/_numpy/__pycache__/_ndarray.cpython-310.pyc,, +torch/_numpy/__pycache__/_normalizations.cpython-310.pyc,, +torch/_numpy/__pycache__/_reductions_impl.cpython-310.pyc,, +torch/_numpy/__pycache__/_ufuncs.cpython-310.pyc,, +torch/_numpy/__pycache__/_unary_ufuncs_impl.cpython-310.pyc,, +torch/_numpy/__pycache__/_util.cpython-310.pyc,, +torch/_numpy/__pycache__/fft.cpython-310.pyc,, +torch/_numpy/__pycache__/linalg.cpython-310.pyc,, +torch/_numpy/__pycache__/random.cpython-310.pyc,, +torch/_numpy/_binary_ufuncs_impl.py,sha256=2ARnfWfW0QTkfv3gXU_YjD6qCiJs6-UaFKAoOFJLeHI,2418 +torch/_numpy/_casting_dicts.py,sha256=Qde3AoGpEzMJFMRuZFrgljDoDaNSWOiSnoLmmuLfcUA,26853 +torch/_numpy/_dtypes.py,sha256=dKbfhJEDSzXqomnnfVXngY5ZomefNv6TTHzd5RzcR7c,9972 +torch/_numpy/_dtypes_impl.py,sha256=ub1dc3recbKXxkq5X7T-97zurCouuanzRc0Qy40tY0s,5906 +torch/_numpy/_funcs.py,sha256=i-TO7VrfmbP21G5Hm2DLm10r3KyGDUeDoGfjsOHUzi0,2096 +torch/_numpy/_funcs_impl.py,sha256=r2wq_btEGFkoIhWZGiRsX8TG_gPM8Dopufuz8M2tcCw,59136 +torch/_numpy/_getlimits.py,sha256=QRUbPnrehERJA9Wk01SdUaF1F2FhksfgpewYN6SmtgE,269 +torch/_numpy/_ndarray.py,sha256=zEL3tl3vRsNHExbQtnBMlGZmgxpHJ7ImSCIC-InBHz0,16635 +torch/_numpy/_normalizations.py,sha256=vRwnHadqLb9aRay6NBxstPeTUL6ciqi4rbNK-FzUjdg,8250 +torch/_numpy/_reductions_impl.py,sha256=H_fPnn6Pdiy5g8jiBu_oxe55uQdssMry_sa2NGQIpzg,11733 +torch/_numpy/_ufuncs.py,sha256=CJoWG7TWKRZ2tM7JV3qsZXpAYlB2iRzfogs7721xGl0,8366 +torch/_numpy/_unary_ufuncs_impl.py,sha256=cd5mngyMI7ltNESj9nCYJBRyslyg_Hb6ELCNIlhW6gQ,1750 +torch/_numpy/_util.py,sha256=8HCyDKXhZKMewGqGnj0jrkESxdZat-jE7hPBozuYTSQ,7549 +torch/_numpy/fft.py,sha256=lqeN-889bRRT8VjzgAaXoK9aAz8wdQdoiUSVN-oIhRQ,2805 +torch/_numpy/linalg.py,sha256=SXETOx6igv1pG5mDR4EM6fykabq4Vt9lpRpQwmJSlW4,5584 +torch/_numpy/random.py,sha256=yWr3GUftkX9_FZ10phn_V5SWy1gbzpZpnSqVQgqlhwo,4650 +torch/_numpy/testing/__init__.py,sha256=MvxIGX8BvdId3cKxdiTqEd6uWu5nc-fhKXUTJgtiXjU,374 +torch/_numpy/testing/__pycache__/__init__.cpython-310.pyc,, +torch/_numpy/testing/__pycache__/utils.cpython-310.pyc,, +torch/_numpy/testing/utils.py,sha256=dNDqpWskb6Ye5FO6rNvq4h90-19fDcvX9ILQ4qmQAsM,76352 +torch/_ops.py,sha256=ZzF-fp7K8cQwwb5fvEpU_5owSYGl5k28Kgngoj-CNPs,42188 +torch/_prims/__init__.py,sha256=0OxjWd6iE1zRax7D4vhZayJDGqeC1bfiu4Dt6rNkLpk,83418 +torch/_prims/__pycache__/__init__.cpython-310.pyc,, +torch/_prims/__pycache__/context.cpython-310.pyc,, +torch/_prims/__pycache__/debug_prims.cpython-310.pyc,, +torch/_prims/__pycache__/executor.cpython-310.pyc,, +torch/_prims/__pycache__/rng_prims.cpython-310.pyc,, +torch/_prims/context.py,sha256=xWZb2445zAMfbIDF3mlHASnYnrFo5vD7MbPlSda7UWU,5459 +torch/_prims/debug_prims.py,sha256=vVhtD0a2EPOv_iOBhEc9xrpwnu6bXyja9jeegQKb5VU,1992 +torch/_prims/executor.py,sha256=FEaP11kQBEpc9ztfHMPqRA_RWXzVwLTwxMXWTFgOLjM,1637 +torch/_prims/rng_prims.py,sha256=oLyd9V5Jh4g7JopQdPuw2tGLvvQ7ZwdHm_kkHecQ2fg,9760 +torch/_prims_common/__init__.py,sha256=TvfTkT5tEAUJNEUWgLON7NyM10dUZ06bF-fqi4TrYhw,64779 +torch/_prims_common/__pycache__/__init__.cpython-310.pyc,, +torch/_prims_common/__pycache__/wrappers.cpython-310.pyc,, +torch/_prims_common/wrappers.py,sha256=wK98H5rLqM9gtAYH0y6xtqpKxdiRFihhOiS5fKt4Yoo,15251 +torch/_python_dispatcher.py,sha256=I6xmFG2xqLKsbGlTCi0xG2YOfimXRV3ZgBQrDA6Wv9w,7100 +torch/_refs/__init__.py,sha256=0UYgj_UVnDBPqjc3Fu4QllZ_yiUuQWkpyEwl-zTdCW8,205969 +torch/_refs/__pycache__/__init__.cpython-310.pyc,, +torch/_refs/__pycache__/_conversions.cpython-310.pyc,, +torch/_refs/__pycache__/fft.cpython-310.pyc,, +torch/_refs/_conversions.py,sha256=ctcO4gAxqCsrQBCnoFW6XLKKjhXUn_jJ3BGyKnYIpJ4,3506 +torch/_refs/fft.py,sha256=VEF1PU4Ckt6J4inqB9Eqh9RI0rff55XfiskfRuaoYPA,17953 +torch/_refs/linalg/__init__.py,sha256=ZIlS7ZVh7pmqEZMe2KY0v65GFQSH_re74iorEf9JoPY,10355 +torch/_refs/linalg/__pycache__/__init__.cpython-310.pyc,, +torch/_refs/nn/__init__.py,sha256=TxVn7Qjs3VBg36A_3dasco_AQPZtK4HebdViKMirE8U,49 +torch/_refs/nn/__pycache__/__init__.cpython-310.pyc,, +torch/_refs/nn/functional/__init__.py,sha256=X6t_6u6dYadVqxO6W8gN1o9HtyGdQ1cD-dRsLaNywsg,40737 +torch/_refs/nn/functional/__pycache__/__init__.cpython-310.pyc,, +torch/_refs/special/__init__.py,sha256=7XuQ5v7CjsbLVojE-mA8JMHjzhsBpmuUaecjZk-2fvc,6757 +torch/_refs/special/__pycache__/__init__.cpython-310.pyc,, +torch/_sources.py,sha256=U9_HOKzQEQKKMCzrmJGNhaKZnZqkdr-RSQfVruKf9hc,4427 +torch/_storage_docs.py,sha256=jKGkTbLwKBnvNerLtg-mQ2CN71nKMp9C9EQ6hV1Gp7o,1357 +torch/_streambase.py,sha256=Y3UJ6dftcI_RhX1_33KR4nA-0P0LiFwSNrl1AQqwKMA,1027 +torch/_subclasses/__init__.py,sha256=5F35O3CJ9XnkaHcD8NWjnNVGGw5WabjXSUy-UdlpXOE,376 +torch/_subclasses/__pycache__/__init__.cpython-310.pyc,, +torch/_subclasses/__pycache__/fake_impls.cpython-310.pyc,, +torch/_subclasses/__pycache__/fake_tensor.cpython-310.pyc,, +torch/_subclasses/__pycache__/fake_utils.cpython-310.pyc,, +torch/_subclasses/__pycache__/functional_tensor.cpython-310.pyc,, +torch/_subclasses/__pycache__/meta_utils.cpython-310.pyc,, +torch/_subclasses/__pycache__/schema_check_mode.cpython-310.pyc,, +torch/_subclasses/fake_impls.py,sha256=TNoKmDXPUKHDWq0i9CfzXBoPxPqP5Ew9srHZzQTXnZ4,35514 +torch/_subclasses/fake_tensor.py,sha256=imJqv7DFiPDXsyu7hvzIc11weRJARQy8taJiMsUXKqc,70483 +torch/_subclasses/fake_utils.py,sha256=KzlzeSxI1Do0iAI6cl3_dtZHDZ7lIQlJV8uiI3MLuzc,7201 +torch/_subclasses/functional_tensor.py,sha256=yqzwbkADZrf_TD4jdvjjwOGnVyQ4bHd7w7Bow4ZvTL0,29114 +torch/_subclasses/meta_utils.py,sha256=QgEPMt_tjgSF4G_myljFtsVlmQpthZZFkO60_r4Xpto,46960 +torch/_subclasses/schema_check_mode.py,sha256=GgcU5Vub-RsQbj5Gc7VYo4Yn8fJF1mz-wgbyoTaQnaY,7890 +torch/_tensor.py,sha256=X5YB0GndT1KAyZ7eqdPCcLJJlCBh4qBhCC9owLKCCG8,61393 +torch/_tensor_docs.py,sha256=z1pFgv8M9W5Cb5ahv6NkioaTIDY8Q6-fG1GV17hhnDk,142291 +torch/_tensor_str.py,sha256=tPX5GbHufd_cBYNKdF6_4bmTUzu5LaV07MhHc3c-hPk,26787 +torch/_torch_docs.py,sha256=eF1fRp3srbWSgNPCXNvqv4Xj0F7Kr5WBf5nq5KbwBMg,415880 +torch/_utils.py,sha256=yqsc_tL5B5dK4xbgds_y_6g8YZ65igoYXN4ZVT476R4,34792 +torch/_utils_internal.py,sha256=bEEJ2z5ewZYtTAzvsMdlzQKcdTluH8OUTFXc5T2pi5U,4709 +torch/_vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/_vendor/__pycache__/__init__.cpython-310.pyc,, +torch/_vendor/packaging/__init__.py,sha256=EhCMuCSz60IgQJ93b_4wJyAoHpU9J-uddG4QaMT0Pu4,496 +torch/_vendor/packaging/__pycache__/__init__.cpython-310.pyc,, +torch/_vendor/packaging/__pycache__/_structures.cpython-310.pyc,, +torch/_vendor/packaging/__pycache__/version.cpython-310.pyc,, +torch/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431 +torch/_vendor/packaging/version.py,sha256=XjRBLNK17UMDgLeP8UHnqwiY3TdSi03xFQURtec211A,16236 +torch/_vmap_internals.py,sha256=lpd8jyO1Pwa_YV6zeZJpyfTKBBzvycKQ7KGpxzdHAg8,9389 +torch/_weights_only_unpickler.py,sha256=L6uVzk2GXjFH_U9LDdM-eP7n6Q005WkTbA9aHWTHsWY,11202 +torch/amp/__init__.py,sha256=NeyK4Cguk7lzRm0tKElOlKOIkafpXEOqR_ZDNxjDUo0,105 +torch/amp/__pycache__/__init__.cpython-310.pyc,, +torch/amp/__pycache__/autocast_mode.cpython-310.pyc,, +torch/amp/__pycache__/grad_scaler.cpython-310.pyc,, +torch/amp/autocast_mode.py,sha256=aeSnJaRHaLVGhIRIBc5TLrizEMsO3yEE_oMhL8jSRNs,21085 +torch/amp/grad_scaler.py,sha256=gDywt_U-w4UAQNP2i_Ttx3ehbefH_UfcXXhWjMiXQco,30136 +torch/ao/__init__.py,sha256=INOQ09eBUwDXyrxNdFfTvgzdfo3863Tmn08Cu3IkdnU,398 +torch/ao/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/__init__.py,sha256=3sqxlA4O5j1F-qm4NubHku39ZHqO1nYUprp_nRbOgKw,499 +torch/ao/nn/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/__init__.py,sha256=08XXgRazQXLNtUUn9kUgBpebemIBZJqwaJ9WKUi7WN8,919 +torch/ao/nn/intrinsic/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/modules/__init__.py,sha256=sTYCkbIbcGxUiQAz2-QyNH8I3BnUQ3jflkmKA9RPr-k,883 +torch/ao/nn/intrinsic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/modules/__pycache__/fused.cpython-310.pyc,, +torch/ao/nn/intrinsic/modules/fused.py,sha256=SCZ0xDLRpYQhapDYnzP_Zv-v4hMg_kZeUa5VHfkselQ,9370 +torch/ao/nn/intrinsic/qat/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/intrinsic/qat/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/qat/modules/__init__.py,sha256=k99vQqwhgrdNcCFhUs9xb82U_Y1G4LCTbkZJ3gaEgNI,546 +torch/ao/nn/intrinsic/qat/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/qat/modules/__pycache__/conv_fused.cpython-310.pyc,, +torch/ao/nn/intrinsic/qat/modules/__pycache__/linear_fused.cpython-310.pyc,, +torch/ao/nn/intrinsic/qat/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/ao/nn/intrinsic/qat/modules/conv_fused.py,sha256=gaLF4U1gHWWHgxTjgoIxyzRj3hoxIECKjPJP7vpcvcU,29662 +torch/ao/nn/intrinsic/qat/modules/linear_fused.py,sha256=3wXuBLYU-UB8hDIAbbSK5ujT4kSYUnrnMJh5WlFfHkY,6293 +torch/ao/nn/intrinsic/qat/modules/linear_relu.py,sha256=GhFW5YNbcGE0GP2VobxglVChmNVAwDJNxBZHuOQAZYg,1590 +torch/ao/nn/intrinsic/quantized/__init__.py,sha256=O3rBvt2CAwEO2NsKTgloNap0AovxGVyvbwJ1wKwDNaU,235 +torch/ao/nn/intrinsic/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/dynamic/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/intrinsic/quantized/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/dynamic/modules/__init__.py,sha256=WXj7xEgWXEBFBM_KR3XB6HkVPWj6ZO1wtrgY2XoRinw,82 +torch/ao/nn/intrinsic/quantized/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/dynamic/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/dynamic/modules/linear_relu.py,sha256=5y4lGL-DKqHPwCLFuq6mTusos51VnQXP9b7srO9ASpI,1840 +torch/ao/nn/intrinsic/quantized/modules/__init__.py,sha256=sZsrH-au4x7UFRPKA0j0jrLtmoNKPVr40f0c0alCmfs,408 +torch/ao/nn/intrinsic/quantized/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/modules/__pycache__/bn_relu.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/modules/__pycache__/conv_add.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/modules/__pycache__/conv_relu.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/ao/nn/intrinsic/quantized/modules/bn_relu.py,sha256=dSnzUSWGvL2UcmiqaPec-dbTRMIGPU7Tj7-vqFl1ExQ,2781 +torch/ao/nn/intrinsic/quantized/modules/conv_add.py,sha256=CtrJYoI7RlvDW0UDi5WWBrvoWvST9IGiNPOdEjTxdsw,3700 +torch/ao/nn/intrinsic/quantized/modules/conv_relu.py,sha256=36ljh-cAlnSP0NFKwgqAEIEmFE9VKwC7-WBbFxA6_z4,7275 +torch/ao/nn/intrinsic/quantized/modules/linear_relu.py,sha256=HtfSD_oOq6xY6kw4YnjPITU0oswz31hUu0buk2UdQrY,6561 +torch/ao/nn/qat/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/qat/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/qat/dynamic/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/qat/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/qat/dynamic/modules/__init__.py,sha256=juJpue0ixFC8Vq3-HlcHdDRBPTd7H2jLGvdyQFwQzgk,49 +torch/ao/nn/qat/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/qat/dynamic/modules/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/qat/dynamic/modules/linear.py,sha256=-AvvsVe06MGrW7UjrOru7AIH-7rL5KSThePrEjlsplE,933 +torch/ao/nn/qat/modules/__init__.py,sha256=BQBQxFIl4cZ2EExGYlcrCoNXkS9LaVBjim_Arr48f34,261 +torch/ao/nn/qat/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/qat/modules/__pycache__/conv.cpython-310.pyc,, +torch/ao/nn/qat/modules/__pycache__/embedding_ops.cpython-310.pyc,, +torch/ao/nn/qat/modules/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/qat/modules/conv.py,sha256=pWZCCbvtNHXcNhpfEJOtY9Mfr2kAeLB8bwaYVV-yBVg,9424 +torch/ao/nn/qat/modules/embedding_ops.py,sha256=7AU2nQyFvnxZ-Ao15lMrs9OVD6WGKIhq0mbn2kDOyL0,7056 +torch/ao/nn/qat/modules/linear.py,sha256=6js1R3a-z4Dd1czTcruTomMUcNZFwL4gHpgW9jck5Tg,2874 +torch/ao/nn/quantizable/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/quantizable/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantizable/modules/__init__.py,sha256=DOrFHIHns-vtkT8MLwFMujkq5QsW2XXKu7cjQuxkPZc,160 +torch/ao/nn/quantizable/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantizable/modules/__pycache__/activation.cpython-310.pyc,, +torch/ao/nn/quantizable/modules/__pycache__/rnn.cpython-310.pyc,, +torch/ao/nn/quantizable/modules/activation.py,sha256=rXzoIeyHZzFqfw6vbp5_YC4GPAoRBZGwpb2vbU9LPYo,22333 +torch/ao/nn/quantizable/modules/rnn.py,sha256=jScWe6J_oazPHHnEiCb8t5BunpqfD2qAGimIjay3bZw,17177 +torch/ao/nn/quantized/__init__.py,sha256=dhO5H4qKeWJIqKbmuJA31y6Jc4_E07_0uZCz2Ut7Eag,685 +torch/ao/nn/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/__pycache__/functional.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/ao/nn/quantized/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/modules/__init__.py,sha256=99bhbZ0L1o_qTGVoVbx9lAOgA0YKxaeG15QQ9rpUWhU,384 +torch/ao/nn/quantized/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/modules/__pycache__/conv.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/modules/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/modules/__pycache__/rnn.cpython-310.pyc,, +torch/ao/nn/quantized/dynamic/modules/conv.py,sha256=Yf6EJ_YeTBAWKHBsZNc1Fi7YSapJdWGCp03qm2tQARE,17010 +torch/ao/nn/quantized/dynamic/modules/linear.py,sha256=g_DwYVTXd9VQ2TgG1pnDrTdwN2bxU_GEmfauFQ3TZ4c,6009 +torch/ao/nn/quantized/dynamic/modules/rnn.py,sha256=yu7o2mfbFFYYi8gbnDjaIaBrhJLJMHlBe21GquR8cvM,48232 +torch/ao/nn/quantized/functional.py,sha256=v671LwZVnHlRw8XYHtr4WQY6Pscrd3dETR6QYI1FWxU,29279 +torch/ao/nn/quantized/modules/__init__.py,sha256=chsivZFveuRPqsqH4N9ssaqX7fyKKzcLYKChSuXNvIY,4303 +torch/ao/nn/quantized/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/activation.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/batchnorm.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/conv.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/dropout.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/embedding_ops.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/functional_modules.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/normalization.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/rnn.cpython-310.pyc,, +torch/ao/nn/quantized/modules/__pycache__/utils.cpython-310.pyc,, +torch/ao/nn/quantized/modules/activation.py,sha256=1dxhgv6LqRuRRHP-HcXk7hZAbWIWqNO0WP8r0jM95ks,11327 +torch/ao/nn/quantized/modules/batchnorm.py,sha256=GzaWkcRMZzFtXe6gpxvdwE2aLuJn77pXsK_khKMwmtI,3915 +torch/ao/nn/quantized/modules/conv.py,sha256=2c0zmUZyIEOxxtd2czqJltbsFLq00WZRNwN15A9jgvk,39395 +torch/ao/nn/quantized/modules/dropout.py,sha256=OOxmrr90-PmGaEiGSEoh8LUBMG5rGcsKNn18SII058Y,743 +torch/ao/nn/quantized/modules/embedding_ops.py,sha256=OgMNDVtNS_PmhDQBIHqm9vQ_FCTNUoTqmSVNkkF6axo,13538 +torch/ao/nn/quantized/modules/functional_modules.py,sha256=CPhZWK9bb06I12AhD3Ku4CR36T7tp8L_zdQz4I6rQMY,9014 +torch/ao/nn/quantized/modules/linear.py,sha256=QJdao7F1v0MYsPOsDVtimGCFFSN4HiscK1Jq1zK1qDs,12622 +torch/ao/nn/quantized/modules/normalization.py,sha256=k9YO8peFeJPsJ21x0aTmCwIEbR7UzKp7qwFXld5a0sw,8081 +torch/ao/nn/quantized/modules/rnn.py,sha256=BXf3_4brefXnMh3Pl4Bww3CtDWqNxXfqX78i2kGppUU,1838 +torch/ao/nn/quantized/modules/utils.py,sha256=ICfmRM2bnvZzGJmEiZ0vaLoSjaKJkA9tDUPOaI30NcM,4579 +torch/ao/nn/quantized/reference/__init__.py,sha256=hfW9rcoKb1oV77KPD3samTqjHeCr3_b3Ww2ugN0bbYs,283 +torch/ao/nn/quantized/reference/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__init__.py,sha256=xgZZdRMMIQzFeTjpIAkhOmHdg0ORESL0HTw2Vt6lzDA,464 +torch/ao/nn/quantized/reference/modules/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__pycache__/conv.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__pycache__/rnn.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__pycache__/sparse.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/__pycache__/utils.cpython-310.pyc,, +torch/ao/nn/quantized/reference/modules/conv.py,sha256=TBiwQIM4WU9kj4ZnMPtzESuhdPzUb2aoVXSdEn_XBt4,13459 +torch/ao/nn/quantized/reference/modules/linear.py,sha256=E5Vd3Cud4gWfUv4xL-G4QwnH8V1mbogan5-McvlxbHc,2183 +torch/ao/nn/quantized/reference/modules/rnn.py,sha256=sLDDlzDljmUtRfsmamYrKMecd8BgqDFi8lM7nNnhQqQ,27184 +torch/ao/nn/quantized/reference/modules/sparse.py,sha256=8bCZNxGaRh1-o7KoxF55Q_pLesuIsWwO37GK08OvYpU,4192 +torch/ao/nn/quantized/reference/modules/utils.py,sha256=u55Ovxl4__UvT-9fyLBMVNKPmOdAUPQUQNzV4292Dzg,14295 +torch/ao/nn/sparse/__init__.py,sha256=PfB-tgPOelyV_0eb_ipJK4LzPHwB5Z-wfJXeE_O3AK4,24 +torch/ao/nn/sparse/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/__init__.py,sha256=KLvIbffZ6qZTRFGIl0Exw6hChjE107oSFy-ttvyJ7kE,186 +torch/ao/nn/sparse/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/__pycache__/utils.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/dynamic/__init__.py,sha256=PRt6lakWjibZNw_RaC826K3mGgh0L_aBBFvCxmOEWLY,56 +torch/ao/nn/sparse/quantized/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/dynamic/__pycache__/linear.cpython-310.pyc,, +torch/ao/nn/sparse/quantized/dynamic/linear.py,sha256=5hfa3b4oZ59A7EWHqDZu3uX1FYQasc0qWYqXmVI3uAI,6036 +torch/ao/nn/sparse/quantized/linear.py,sha256=RczzqKOt8JX_0oTIeNxwYHDBxhD-1rwEd0C4lOPX0n4,8560 +torch/ao/nn/sparse/quantized/utils.py,sha256=6GFI7oev9cZayGHSmJu8cqI6y93TEa9gA7FvX0kO5rY,1715 +torch/ao/ns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/ns/__pycache__/__init__.cpython-310.pyc,, +torch/ao/ns/__pycache__/_numeric_suite.cpython-310.pyc,, +torch/ao/ns/__pycache__/_numeric_suite_fx.cpython-310.pyc,, +torch/ao/ns/_numeric_suite.py,sha256=jkqg8bgKBnS6i0D5G54ayLQHjBAF__qSq67xYl32kYM,19527 +torch/ao/ns/_numeric_suite_fx.py,sha256=a78IrQ6ViY0-TQ24kNZ44Re73DIbnmG1Aa5wO4Pcc9U,40669 +torch/ao/ns/fx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/ns/fx/__pycache__/__init__.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/graph_matcher.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/graph_passes.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/mappings.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/n_shadows_utils.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/ns_types.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/pattern_utils.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/qconfig_multi_mapping.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/utils.cpython-310.pyc,, +torch/ao/ns/fx/__pycache__/weight_utils.cpython-310.pyc,, +torch/ao/ns/fx/graph_matcher.py,sha256=9XQra_I_8yhUynA064VRmmKDnRqn4NBqNeY9xMPNDmM,19229 +torch/ao/ns/fx/graph_passes.py,sha256=2ciUkze1Qdsr4Pd7LuqCDuHm7qqilUdumrDfihQWlIQ,40738 +torch/ao/ns/fx/mappings.py,sha256=Pd81Elf46aNYvVPkWj9Vaj6bvo_CuJLRURXV0n4wOuQ,18260 +torch/ao/ns/fx/n_shadows_utils.py,sha256=rw9azF7tEjFxvN-dtU7UyFvQaRGM3UwGlq-unxZK6tM,50122 +torch/ao/ns/fx/ns_types.py,sha256=ao4-hZJNKzPW6HzqJy7ilGNkYHikUFhd14dBgOEP_0A,2355 +torch/ao/ns/fx/pattern_utils.py,sha256=KLZ6dO_7u8OkCkhDSE_u3lkmaMIDSWH4dOdprpc1tFs,8284 +torch/ao/ns/fx/qconfig_multi_mapping.py,sha256=2KJI4iwvBuG5FBNs2LCNTf4JJR2LUi2l1sY_4MQbLyI,10076 +torch/ao/ns/fx/utils.py,sha256=afyCOS83FvOJeE78AlusNaXTvno5_nyQ0GuvEVLc6Ck,20536 +torch/ao/ns/fx/weight_utils.py,sha256=Sz6gc8gC_C-P3LuMLcZSfMxxCBFTtkO_SQcVCf9Do6o,11225 +torch/ao/pruning/__init__.py,sha256=qUqyaa2zDF9bM4l8suXQw6WfDSQ5nbQM7nodu59PiU4,715 +torch/ao/pruning/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/__pycache__/_mappings.cpython-310.pyc,, +torch/ao/pruning/_experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/_experimental/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/activation_sparsifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/_experimental/activation_sparsifier/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/activation_sparsifier/__pycache__/activation_sparsifier.cpython-310.pyc,, +torch/ao/pruning/_experimental/activation_sparsifier/activation_sparsifier.py,sha256=EpJsKiGKw_pRrbmiVZPFAUbqb2GzLyIdb_Fd6h_ilsw,18222 +torch/ao/pruning/_experimental/data_scheduler/__init__.py,sha256=BPYua3ba-QGK8fmcEOxzMkRUdQ6qaKxqIO1vh4_EWq4,91 +torch/ao/pruning/_experimental/data_scheduler/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_scheduler/__pycache__/base_data_scheduler.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_scheduler/base_data_scheduler.py,sha256=yiQmmbiqI0DTjBm93buZUKVg0AkrtfbAbQA8R8VcBOA,7409 +torch/ao/pruning/_experimental/data_sparsifier/__init__.py,sha256=CDr9hH7eg9bmbrdFM2E_COpX4eP8IkGOpaQeONAlybs,173 +torch/ao/pruning/_experimental/data_sparsifier/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/__pycache__/base_data_sparsifier.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/__pycache__/data_norm_sparsifier.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/__pycache__/quantization_utils.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/base_data_sparsifier.py,sha256=UR9YJwIYws-vWp9qL0myevN_br0n5DMHm2QFmwxk3mw,13046 +torch/ao/pruning/_experimental/data_sparsifier/data_norm_sparsifier.py,sha256=RAOXoSH_pBSvPaVlx5PZSy0mWbJc32_8lKzcIm05V68,7500 +torch/ao/pruning/_experimental/data_sparsifier/lightning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/_experimental/data_sparsifier/lightning/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/__pycache__/_data_sparstity_utils.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/__pycache__/data_sparsity.cpython-310.pyc,, +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/_data_sparstity_utils.py,sha256=tmR6vRBR5w-wqbRfJCkDAUSnfAU4vZxN0u5hEZphqVY,1590 +torch/ao/pruning/_experimental/data_sparsifier/lightning/callbacks/data_sparsity.py,sha256=nVc1h_SFnox7is-9pGvRoNLdIPCYY1MJDH5_0ggLlvU,6473 +torch/ao/pruning/_experimental/data_sparsifier/quantization_utils.py,sha256=xnyHv9koYh8kitLTNFAhnVf64sk6ybkXtImzx23WlDA,5966 +torch/ao/pruning/_experimental/pruner/FPGM_pruner.py,sha256=FVpLfSTYfwGycjOkdroSRpsfqcT5iQxC8w48mF5HcVM,3388 +torch/ao/pruning/_experimental/pruner/__init__.py,sha256=xomRxvLKj_PF8JMKHpiJALkJ7w-djJIt1oj5I65bgg0,273 +torch/ao/pruning/_experimental/pruner/__pycache__/FPGM_pruner.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/base_structured_sparsifier.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/lstm_saliency_pruner.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/match_utils.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/parametrization.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/prune_functions.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/__pycache__/saliency_pruner.cpython-310.pyc,, +torch/ao/pruning/_experimental/pruner/base_structured_sparsifier.py,sha256=21i9_mY_EtXDhnIXS3gFFw2s4-VmeIjEjvH7foyOBt4,10824 +torch/ao/pruning/_experimental/pruner/lstm_saliency_pruner.py,sha256=hJ9jyKBupBpeApycP-4lxyKkHc6yRYfnP1pCN9m92_o,2050 +torch/ao/pruning/_experimental/pruner/match_utils.py,sha256=yW06wMrPlHzLMoLo6KyL54BRa7rnjzXiD590Sk963_Y,1967 +torch/ao/pruning/_experimental/pruner/parametrization.py,sha256=3cf3ttrmADAziiepuOsfSEwHss33NotJtUo9a7rHyoo,1818 +torch/ao/pruning/_experimental/pruner/prune_functions.py,sha256=qEY2NWeV5t4qTlnxprHT2rD5OfbRZ71y_fpvd96NZwA,18992 +torch/ao/pruning/_experimental/pruner/saliency_pruner.py,sha256=kpx3frbax3zHACH2Pwq_b93nOog-XTCPc0T1bYjrjjY,1327 +torch/ao/pruning/_mappings.py,sha256=kVYJbQw0VjDw1KjKTH6bgX1o2BacpEMjkzlaqiSCdx8,566 +torch/ao/pruning/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/scheduler/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/scheduler/__pycache__/base_scheduler.cpython-310.pyc,, +torch/ao/pruning/scheduler/__pycache__/cubic_scheduler.cpython-310.pyc,, +torch/ao/pruning/scheduler/__pycache__/lambda_scheduler.cpython-310.pyc,, +torch/ao/pruning/scheduler/base_scheduler.py,sha256=klZjQbr5jzSHCmzeWFeWJkWBU0JLRL9sfTNjcm7gBNY,6311 +torch/ao/pruning/scheduler/cubic_scheduler.py,sha256=fXirWwTeIixjh4Vpvzt-4fgjyPb7awM_ixQjQhTC-2c,3873 +torch/ao/pruning/scheduler/lambda_scheduler.py,sha256=fRoa4OTZuuhxwwd9VLtUti5s6e7RHfwfDyy3UB3QjbU,2018 +torch/ao/pruning/sparsifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/pruning/sparsifier/__pycache__/__init__.cpython-310.pyc,, +torch/ao/pruning/sparsifier/__pycache__/base_sparsifier.cpython-310.pyc,, +torch/ao/pruning/sparsifier/__pycache__/nearly_diagonal_sparsifier.cpython-310.pyc,, +torch/ao/pruning/sparsifier/__pycache__/utils.cpython-310.pyc,, +torch/ao/pruning/sparsifier/__pycache__/weight_norm_sparsifier.cpython-310.pyc,, +torch/ao/pruning/sparsifier/base_sparsifier.py,sha256=JVlL80Zwjv13u802EzD3yThnnkH4L2hM8hbI6cXqplg,13762 +torch/ao/pruning/sparsifier/nearly_diagonal_sparsifier.py,sha256=tAI5EFoh6JZfolesoyfDuCzSxkjqhhtISXVvWjdMEw8,2189 +torch/ao/pruning/sparsifier/utils.py,sha256=tFKke04D87JFiXX0AAgvWzAAfoj0TxC03HqgZzDG0N0,4786 +torch/ao/pruning/sparsifier/weight_norm_sparsifier.py,sha256=xPLtL3wyQuBShVcL1yqpJeCRPiyO9EKop4O6KMxzX9I,8853 +torch/ao/quantization/__init__.py,sha256=w5L2IYww848lkeKLjhD-1JZKr-z3r2FWEbm7EZK1-Ac,6469 +torch/ao/quantization/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/__pycache__/_correct_bias.cpython-310.pyc,, +torch/ao/quantization/__pycache__/_equalize.cpython-310.pyc,, +torch/ao/quantization/__pycache__/_learnable_fake_quantize.cpython-310.pyc,, +torch/ao/quantization/__pycache__/fake_quantize.cpython-310.pyc,, +torch/ao/quantization/__pycache__/fuse_modules.cpython-310.pyc,, +torch/ao/quantization/__pycache__/fuser_method_mappings.cpython-310.pyc,, +torch/ao/quantization/__pycache__/observer.cpython-310.pyc,, +torch/ao/quantization/__pycache__/qconfig.cpython-310.pyc,, +torch/ao/quantization/__pycache__/qconfig_mapping.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quant_type.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quantization_mappings.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quantize.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quantize_fx.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quantize_jit.cpython-310.pyc,, +torch/ao/quantization/__pycache__/quantize_pt2e.cpython-310.pyc,, +torch/ao/quantization/__pycache__/stubs.cpython-310.pyc,, +torch/ao/quantization/__pycache__/utils.cpython-310.pyc,, +torch/ao/quantization/_correct_bias.py,sha256=nWdo5CAg0EPLexTZ6Jehyy85GDQjC8k7GsJ6tCU5zoA,5374 +torch/ao/quantization/_equalize.py,sha256=bZZldTC8zoLDtc-fEeftEwNwvd2bxCbwFyYMlwj1OeE,6954 +torch/ao/quantization/_learnable_fake_quantize.py,sha256=YZ1t157mkK8al8gqAnl01zdxAJPhmmUTIo87TZDRuO0,7532 +torch/ao/quantization/backend_config/__init__.py,sha256=k1xaNCxYKyGefvUWwxgb8eTKKEJh8Z-9XUOeQgDO0S4,889 +torch/ao/quantization/backend_config/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/_common_operator_config_utils.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/_qnnpack_pt2e.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/backend_config.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/executorch.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/fbgemm.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/native.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/observation_type.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/onednn.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/qnnpack.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/tensorrt.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/utils.cpython-310.pyc,, +torch/ao/quantization/backend_config/__pycache__/x86.cpython-310.pyc,, +torch/ao/quantization/backend_config/_common_operator_config_utils.py,sha256=bfN-b8BwxTPeaul2WKUqu5-Y-2MtWyW0sntDOk2wfnc,27073 +torch/ao/quantization/backend_config/_qnnpack_pt2e.py,sha256=SYV4oemlmy_RRxe-0XSpLBQgk33RLChlPrSjTcRgtog,6306 +torch/ao/quantization/backend_config/backend_config.py,sha256=UHIhDNfe6LYlGWWQTjqAnP2ZHtRqdRFp53mheFhWBKA,30465 +torch/ao/quantization/backend_config/executorch.py,sha256=9bjVtmnOhgXUzHT3Xx5FZQiU2Sd1qp5tanRtPZ87Wjk,16953 +torch/ao/quantization/backend_config/fbgemm.py,sha256=358ATueA22LrpHct9AvA-FQrQ2oo6WSC5MTQzsLmcVE,4123 +torch/ao/quantization/backend_config/native.py,sha256=vGnfZqSnUKZpcFRzAmBu4Q3xwC08xFBdzEYqzkYoDKI,8048 +torch/ao/quantization/backend_config/observation_type.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/quantization/backend_config/onednn.py,sha256=Ug7IhfW9vQLwtEmlBzOF9IXzRz0Tz9lc-Kw15JVRKAU,19150 +torch/ao/quantization/backend_config/qnnpack.py,sha256=7RvYtsyjrfVs9LDju0srKxzWQzY-4K9K9XNEdQujAao,5339 +torch/ao/quantization/backend_config/tensorrt.py,sha256=vMpWuWEsAMvCcEE-Vv5XHapWMDodxiDuj1Z2QdFc1cc,2883 +torch/ao/quantization/backend_config/utils.py,sha256=QURoq4AjHJHmFIvgsLSnaDewWwVWc22mT_MmwJ7hqGk,12342 +torch/ao/quantization/backend_config/x86.py,sha256=qdEh3Nj2sMY6kUWT3nSJfiRSfBPfeSRMCmQPYbaN3uE,3784 +torch/ao/quantization/fake_quantize.py,sha256=RTPltJoS9s3rIo6sHDpfoUdK1qwR2oDENX6QMgEMkJ0,24764 +torch/ao/quantization/fuse_modules.py,sha256=pAPPD8pLvv7F4QNSTrqPVF07j3FW600PDv6uV1nFc8g,6748 +torch/ao/quantization/fuser_method_mappings.py,sha256=EJXvlSy4yV0bXDt8sdAAGoG5RpVxcDoynx4AFryNCVE,10249 +torch/ao/quantization/fx/__init__.py,sha256=XcWhBskMMnQCJmz6ezLX7JFcyBUuNNyn8VCzY1OCz4A,81 +torch/ao/quantization/fx/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/_decomposed.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/_equalize.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/_lower_to_native_backend.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/convert.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/custom_config.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/fuse.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/fuse_handler.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/graph_module.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/lower_to_fbgemm.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/lower_to_qnnpack.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/lstm_utils.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/match_utils.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/pattern_utils.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/prepare.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/qconfig_mapping_utils.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/quantize_handler.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/tracer.cpython-310.pyc,, +torch/ao/quantization/fx/__pycache__/utils.cpython-310.pyc,, +torch/ao/quantization/fx/_decomposed.py,sha256=_38f5awLyUBUXs-ZUVsfzkFjkUlAPafzSmyzaJ0K8-Y,37856 +torch/ao/quantization/fx/_equalize.py,sha256=qJj4dJhLfwwuTbI5i4_U-TJIEowjFrGjnMFqBdPX9NM,37027 +torch/ao/quantization/fx/_lower_to_native_backend.py,sha256=_fIdzqytCjrVF-5w-xk1lXVuu5lii9a8HmAKeFDpXQA,51595 +torch/ao/quantization/fx/_model_report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/quantization/fx/_model_report/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/fx/_model_report/__pycache__/detector.cpython-310.pyc,, +torch/ao/quantization/fx/_model_report/__pycache__/model_report.cpython-310.pyc,, +torch/ao/quantization/fx/_model_report/__pycache__/model_report_observer.cpython-310.pyc,, +torch/ao/quantization/fx/_model_report/__pycache__/model_report_visualizer.cpython-310.pyc,, +torch/ao/quantization/fx/_model_report/detector.py,sha256=wT6HLhaNIQSDCsUsC50VComiWfVx_nadzd7xqQw0yUQ,73872 +torch/ao/quantization/fx/_model_report/model_report.py,sha256=i6uyhqdNX7k7rZiQbzxLcDhsDj37TzHt8YSgEoh77Fw,28697 +torch/ao/quantization/fx/_model_report/model_report_observer.py,sha256=95ptu3TE8T2Xyn41-EXj_z9k9Ip6pKYcNtsD70D6vyE,11789 +torch/ao/quantization/fx/_model_report/model_report_visualizer.py,sha256=QAexuXlv9EcZkechgdI-1NdXe9D7Abp_G-25ZGPBV6c,32106 +torch/ao/quantization/fx/convert.py,sha256=X5ZQYGI8_PGnnlrqkpd90rvJ_TxP_ZVrFPFufCWUbzk,55692 +torch/ao/quantization/fx/custom_config.py,sha256=r6c5dS0e0JgIBwoDbjZI1Gw-TPlN_LGsq4bBElbQXUk,20693 +torch/ao/quantization/fx/fuse.py,sha256=vrHm15ISmBTzuyMiDPI76ssSPPzjSTUBKndtsTSjI-E,6541 +torch/ao/quantization/fx/fuse_handler.py,sha256=uiqMQ7BRFbTEDZjHHmzfg8bSJad1V7ZrIEWr9SyEcv0,4688 +torch/ao/quantization/fx/graph_module.py,sha256=OQQg3RJDUa1fn2wnBEISkesqNE9xNVCGxVpPGlqEFp4,5879 +torch/ao/quantization/fx/lower_to_fbgemm.py,sha256=R_Ipce4L8BkkjFaus66sILJpdHB7mqOMY-KuoxzFrk0,532 +torch/ao/quantization/fx/lower_to_qnnpack.py,sha256=C-y4Es9ZKShs1VIIeFLhG2xj2dIy7f_sXqgsTUN0RVE,541 +torch/ao/quantization/fx/lstm_utils.py,sha256=GNeGCiMgnGCFwbt9YbzpJ6nF5LdbwuhxMdBm_atFuK0,9328 +torch/ao/quantization/fx/match_utils.py,sha256=HcwgwxVpZeKX0d9Ap5XSm2m1HeBU68n2YDik7ewS2Go,9116 +torch/ao/quantization/fx/pattern_utils.py,sha256=XELt4d5df5lHCHuBWp2JxY3XcYzWlaGzUSImOOzeOpc,3500 +torch/ao/quantization/fx/prepare.py,sha256=y4MdkqAoYyhpRKkNey5J1xfftiDdcPURwt_sBLOdsmw,83050 +torch/ao/quantization/fx/qconfig_mapping_utils.py,sha256=cf3A3V6fh7dCwGxSDlQW8dvKO_1EFlAg7atK0JGHQ2A,14789 +torch/ao/quantization/fx/quantize_handler.py,sha256=rqMohgVrtI43Bqb3Ntvx-PzzV2nB-SOTrCKStFK9oTo,7188 +torch/ao/quantization/fx/tracer.py,sha256=vcj2ZcSjwaaCkjtcPAj-8kmJaau_YzvJpht8x0Ptm1g,1657 +torch/ao/quantization/fx/utils.py,sha256=GYcJV0OfQwnpDxFRqT1piGS_3PqbQzWt3UaNvdpJa2k,37576 +torch/ao/quantization/observer.py,sha256=hJI-AcCFsXjRZnLkLeiuocfOUfbNUnGH7DhsASMPx-o,66134 +torch/ao/quantization/pt2e/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/ao/quantization/pt2e/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/duplicate_dq_pass.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/export_utils.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/generate_numeric_debug_handle.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/graph_utils.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/port_metadata_pass.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/prepare.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/qat_utils.cpython-310.pyc,, +torch/ao/quantization/pt2e/__pycache__/utils.cpython-310.pyc,, +torch/ao/quantization/pt2e/duplicate_dq_pass.py,sha256=I71goAGsLrUA5UUzmxIQLL1QZ5p5LYSj_0qVHNnoIX4,3041 +torch/ao/quantization/pt2e/export_utils.py,sha256=32EoClAPXdKG_fxlNVk7n5SDYbroikun5E0Pv0X5ycg,7091 +torch/ao/quantization/pt2e/generate_numeric_debug_handle.py,sha256=XtIhI0Zy9ANI0VD3sQm0Hjd4M7w_ADWC1FwK-mJsotk,584 +torch/ao/quantization/pt2e/graph_utils.py,sha256=UvMSKgnFB3Wd2OxR9ZSZSk2u6QFR_kQFxVKohYPUmHw,3887 +torch/ao/quantization/pt2e/port_metadata_pass.py,sha256=bPx5rOaQOS6m3ZV8Zomt9XtVJIu8ajUqK7Ldu8BJ_wY,8293 +torch/ao/quantization/pt2e/prepare.py,sha256=fvyVTjXsX4slTxsXhoOrk1DnKt0b-nTndk2qxGlkkV0,20459 +torch/ao/quantization/pt2e/qat_utils.py,sha256=wQsYrzDVFmsiT1qvi5Exiu3dfzIT8Ai4LV1H8CNiSiI,32111 +torch/ao/quantization/pt2e/representation/__init__.py,sha256=sWVndHoPQ6CNaIiUCKpBx4EbvVdTmVplU0-Sf9BZoLU,109 +torch/ao/quantization/pt2e/representation/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/pt2e/representation/__pycache__/rewrite.cpython-310.pyc,, +torch/ao/quantization/pt2e/representation/rewrite.py,sha256=BOlSLGJqmA72jwVwnkES0Id8gQA2rFc9O-CMAT1hqzg,26286 +torch/ao/quantization/pt2e/utils.py,sha256=mFB2e4umMunu4-L5vI-cduHMQpC9YApYCNtzfkoQb_Y,21139 +torch/ao/quantization/qconfig.py,sha256=d3yLB_SkarDsaI0eCtOf4P7iKS_PBRD73q2xItPdmVM,25824 +torch/ao/quantization/qconfig_mapping.py,sha256=EggVYxiHC4XVoHLmKL7lAxLxlmHqcfDIb1Z5clqJQ8U,14598 +torch/ao/quantization/quant_type.py,sha256=wj7Mk-f4BncrM0yqsP9XTHqIEjECt9iZiMlEQ41NXWw,755 +torch/ao/quantization/quantization_mappings.py,sha256=IH5K1tK9wx6o1em45SX60x77fJcMMJ_HTHzsHLyDbbI,13878 +torch/ao/quantization/quantize.py,sha256=vuSWR5ypxYSYTOTxPFkWh_jxHKOin318QfubYBT4E7M,28476 +torch/ao/quantization/quantize_fx.py,sha256=2vwZ-lbnpGVvnofQknCa-1oc2WiCyPhzvaaY6Co7nQI,32001 +torch/ao/quantization/quantize_jit.py,sha256=g619D7eDfHUPri3G2oLPtPMIHmlHZ088s6PP8N96cSI,14605 +torch/ao/quantization/quantize_pt2e.py,sha256=0T2kUw-ypw2dZu6WUI5qoN418cDmCjLlK3G4R87J0pI,9255 +torch/ao/quantization/quantizer/__init__.py,sha256=dgmk3-EJMR3k-Ytcpsm6IBUqk9LDsve3btFoGAHaDSc,454 +torch/ao/quantization/quantizer/__pycache__/__init__.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/composable_quantizer.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/embedding_quantizer.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/quantizer.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/utils.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/x86_inductor_quantizer.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/xnnpack_quantizer.cpython-310.pyc,, +torch/ao/quantization/quantizer/__pycache__/xnnpack_quantizer_utils.cpython-310.pyc,, +torch/ao/quantization/quantizer/composable_quantizer.py,sha256=8gshfUvE-Rf_g04q4fcYq8_fQfjJzUJouzRREvAEYW8,2952 +torch/ao/quantization/quantizer/embedding_quantizer.py,sha256=elIbTSM5b5EyxLebGAwrZVJvjLD4mdfevNc_DggBz08,3471 +torch/ao/quantization/quantizer/quantizer.py,sha256=S-Pb-7k1jSQPJF2m7zEYTzj1P74fp9kaNC_yKdvGzY0,5540 +torch/ao/quantization/quantizer/utils.py,sha256=Xrd0fzoPz8u0l-5JkTlnFPmYITSG3pvVVoedjpMVEjU,1873 +torch/ao/quantization/quantizer/x86_inductor_quantizer.py,sha256=ELMQq-d4t2NGqfnNkd-J324o4xf1QtGTse3B-eQ9KbQ,42226 +torch/ao/quantization/quantizer/xnnpack_quantizer.py,sha256=mU9gI6VXWumoJ0XJ2YnziBD78yQllt_StHiYVBgdnkw,16362 +torch/ao/quantization/quantizer/xnnpack_quantizer_utils.py,sha256=lx6HamHEA3DPXo4RWWOdjN6GjvMcq5tflbTmHY6xKEI,38435 +torch/ao/quantization/stubs.py,sha256=9dCEyHugCeX1Qid9IPOp-hJ_NhVRW_KO8kDZ1SZZscc,2010 +torch/ao/quantization/utils.py,sha256=-n5ZuRpY9Ns4HO7pgA7mKRlBYO2MGz9V-pIkSNnfvXc,25907 +torch/autograd/__init__.py,sha256=jLMM3-wAaGp3sFwkXeu5qJhOE3iPRxU18RSieQDXl4Q,21948 +torch/autograd/__pycache__/__init__.cpython-310.pyc,, +torch/autograd/__pycache__/anomaly_mode.cpython-310.pyc,, +torch/autograd/__pycache__/forward_ad.cpython-310.pyc,, +torch/autograd/__pycache__/function.cpython-310.pyc,, +torch/autograd/__pycache__/functional.cpython-310.pyc,, +torch/autograd/__pycache__/grad_mode.cpython-310.pyc,, +torch/autograd/__pycache__/gradcheck.cpython-310.pyc,, +torch/autograd/__pycache__/graph.cpython-310.pyc,, +torch/autograd/__pycache__/profiler.cpython-310.pyc,, +torch/autograd/__pycache__/profiler_legacy.cpython-310.pyc,, +torch/autograd/__pycache__/profiler_util.cpython-310.pyc,, +torch/autograd/__pycache__/variable.cpython-310.pyc,, +torch/autograd/_functions/__init__.py,sha256=sdKJj6Dia1vNRSolyufzRKdn5qHkgCBCUI3OBm-PGW0,36 +torch/autograd/_functions/__pycache__/__init__.cpython-310.pyc,, +torch/autograd/_functions/__pycache__/tensor.cpython-310.pyc,, +torch/autograd/_functions/__pycache__/utils.cpython-310.pyc,, +torch/autograd/_functions/tensor.py,sha256=ycwq72Onc-p329OwFeZ320b5Vjk_aPpSjCgj_7ZsiLQ,2106 +torch/autograd/_functions/utils.py,sha256=Bri3OWu4lkkV6YGLaLUYtdA95Y8ehK5MobMThDoCTt0,2030 +torch/autograd/anomaly_mode.py,sha256=Mo-BPwoac_vG_brHOSZ0Y5jj7veDH-nF4nkfPXU7upE,4810 +torch/autograd/forward_ad.py,sha256=U3IpmJ18svx3n2qXM3-E4KYmB7MwNihGbYtGYAfxdTk,7594 +torch/autograd/function.py,sha256=bu8-KKYuf8btXlyrV0B4RfwH08MzIWUkfsMOf4kOb5o,34625 +torch/autograd/functional.py,sha256=-ZqPKeXBMim7VmsJjfYwNWfz9K2fgM8NB2n06V_cdCA,52278 +torch/autograd/grad_mode.py,sha256=T1vGrp1A8sR3fdlp_mOX-SH7ZI9DMmwhR85F1zvl7G8,12972 +torch/autograd/gradcheck.py,sha256=9hiejO7jhMhWaBUFXa3H1lI9pHonPyi22yAjqAl4rKU,90591 +torch/autograd/graph.py,sha256=8-AKa29RmtXiPFcZ9WtfAebpAEvLq8rAi3CeohOTBFE,26723 +torch/autograd/profiler.py,sha256=p9CDP_Z5MCarb8zzmGU35bDsdz6EZ7hW-i7upj3V1Ng,41454 +torch/autograd/profiler_legacy.py,sha256=f1vCGAjDpGud2eGv6FJNVRlSvcFEmAXOQKTWr5M_xHk,11105 +torch/autograd/profiler_util.py,sha256=uTR0xZGm9PXtv8cvEPJ__heUOtnRphDjZGzKYP5CYs4,42384 +torch/autograd/variable.py,sha256=MuEFYqFoe3iEw-slxG_Ar4Cd5t2x9OJJIX8_SiPBxBE,364 +torch/backends/__init__.py,sha256=g0tWtZnkloTR5s10trgRRUqSy5BEVb-vajJBFBYeEno,1711 +torch/backends/__pycache__/__init__.cpython-310.pyc,, +torch/backends/_coreml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/backends/_coreml/__pycache__/__init__.cpython-310.pyc,, +torch/backends/_coreml/__pycache__/preprocess.cpython-310.pyc,, +torch/backends/_coreml/preprocess.py,sha256=MRh1UaOG-RHHfdtZlVqwU-cTvrNzqHyjsqqYXUa4IBM,4220 +torch/backends/_nnapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/backends/_nnapi/__pycache__/__init__.cpython-310.pyc,, +torch/backends/_nnapi/__pycache__/prepare.cpython-310.pyc,, +torch/backends/_nnapi/__pycache__/serializer.cpython-310.pyc,, +torch/backends/_nnapi/prepare.py,sha256=jAF-8ZOKOBOPAxmSU94rL9WHD-2vU9djmA_zHZaGs78,6516 +torch/backends/_nnapi/serializer.py,sha256=kvuAg-VbQ-st6VRUc0YzZhxkw44JeblDHAQVU3jN0Gk,81212 +torch/backends/cpu/__init__.py,sha256=eXEopiEO61M4MV-A4RBSHSKcKzg1xFK8YJbNbPGDgp8,298 +torch/backends/cpu/__pycache__/__init__.cpython-310.pyc,, +torch/backends/cuda/__init__.py,sha256=znjvpSRuF8zoIQn5SF6DFVfpyGktfIZMUE-9X9f615Q,12349 +torch/backends/cuda/__pycache__/__init__.cpython-310.pyc,, +torch/backends/cudnn/__init__.py,sha256=mMF0uFj_Pmm2ReBLDpXS4cHLqE1_89e_do_W8JWTNR0,6575 +torch/backends/cudnn/__pycache__/__init__.cpython-310.pyc,, +torch/backends/cudnn/__pycache__/rnn.cpython-310.pyc,, +torch/backends/cudnn/rnn.py,sha256=ogLvJqMP9H9ab06PB_GBZK6iEaKC2aRiu3kZE2Krux8,2017 +torch/backends/mha/__init__.py,sha256=GSRB9qHmMJ4GSB4ke2qF6so_qI7YXQZx83sk6dejvCI,715 +torch/backends/mha/__pycache__/__init__.cpython-310.pyc,, +torch/backends/mkl/__init__.py,sha256=T4P31kIuJa6ahkx1uDQjgD14wGJXd7CaasAOPS6l-mU,1755 +torch/backends/mkl/__pycache__/__init__.cpython-310.pyc,, +torch/backends/mkldnn/__init__.py,sha256=tjoOmf1Eh2_PPVnv_WhOKOmB1xDhm2e_U5M7Y6hjJSY,2934 +torch/backends/mkldnn/__pycache__/__init__.cpython-310.pyc,, +torch/backends/mps/__init__.py,sha256=cj05iZ5GhU68VvpGiwq4aMzIUANrn8q0aV7bI6NOXj8,1650 +torch/backends/mps/__pycache__/__init__.cpython-310.pyc,, +torch/backends/nnpack/__init__.py,sha256=l306KTIvTZIwRX31xX2SgFgfEKeA5toHGAZyRVzKlE4,809 +torch/backends/nnpack/__pycache__/__init__.cpython-310.pyc,, +torch/backends/openmp/__init__.py,sha256=R319KXl83TXQBIDp675MRdxC0GeMshRoBKSfLe7Nkjk,130 +torch/backends/openmp/__pycache__/__init__.cpython-310.pyc,, +torch/backends/opt_einsum/__init__.py,sha256=lvo21CBq0htrLaavqNcLBCVMDMF6TmXVy1bRDnCGrSs,3424 +torch/backends/opt_einsum/__pycache__/__init__.cpython-310.pyc,, +torch/backends/quantized/__init__.py,sha256=faeIgQ_9zzr-lLp57E8X7nqvpNg_GSjepdCubt1JeD8,1858 +torch/backends/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/backends/xeon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/backends/xeon/__pycache__/__init__.cpython-310.pyc,, +torch/backends/xeon/__pycache__/run_cpu.cpython-310.pyc,, +torch/backends/xeon/run_cpu.py,sha256=aL3SjXvsXjG1nexRdCtnSFIJSVCI6v_9GbboCazbbiU,36845 +torch/backends/xnnpack/__init__.py,sha256=quOConD3FMrefTb_VLQ0G_cMOH70tg4JO8hGjdFZEQ0,675 +torch/backends/xnnpack/__pycache__/__init__.cpython-310.pyc,, +torch/bin/protoc,sha256=M5CHOy2lbBOXrew3KPFYjFHhgvFbEj07TU8kjTHB9No,5330888 +torch/bin/protoc-3.13.0.0,sha256=M5CHOy2lbBOXrew3KPFYjFHhgvFbEj07TU8kjTHB9No,5330888 +torch/bin/torch_shm_manager,sha256=Dg3zQDukdI85K4zF61ZdFTtO3lyTh0L1fxVl9SQM8Ws,80456 +torch/compiler/__init__.py,sha256=WBfzMptVurZ95KK4p2v-JkZUNp7mdxypac_3-JCTKl0,6422 +torch/compiler/__pycache__/__init__.cpython-310.pyc,, +torch/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/contrib/__pycache__/__init__.cpython-310.pyc,, +torch/contrib/__pycache__/_tensorboard_vis.cpython-310.pyc,, +torch/contrib/_tensorboard_vis.py,sha256=OiLBnE24qCffM68kgeZe7g6gl2Ud8KC9x1S9HfxO5xA,5916 +torch/cpu/__init__.py,sha256=KXQb1lYdyrNHShTzKqMgDoNnaI3Sqmf-ZLceeaFlC-E,3525 +torch/cpu/__pycache__/__init__.cpython-310.pyc,, +torch/cpu/amp/__init__.py,sha256=E_HPtKk9IO3AW-gyneT7K5wtjnFZHx9GkvH424D_kb8,72 +torch/cpu/amp/__pycache__/__init__.cpython-310.pyc,, +torch/cpu/amp/__pycache__/autocast_mode.cpython-310.pyc,, +torch/cpu/amp/__pycache__/grad_scaler.cpython-310.pyc,, +torch/cpu/amp/autocast_mode.py,sha256=MGlcNtApgK_wB47UUCJulrFYyOmm0jtb_rVHvTKewiw,1247 +torch/cpu/amp/grad_scaler.py,sha256=nTkwLbUt3sbmiz7OvoZVcqcfycFxoUH9CBSt38QULmE,710 +torch/cuda/__init__.py,sha256=EYPvSKOCZa7IB71Ehq11y7Bng3SwL9te-LimWrrU14g,44941 +torch/cuda/__pycache__/__init__.cpython-310.pyc,, +torch/cuda/__pycache__/_memory_viz.cpython-310.pyc,, +torch/cuda/__pycache__/_sanitizer.cpython-310.pyc,, +torch/cuda/__pycache__/_utils.cpython-310.pyc,, +torch/cuda/__pycache__/comm.cpython-310.pyc,, +torch/cuda/__pycache__/error.cpython-310.pyc,, +torch/cuda/__pycache__/graphs.cpython-310.pyc,, +torch/cuda/__pycache__/jiterator.cpython-310.pyc,, +torch/cuda/__pycache__/memory.cpython-310.pyc,, +torch/cuda/__pycache__/nccl.cpython-310.pyc,, +torch/cuda/__pycache__/nvtx.cpython-310.pyc,, +torch/cuda/__pycache__/profiler.cpython-310.pyc,, +torch/cuda/__pycache__/random.cpython-310.pyc,, +torch/cuda/__pycache__/sparse.cpython-310.pyc,, +torch/cuda/__pycache__/streams.cpython-310.pyc,, +torch/cuda/_memory_viz.py,sha256=Ghqzoj0KudAe2jWJvwhBi6I0kecD70LWon5-ldgrwSg,24804 +torch/cuda/_sanitizer.py,sha256=knq3g3vZxOoUrMQfaJ46ARPh6MA2T4WrCUSd8w5SueM,22432 +torch/cuda/_utils.py,sha256=_lWqK6eEa4-odb_CBYKyWjUY-iVr3vZwWHNqeTS9mVM,1597 +torch/cuda/amp/__init__.py,sha256=2GI7qU_dzMroeeoyC9Crwg28-jpIp7xCYMa39nWMlHE,266 +torch/cuda/amp/__pycache__/__init__.cpython-310.pyc,, +torch/cuda/amp/__pycache__/autocast_mode.cpython-310.pyc,, +torch/cuda/amp/__pycache__/common.cpython-310.pyc,, +torch/cuda/amp/__pycache__/grad_scaler.cpython-310.pyc,, +torch/cuda/amp/autocast_mode.py,sha256=4vW5g-2BrMLIcPLz5pwtvxCxWPoj1_JmHOQGO_JeXEs,5167 +torch/cuda/amp/common.py,sha256=QdcXnCNAwps5VVTNo6jsdmES6H6K6zqpyUZxIZmfKa0,202 +torch/cuda/amp/grad_scaler.py,sha256=n1JaK5oOHOtSIAUJM8LO2KQEff4-8PZmVNopU4o2f5w,768 +torch/cuda/comm.py,sha256=g4kiETMiMDJ5ufrlym1JdITVMuZLogs8HiwaC111U0Q,343 +torch/cuda/error.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/cuda/graphs.py,sha256=3yd3bRWZCzJRjTxbf1L3eib5_dU9u9V32QbJBklj36E,21738 +torch/cuda/jiterator.py,sha256=aUkfHRmKzvw4ZyF8b6UkURnmJvPgUl7YLcG2InXYLCs,6790 +torch/cuda/memory.py,sha256=gzUI0S_0d0K6Zby7xoAYCHpeTl-Q2iC2aD7MiLEl-pY,35047 +torch/cuda/nccl.py,sha256=YqnefVwWH0Lmp1LW_fI-ZoZhHFggWbHOOkM1E50YJxM,4110 +torch/cuda/nvtx.py,sha256=sOydfpK6FbkQGli4ctRcSSI0zTW00SE-rCpOTT6AVwY,2415 +torch/cuda/profiler.py,sha256=5RSXPx0OW9NlGVzlQ73m2bpXGcwVkCcb8R_KAgjmM3M,1666 +torch/cuda/random.py,sha256=4kLtmqUz3GgavLa1KlaDmTrNeuliIU91KkSgeBd6HvM,5255 +torch/cuda/sparse.py,sha256=H912FRisikGM9SSVDQQq-YX5TNIilBYBZs1AwmIv3GQ,67 +torch/cuda/streams.py,sha256=I_TprFSOtlwPvo-cbDCL0BOC35RORrJ9Qu-6TNy1YX4,8320 +torch/distributed/__init__.py,sha256=l6XKkOOD3hf7gRszz_9sYicBleCSauZqWlHnzTnrjW0,3877 +torch/distributed/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/__pycache__/_composable_state.cpython-310.pyc,, +torch/distributed/__pycache__/_functional_collectives.cpython-310.pyc,, +torch/distributed/__pycache__/_functional_collectives_impl.cpython-310.pyc,, +torch/distributed/__pycache__/_state_dict_utils.cpython-310.pyc,, +torch/distributed/__pycache__/argparse_util.cpython-310.pyc,, +torch/distributed/__pycache__/c10d_logger.cpython-310.pyc,, +torch/distributed/__pycache__/collective_utils.cpython-310.pyc,, +torch/distributed/__pycache__/constants.cpython-310.pyc,, +torch/distributed/__pycache__/device_mesh.cpython-310.pyc,, +torch/distributed/__pycache__/distributed_c10d.cpython-310.pyc,, +torch/distributed/__pycache__/launch.cpython-310.pyc,, +torch/distributed/__pycache__/logging_handlers.cpython-310.pyc,, +torch/distributed/__pycache__/remote_device.cpython-310.pyc,, +torch/distributed/__pycache__/rendezvous.cpython-310.pyc,, +torch/distributed/__pycache__/run.cpython-310.pyc,, +torch/distributed/__pycache__/utils.cpython-310.pyc,, +torch/distributed/_composable/__init__.py,sha256=m_X5LTwtmai9gMvopIlzj-N32YkCV1aTokhVNgUf8LU,162 +torch/distributed/_composable/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_composable/__pycache__/checkpoint_activation.cpython-310.pyc,, +torch/distributed/_composable/__pycache__/contract.cpython-310.pyc,, +torch/distributed/_composable/__pycache__/fully_shard.cpython-310.pyc,, +torch/distributed/_composable/__pycache__/replicate.cpython-310.pyc,, +torch/distributed/_composable/checkpoint_activation.py,sha256=AeoOhbTP-cCVfK7nEvvLQElRX5Hp9sjcoV7mfp7H2rg,3335 +torch/distributed/_composable/contract.py,sha256=StFnsJiSjB4BM5tM-Q9hNOId4yuVrzWj0QsGvOawkDQ,7373 +torch/distributed/_composable/fsdp/__init__.py,sha256=3WHJpfYvfuFCfcOTVkoPYzjYHkNd4vKQG5iQ7QzeE6s,87 +torch/distributed/_composable/fsdp/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_api.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_collectives.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_common.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_init.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_param.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_param_group.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/_fsdp_state.cpython-310.pyc,, +torch/distributed/_composable/fsdp/__pycache__/fully_shard.cpython-310.pyc,, +torch/distributed/_composable/fsdp/_fsdp_api.py,sha256=cIcxxE7iT2fEip-AwpN3Gq3H15RzefF-58-BpC_xYQk,2511 +torch/distributed/_composable/fsdp/_fsdp_collectives.py,sha256=iefv78rz-yjex_b99di5Oizi_fBfupReE37BibwyM80,8777 +torch/distributed/_composable/fsdp/_fsdp_common.py,sha256=--Mx9fCOYi8i0EtwN8RvHwlspa9DwbFlTEQx3PMUepU,4815 +torch/distributed/_composable/fsdp/_fsdp_init.py,sha256=xvonoS0ldgQyccneif8DfjoCpX4I8_eFMB2YMQsktZk,5836 +torch/distributed/_composable/fsdp/_fsdp_param.py,sha256=-xUNGJMfBDj0JN9dPqi-4Nv8v4CtGouZOtATTSqwwOU,19430 +torch/distributed/_composable/fsdp/_fsdp_param_group.py,sha256=AfnkCexhnSfNp7T7CvcOrzhlCIALoEGE8Ngo5OGzhLQ,22623 +torch/distributed/_composable/fsdp/_fsdp_state.py,sha256=Yya5Fag5j9_NUBYLbp-gC1tbUULFYjAFwsmJFkMrN3E,11566 +torch/distributed/_composable/fsdp/fully_shard.py,sha256=epINDyehRPWNJFSiU-dreQm4dmOjk4cmaw1Ij5nAtOU,11626 +torch/distributed/_composable/fully_shard.py,sha256=7BVRWO8BTe3hviboA8V_mWKX-IirZDLaOozN_Iuzhhg,5177 +torch/distributed/_composable/replicate.py,sha256=u2fIfXD-vK_cC0jVNd4hcQnjoTwa6LTR6TGLhM2ACMY,5320 +torch/distributed/_composable_state.py,sha256=LV7Lb610CsRZ7SxFp7mLz-5K0cwu7LP5aKil_ouDKsg,1124 +torch/distributed/_functional_collectives.py,sha256=gX6qRzXxExtU36X4u4-VjjRL7OojLkLE_k0SHfkVClU,40481 +torch/distributed/_functional_collectives_impl.py,sha256=2ZGs7QNwxFoMlwpSpGAbOhFDTRfNoZIjekNehwnFSGQ,13663 +torch/distributed/_shard/__init__.py,sha256=wSp5Aq8q4aICaAb7LZaEZAMtO4EGpRcqWfrF6g9EqWs,108 +torch/distributed/_shard/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/_utils.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/api.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/common_op_utils.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/metadata.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/op_registry_utils.cpython-310.pyc,, +torch/distributed/_shard/__pycache__/sharder.cpython-310.pyc,, +torch/distributed/_shard/_utils.py,sha256=Js6Vzz5BHfpef7wDF_dxFsORwd2UQuhXLKN0XC9ge_A,1104 +torch/distributed/_shard/api.py,sha256=XEj0ZYi_ETuZ98QrfriLZ3JqFaO-NRyJ7dO-BvMLE-k,12271 +torch/distributed/_shard/checkpoint/__init__.py,sha256=svskj1ZwUZ27FZPzkIBS4pI8ltZTmK5KzeAoStn46nY,459 +torch/distributed/_shard/checkpoint/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/common_op_utils.py,sha256=O0sMPoh-LB23x5Z5U-K3BrQr_Liydg4GQSnCNZ9uGBo,2149 +torch/distributed/_shard/metadata.py,sha256=T3wDjBCvO_auXM0j_mF_ZWzkl_LyUfkOrcxGWLtzhgc,2179 +torch/distributed/_shard/op_registry_utils.py,sha256=DSF2gmxl4Fw86qfApPo_aVxjdAAhdy4wco1NtQv5apU,991 +torch/distributed/_shard/sharded_optim/__init__.py,sha256=q0lya6lbOt4HUujeftvTaKyprAKtU_wff9xq4t6RdRM,1857 +torch/distributed/_shard/sharded_optim/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharded_optim/__pycache__/api.cpython-310.pyc,, +torch/distributed/_shard/sharded_optim/api.py,sha256=2RjUcLizDv24wxDf4s9C72kQvy0OhqTDLfIK-RgtiOE,4183 +torch/distributed/_shard/sharded_tensor/__init__.py,sha256=2exL3Uq7BQxI1cOBG8BUdm-tU-_UgBjobqL2_DDi6BQ,19531 +torch/distributed/_shard/sharded_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/api.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/logger.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/logging_handlers.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/metadata.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/reshard.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/shard.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/__pycache__/utils.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__init__.py,sha256=lOaER0hNB_XR9GIjdcKC8HBm2DeHsMsMwVd5MaOzS8I,480 +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/_common.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/binary_cmp.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/init.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/misc_ops.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/__pycache__/tensor_ops.cpython-310.pyc,, +torch/distributed/_shard/sharded_tensor/_ops/_common.py,sha256=ou_e2LqdNlF27bPRlojIdtjy6JC5TSpwGBwLNVJrfTk,4163 +torch/distributed/_shard/sharded_tensor/_ops/binary_cmp.py,sha256=sg29NRj2RGCkoAs1rownzGbMTo8z34mJzBUR5D1HchU,2642 +torch/distributed/_shard/sharded_tensor/_ops/init.py,sha256=jvvLxpYSb7DTKon4Fp67xb_KdM4qStUsY5gtJ9vMtQk,5439 +torch/distributed/_shard/sharded_tensor/_ops/misc_ops.py,sha256=RVT4nwQVP0TqsnL7WqYaMQK2-BEXm2gEHX_Ksv3_b08,478 +torch/distributed/_shard/sharded_tensor/_ops/tensor_ops.py,sha256=o4hJ6gAFoYdtLPAOC4X9mvXWAif5wBatbURfp-TUNE0,7706 +torch/distributed/_shard/sharded_tensor/api.py,sha256=nqWDx04RxyObwB0PZ6kJ-7CiqUL_98QYTbqElOFGjt8,51532 +torch/distributed/_shard/sharded_tensor/logger.py,sha256=uo_Lbobg-lIwEG2r9ArKbK-aGdsgxhwR17nsC-9a9ss,1123 +torch/distributed/_shard/sharded_tensor/logging_handlers.py,sha256=nfWJ7C4I3VkGNoVR9CH5yKIGYxAPa0KC8KQ_KAwFs8Y,388 +torch/distributed/_shard/sharded_tensor/metadata.py,sha256=2994_FwQTkeUeGMzPR7yZXmPSgu1wbk9fG_296t3404,2891 +torch/distributed/_shard/sharded_tensor/reshard.py,sha256=dcvdQAf5QZtT1V-osFoTPHJXI8Qj0Sr4rmfKZkDnnn0,10786 +torch/distributed/_shard/sharded_tensor/shard.py,sha256=VAKw8JT3Zo6_EyUwnIe6ztdBCCVMsD2zq9G4bKBtS-c,2339 +torch/distributed/_shard/sharded_tensor/utils.py,sha256=_Lstt2vDvkZ2lPbxdNmWpU8m64eKF-u6JDUH6HWsMh8,9056 +torch/distributed/_shard/sharder.py,sha256=QbZeSUAbIdVfDUeNZyyy-l8BqbKy8L-UeTa88Ac0RNw,911 +torch/distributed/_shard/sharding_plan/__init__.py,sha256=62qINZKfvhOJgUZf_iRtigeyYCvHpDamhz34lP2rBn8,59 +torch/distributed/_shard/sharding_plan/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharding_plan/__pycache__/api.cpython-310.pyc,, +torch/distributed/_shard/sharding_plan/api.py,sha256=H6lY8HkUJM17qk1iCpAtbOrJ4g7CuaV5umDRIYCCYYA,3664 +torch/distributed/_shard/sharding_spec/__init__.py,sha256=V1cjoJfbIyos11lcp8wpTiE0TadNRzX0UrrELu8PmnM,300 +torch/distributed/_shard/sharding_spec/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/__pycache__/_internals.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/__pycache__/api.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/__pycache__/chunk_sharding_spec.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/_internals.py,sha256=B41BTGXqXzTakFspDTLZpNpGVvFst7IignlRILfYsDk,7917 +torch/distributed/_shard/sharding_spec/api.py,sha256=JbxLr-yBxgQiNi18Uu5eVbAzJobpMJg0c6NBTUMORVc,9764 +torch/distributed/_shard/sharding_spec/chunk_sharding_spec.py,sha256=IgpH_JcYbJC5qR7ijham2VniNQQonaE2-NYCRmpv2Mo,8566 +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/__pycache__/_common.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/__pycache__/embedding.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/__pycache__/embedding_bag.cpython-310.pyc,, +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/_common.py,sha256=viKqDCN-ZC6dx-VV01QbrNKfCixXsebuMtvnSiGOpeo,13046 +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/embedding.py,sha256=3ooqRn3KNnx-jKIf6N986H2bgkiuhLcxdxweF5Q3kLU,11190 +torch/distributed/_shard/sharding_spec/chunk_sharding_spec_ops/embedding_bag.py,sha256=0GbPJFc0M8bVZw3wHjl7BrZgPH1v0OqtX7-ENNjKQ7o,18306 +torch/distributed/_sharded_tensor/__init__.py,sha256=Cq-jPFZ6xzQh8scFJ_hmNYiec2yDCVe5MDoX5efhCTY,484 +torch/distributed/_sharded_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_sharding_spec/__init__.py,sha256=SISl7BpPTUq3ctXbME1sFvVWgS-s07tHKrHQ0abCtcM,520 +torch/distributed/_sharding_spec/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_spmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/_spmd/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/api.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/batch_dim_utils.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/comm_tensor.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/config.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/data_parallel.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/distribute.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/experimental_ops.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/gm_transformation.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/graph_optimization.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/graph_utils.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/iter_graph_module.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/log_utils.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/parallel_mode.cpython-310.pyc,, +torch/distributed/_spmd/__pycache__/partial_lower.cpython-310.pyc,, +torch/distributed/_spmd/api.py,sha256=JBYB3AdnZKxBLi3gzkFUJ6dE3M4U1KB6mrCZwrC0V1k,20991 +torch/distributed/_spmd/batch_dim_utils.py,sha256=4oeiWGmhyp91NSvfD7pHAwcIkXJXtGVSdISY_keSU7o,7896 +torch/distributed/_spmd/comm_tensor.py,sha256=czAtAMUOkEe0fNH6tu7hUBwKTYfYb5nJ1KoXF6dWT6A,10278 +torch/distributed/_spmd/config.py,sha256=zK-jnLX5bAuJOqzFVFVxZfB3jy9jvzp__7VUNKMzGgI,879 +torch/distributed/_spmd/data_parallel.py,sha256=eLvPV0LMgJ6ULN_wtQyuG7SKaNIxNnbSI-26VlUddQQ,37896 +torch/distributed/_spmd/distribute.py,sha256=vH4lc0XFLuS-sADvY9IzW2iJ3Ao9a406AWm1w5QzExg,29823 +torch/distributed/_spmd/experimental_ops.py,sha256=FfK5TFeocxShCAfm_J0VKrYOHuR2ThCE5PbYZ630iqo,17344 +torch/distributed/_spmd/gm_transformation.py,sha256=8fQDvTQaHq8SjeykfgtYb6qKnElbCMNaxcDaIU2xYd8,1829 +torch/distributed/_spmd/graph_optimization.py,sha256=l2Ygi5ILvwjrHYvU6d4XTBD7p74-9XDb5fiBKgY9AUM,37830 +torch/distributed/_spmd/graph_utils.py,sha256=91uExNFiQAt8H7sLuILmMaSyLNz2W9NAfwSc_TeLd7o,4927 +torch/distributed/_spmd/iter_graph_module.py,sha256=7GePQNDwDlJC2sZwFyPNdqLfX4ZeoY6r7_7myC76Mt8,32287 +torch/distributed/_spmd/log_utils.py,sha256=YE3mt9cuj7XNMNqu8tuA-daAL0vXPWN5138aZSNQ8Uw,2344 +torch/distributed/_spmd/parallel_mode.py,sha256=Wkh69iAtVugJqAnwa_k1bNEP9N4aeSDMORFDoJAC004,7956 +torch/distributed/_spmd/partial_lower.py,sha256=dJOmROOHDtDqGybSsIh_OuDaXhK36fFPMS2hqHq16Ww,9899 +torch/distributed/_state_dict_utils.py,sha256=KIvF3AdOeO4PtTqPFEWaihPONc85Dt6d5o4b064nuuU,13531 +torch/distributed/_tensor/__init__.py,sha256=KwmvrtqlErLwJy7jmbUut4vuhLGs3Co1zKXhoWaT13I,13022 +torch/distributed/_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/_collective_utils.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/_utils.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/api.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/device_mesh.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/dispatch.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/op_schema.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/placement_types.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/random.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/redistribute.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/sharding_prop.cpython-310.pyc,, +torch/distributed/_tensor/__pycache__/tp_conv.cpython-310.pyc,, +torch/distributed/_tensor/_collective_utils.py,sha256=X1vDNNpkP5ggKbPr2GssaA5X4z8pavLsf9vzDKVF8LQ,11337 +torch/distributed/_tensor/_utils.py,sha256=vpdbiVjpGGMlsrF_iR_Fm1zIMbGrSfNLHZTkSIGdpCo,8538 +torch/distributed/_tensor/api.py,sha256=og87anwgqrD3Jnx3i2rsbehdNJ6EDrZ85CxNOiRoqRs,33483 +torch/distributed/_tensor/debug/__init__.py,sha256=GFzGZcnjbeA-RSZ6qbUmZWGGoskSRV3G6hFpw-le8gw,515 +torch/distributed/_tensor/debug/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_tensor/debug/__pycache__/comm_mode.cpython-310.pyc,, +torch/distributed/_tensor/debug/__pycache__/op_coverage.cpython-310.pyc,, +torch/distributed/_tensor/debug/__pycache__/visualize_sharding.cpython-310.pyc,, +torch/distributed/_tensor/debug/comm_mode.py,sha256=fGg8c1dalFYwTTbCuM_ExgQWBemMYVxder02h2yoGkE,3375 +torch/distributed/_tensor/debug/op_coverage.py,sha256=NwEM8DY_CdLdbxZYnCvikepoStKB7Iub-7rAX6AxKnQ,3141 +torch/distributed/_tensor/debug/visualize_sharding.py,sha256=8wLXPPdDf-DDQkxczAqXbb90IVqPpTAWhCpd_G48sDk,6412 +torch/distributed/_tensor/device_mesh.py,sha256=UvmlUwYHy1bh-FyCVUtUPgVZoGJVmoWTl7EjzhW86HE,143 +torch/distributed/_tensor/dispatch.py,sha256=HucalhPfLpPnRPsOoXDfZwaInLlvRffSCFJBw63ijDY,16454 +torch/distributed/_tensor/experimental/__init__.py,sha256=ebnEt2sImqpYMai7lv5KVdpOYPX8vrzuF47_wuzmncQ,304 +torch/distributed/_tensor/experimental/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_tensor/experimental/__pycache__/tp_transform.cpython-310.pyc,, +torch/distributed/_tensor/experimental/tp_transform.py,sha256=mW0AClFL63XC6nXWP8whQQfCipTVasLAIhDw4PZRGl8,19901 +torch/distributed/_tensor/op_schema.py,sha256=kYmROBVve51MiekhK9OA-dZGbkEZjT8D2Wc0d_s3OIY,15976 +torch/distributed/_tensor/ops/__init__.py,sha256=FpW_UGJUbqKHEfm8S54cNEQseoKya4eRbZ50yEOQTQo,418 +torch/distributed/_tensor/ops/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/basic_strategy.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/common_rules.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/conv_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/embedding_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/experimental_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/math_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/matrix_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/pointwise_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/random_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/tensor_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/utils.cpython-310.pyc,, +torch/distributed/_tensor/ops/__pycache__/view_ops.cpython-310.pyc,, +torch/distributed/_tensor/ops/basic_strategy.py,sha256=da-47gJ26LUhTC1rW7jLdOB-EJx6O-Hx6GyuXUx1pGQ,6660 +torch/distributed/_tensor/ops/common_rules.py,sha256=ZQnRoDPPH1Gppo7-hRs_kmu0gn1QERHqCzeR1sN2wkk,12120 +torch/distributed/_tensor/ops/conv_ops.py,sha256=_xhAlmlQY7po2Tq2MMn11hLSKcr1S4DRfSErClN0qCs,3290 +torch/distributed/_tensor/ops/embedding_ops.py,sha256=LguQIhWpg1xQxYc4tJnKfyAfwZO3KDzqg8jc8vIW1-o,11823 +torch/distributed/_tensor/ops/experimental_ops.py,sha256=RviWWangdj5TrEw41Lx8COBCiMsUFIc4NvUDfKl_PyI,1641 +torch/distributed/_tensor/ops/math_ops.py,sha256=90MR8NpRge1sZnFNdIt-K_J_kYuyWVkV7_fWPfgGtv8,36903 +torch/distributed/_tensor/ops/matrix_ops.py,sha256=629O4uPTd7QzGNygHln_yChXRVQxRI1T2-Ep90MnE-k,8635 +torch/distributed/_tensor/ops/pointwise_ops.py,sha256=K4wDFLnFC5msSo0LVcbOCB3wu_Ey9JqgUGAVZDv6KO4,18978 +torch/distributed/_tensor/ops/random_ops.py,sha256=ougCOujWUYoJCiA5EK_zRCzOComSviN2TsdDRACG2B4,1086 +torch/distributed/_tensor/ops/tensor_ops.py,sha256=Mtu3kv3jbGdaC6lBxfOmnv-_U-Wr8geSvwp2ru2omf8,32008 +torch/distributed/_tensor/ops/utils.py,sha256=ISBjydW0Z3Cdv5k8r-ACS6JXbLXdifx5oeXPtpdX_h8,8130 +torch/distributed/_tensor/ops/view_ops.py,sha256=uR79fsk4KE7B5zK9r3nKBGSMkFpIHNoDiqun7AW_9Rg,24717 +torch/distributed/_tensor/placement_types.py,sha256=dzwHSX8dLxzPdjUr_z3fJQjxz5THMfWTVd4BqKrDHzE,22232 +torch/distributed/_tensor/random.py,sha256=jSug5kPDIn0TT82byJe02_AfQhNJur-FVeTuHLkh4C4,15629 +torch/distributed/_tensor/redistribute.py,sha256=BJ1ciJoJsqrlVHIagAstRPKxmAMU9cbO030rP5GZXRM,13372 +torch/distributed/_tensor/sharding_prop.py,sha256=67sW1RspgWhRHBoJydXOoPzpRJ6XQS_foJZZooRZiYs,18482 +torch/distributed/_tensor/tp_conv.py,sha256=0BFvujfRtwGefb-Hb7-gI0061aAB0aT5dlzBnnonfWQ,10137 +torch/distributed/_tools/__init__.py,sha256=d46iFLG9j3jN7HZkwEu99Wt9svzuP-wmZtpZEl7g5cg,42 +torch/distributed/_tools/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/_tools/__pycache__/memory_tracker.cpython-310.pyc,, +torch/distributed/_tools/memory_tracker.py,sha256=zCrOEUR-aOJoTbNDlJQlYlFi2V81xcwWbCrl5OLbfgA,11439 +torch/distributed/algorithms/__init__.py,sha256=FSx7ffbFnhrQvyCoO261CVdljZDFcjnCduv6eiZHqFE,77 +torch/distributed/algorithms/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/__pycache__/join.cpython-310.pyc,, +torch/distributed/algorithms/_checkpoint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/algorithms/_checkpoint/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/_checkpoint/__pycache__/checkpoint_wrapper.cpython-310.pyc,, +torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py,sha256=bJLNQyKIBUTQripHJTQfudGsEnAa27smh2Frrd46YIY,12155 +torch/distributed/algorithms/_comm_hooks/__init__.py,sha256=4jm0yFOaLYG7lA-2gV2vvGlvcZj3SlBFU7p6EtgfIUE,131 +torch/distributed/algorithms/_comm_hooks/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/_comm_hooks/__pycache__/default_hooks.cpython-310.pyc,, +torch/distributed/algorithms/_comm_hooks/default_hooks.py,sha256=8PV7G7Vxr85YL79KqeT717XAC3zl07x8HYLx9mB_31o,7138 +torch/distributed/algorithms/_optimizer_overlap/__init__.py,sha256=zuKlfE0DcQCZm0av9HrJZfXH6R5AzV2K3xrEAAgoVsk,52 +torch/distributed/algorithms/_optimizer_overlap/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/_optimizer_overlap/__pycache__/optimizer_overlap.cpython-310.pyc,, +torch/distributed/algorithms/_optimizer_overlap/optimizer_overlap.py,sha256=RzR3T19mKiLResEho623UcPHQfZcKtg7YXNYjImvWb8,3723 +torch/distributed/algorithms/_quantization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/algorithms/_quantization/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/_quantization/__pycache__/quantization.cpython-310.pyc,, +torch/distributed/algorithms/_quantization/quantization.py,sha256=WbKyBchJpyH-vqWs2nMQqQcwe4y9bEHYZ9lFv6Ydn88,5560 +torch/distributed/algorithms/ddp_comm_hooks/__init__.py,sha256=ZtDBe6YLbUa5evxIg_cxVdbrWBJ-LqOxb1cGPy8DmDo,3566 +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/ddp_zero_hook.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/debugging_hooks.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/default_hooks.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/mixed_precision_hooks.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/optimizer_overlap_hooks.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/post_localSGD_hook.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/powerSGD_hook.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/__pycache__/quantization_hooks.cpython-310.pyc,, +torch/distributed/algorithms/ddp_comm_hooks/ddp_zero_hook.py,sha256=TfE1QVkEEZdzuRN0PYySy0wlZ_go1JLjTPAUi6uQD9s,19537 +torch/distributed/algorithms/ddp_comm_hooks/debugging_hooks.py,sha256=Iz6pC-X8bzevET3sdTfpzNzuV4ersJe1pJWYsfryDWI,1114 +torch/distributed/algorithms/ddp_comm_hooks/default_hooks.py,sha256=yk6SOF9FQcQmQ6IsNqG69sgDhjQo-iMJ6y32Nj85ok0,8596 +torch/distributed/algorithms/ddp_comm_hooks/mixed_precision_hooks.py,sha256=5vWhvKgKb19_DRo8Awia72sx_GgVtkq3oSV3aODdOHw,3395 +torch/distributed/algorithms/ddp_comm_hooks/optimizer_overlap_hooks.py,sha256=hLmpqphzgvczv57ZpaF3lNqLszFABQaUm1DXq1XQWA0,6075 +torch/distributed/algorithms/ddp_comm_hooks/post_localSGD_hook.py,sha256=p3Kg_9YCP6hL07weCUBJRvEyRvM1q9DjtTohMfguYfE,5125 +torch/distributed/algorithms/ddp_comm_hooks/powerSGD_hook.py,sha256=b80qcEeFML5d1V6rIN-KnE3KqiX1APoPKnNKOL2dm54,40234 +torch/distributed/algorithms/ddp_comm_hooks/quantization_hooks.py,sha256=RlFhvn1qWealyshNO4XXVpYXI8886GBwGc6lKyQhbMk,8197 +torch/distributed/algorithms/join.py,sha256=Sf0Uv_1_gDeySyO59P81AYf14--WNlTF_Z7bqdyD-Lc,13348 +torch/distributed/algorithms/model_averaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/algorithms/model_averaging/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/algorithms/model_averaging/__pycache__/averagers.cpython-310.pyc,, +torch/distributed/algorithms/model_averaging/__pycache__/hierarchical_model_averager.cpython-310.pyc,, +torch/distributed/algorithms/model_averaging/__pycache__/utils.cpython-310.pyc,, +torch/distributed/algorithms/model_averaging/averagers.py,sha256=hEWYXC5qCEUAfihC3b_8z1Actp7CS4MvDG8h4WsSf9w,5199 +torch/distributed/algorithms/model_averaging/hierarchical_model_averager.py,sha256=kIwXUA8C_-X-twgXgmbe74ikT88MIx8gDhEzoNad95A,9607 +torch/distributed/algorithms/model_averaging/utils.py,sha256=anTRZAoeUupQ-qB31kpZVRVFUsM9Hc81x3LDuIOYTM0,3016 +torch/distributed/argparse_util.py,sha256=oWox_n1Q1klcI0pVrglWF8bZkUSY-AhngRe3dQ_0RuA,3876 +torch/distributed/autograd/__init__.py,sha256=DAXK0mG7CBW37subs8YuTkj__mT3Vjx90Y6KOR6zNXA,1630 +torch/distributed/autograd/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/c10d_logger.py,sha256=1WURiyGtZz891AswUn5Qf1B0k8qlm8szB95qPoxejY0,3163 +torch/distributed/checkpoint/__init__.py,sha256=rNUjRpz3AN1wWwsv7WsyevndzfpyL722GyAjiGUKbXA,641 +torch/distributed/checkpoint/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_dedup_save_plans.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_dedup_tensors.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_fsspec_filesystem.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_nested_dict.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_sharded_tensor_utils.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_storage_utils.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/_traverse.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/api.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/default_planner.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/filesystem.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/format_utils.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/fsspec.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/metadata.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/optimizer.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/planner.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/planner_helpers.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/resharding.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/state_dict.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/state_dict_loader.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/state_dict_saver.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/stateful.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/storage.cpython-310.pyc,, +torch/distributed/checkpoint/__pycache__/utils.cpython-310.pyc,, +torch/distributed/checkpoint/_dedup_save_plans.py,sha256=HJu6xB0_pZYbFp4pfQgf84Y97rAf5d2tnIpsgbwJgn0,2125 +torch/distributed/checkpoint/_dedup_tensors.py,sha256=AyDDS29wtRDOy81yhgOy7uGau4JYQ05o_DR-isuhze0,1964 +torch/distributed/checkpoint/_fsspec_filesystem.py,sha256=3OVZgBHgPWt78UNIDyrbhF3_lP37kaI-cPifmL4lAu0,394 +torch/distributed/checkpoint/_nested_dict.py,sha256=j46dN7WEKAw2YV461gDlBFrV1sOnlgWjvVI1vlxKit8,1816 +torch/distributed/checkpoint/_sharded_tensor_utils.py,sha256=cY_XDoHVJpXFu7UynZHroDXtPS0miOwoxRbF7MrVYQw,4087 +torch/distributed/checkpoint/_storage_utils.py,sha256=JAhmVhuxSQkWZtfYA3QwhgGTKuC_uqIpDIxfxMcewkc,1410 +torch/distributed/checkpoint/_traverse.py,sha256=5OA1cGEAfHMNcYnAxrh-khcf5xvBBEeI8NmWeZHvHfA,5458 +torch/distributed/checkpoint/api.py,sha256=dl8sh0jpp-j466ubVde66ByzMrf9c59ZTqzFhWOG9NI,1422 +torch/distributed/checkpoint/default_planner.py,sha256=BLzoPzjTFOOxlesRwfyGMgp44kTUseX77eCsaqxWdko,14875 +torch/distributed/checkpoint/filesystem.py,sha256=0_yvXu9Dc4tsD8N_E09ml9pH_Gi1oIzmmPeBRiWxZ90,20401 +torch/distributed/checkpoint/format_utils.py,sha256=9AIDTn6nyAeqcGB3HoIL0Gk-yHl6qMwgSiC2HC20RSg,11309 +torch/distributed/checkpoint/fsspec.py,sha256=60ssam5rvMx4dYzNPtXc-DnXxbtIpxMtlD_o3U1YIo4,3805 +torch/distributed/checkpoint/metadata.py,sha256=YHC3qD0be57Zrl_Fa5okdtRpBOxa3xHXocmkAhL0dzI,5269 +torch/distributed/checkpoint/optimizer.py,sha256=MK_bXX_Y_q1e_OGLTZ4FWEaHx-1lVbf4wHy8-DoX52s,12965 +torch/distributed/checkpoint/planner.py,sha256=AVrboPVLE-lJmuHs-gvIhk5G1k6joGDNCkdGdCWUMAc,14123 +torch/distributed/checkpoint/planner_helpers.py,sha256=UDpjcXapIoA-wA4tsPefp0EkKTZGLXhzYdq4fdu278c,10989 +torch/distributed/checkpoint/resharding.py,sha256=Zu9WPSUnNmKiOOaj1vzunFzvoQMKnJKVgu-vbCgwtKI,2298 +torch/distributed/checkpoint/state_dict.py,sha256=l4T92qa2G4jWmpIfCrKJA27mT9rTF-nyTpokeTG5Zdk,39353 +torch/distributed/checkpoint/state_dict_loader.py,sha256=wa1mPe4W-LlzkNoTt5VzzBkif38KZ8MG4cwuTl-Kt40,8045 +torch/distributed/checkpoint/state_dict_saver.py,sha256=U_cJS5MZRGcTEO8fgCSwQoJ76mvXLOA1vJxB17cxmzw,10564 +torch/distributed/checkpoint/stateful.py,sha256=9w0B6EryuHplc__TUjisn_ZHf9NbdyENLcUtjyZB5Is,1068 +torch/distributed/checkpoint/storage.py,sha256=xYHhrvtM-0AtMBKHc1Qukq3Zd5IJ1x1zpT384NVNtd4,9355 +torch/distributed/checkpoint/utils.py,sha256=7OoH-HROJNL7DbbrtAYegqhmOGNTWibfFjSSPfgxGv8,14360 +torch/distributed/collective_utils.py,sha256=nzzr9rddeLevK0e_pv1fvZyBekQLT3OF2AcKPNPKbZ8,7250 +torch/distributed/constants.py,sha256=B1TcHTtqsrH_766_aUv-HmXvT22yUWdufw9brUEtgzg,1226 +torch/distributed/device_mesh.py,sha256=QfCJ6-fqujCh162aRb9A_qNWlC0k-65rV4NAM0cFF9o,25248 +torch/distributed/distributed_c10d.py,sha256=7j60TMw6doU0aR0byJVlGS0CRbv1RS3O3fvkzkeb0FY,171247 +torch/distributed/elastic/__init__.py,sha256=QMPilFK2QkDj895i4fqrtE5bzyO55GJkV4t4EM_1Qzw,3654 +torch/distributed/elastic/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/elastic/agent/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/agent/server/__init__.py,sha256=p6OmZ3UC2RN276H3JLUZm0ygZ1GBWRcOOq4OQwozTo4,1401 +torch/distributed/elastic/agent/server/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/agent/server/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/agent/server/__pycache__/local_elastic_agent.cpython-310.pyc,, +torch/distributed/elastic/agent/server/api.py,sha256=zvJrNZeISteG9jMoPd-tWQ8w17VuXcjEhWE0kOUn1TY,36655 +torch/distributed/elastic/agent/server/local_elastic_agent.py,sha256=QuK9Z1uYpcv0PGlEsGTz2jx63bKH1bgsZkEATKSlxwY,14011 +torch/distributed/elastic/events/__init__.py,sha256=HUVFeUQqsNLVe_Gtp4GiSKXk-oudJ5qIPuhE8M746sk,3933 +torch/distributed/elastic/events/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/events/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/events/__pycache__/handlers.cpython-310.pyc,, +torch/distributed/elastic/events/api.py,sha256=YXyL0pdALLzHDETX4wZDECjzw9vQH2rytP0RXsgPANU,3225 +torch/distributed/elastic/events/handlers.py,sha256=MZLZ2QRkTo6n_XZq-9NY8cSPjOjJoPyfs3grPOLigIc,580 +torch/distributed/elastic/metrics/__init__.py,sha256=xYiClK41CDB1cK4NSqjqNPCC4TPGyVvDsLJqChs5Kns,4853 +torch/distributed/elastic/metrics/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/metrics/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/metrics/api.py,sha256=0J_rIiy9M3_THJPXh1FZGGSU7_yIu-JA2Avb8SBe_CA,5578 +torch/distributed/elastic/multiprocessing/__init__.py,sha256=uIOj0Ioi0YFW2t54t5UsJC37_M-vDCj4id0HfsxD44g,7459 +torch/distributed/elastic/multiprocessing/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/__pycache__/redirects.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/__pycache__/tail_log.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/api.py,sha256=ATON0veLS3TDMgBEfXa6GX8BDL11ANZztqumLPM6fOg,32545 +torch/distributed/elastic/multiprocessing/errors/__init__.py,sha256=FqJffvDEkqQopu-LEV3_WSZrSZOYUar1TZ4ZwkJPibw,14263 +torch/distributed/elastic/multiprocessing/errors/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/errors/__pycache__/error_handler.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/errors/__pycache__/handlers.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/errors/error_handler.py,sha256=ag_ceAEWG26fjh9PanypfBbQI5DKZxITGIbjIHSDzDI,6464 +torch/distributed/elastic/multiprocessing/errors/handlers.py,sha256=lzVFjdwD0zNLMO4IHJQkwj0DnYoapEb1l_7c6xQzC00,446 +torch/distributed/elastic/multiprocessing/redirects.py,sha256=JVaedTer58eMpuvEnfticr1wzUqwmCovPm21yVRySBE,2736 +torch/distributed/elastic/multiprocessing/subprocess_handler/__init__.py,sha256=2UH2P5DnqmbJD9Rw8m7qGLkSIEj_Q4qQRASk-1L1xPI,522 +torch/distributed/elastic/multiprocessing/subprocess_handler/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/subprocess_handler/__pycache__/handlers.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/subprocess_handler/__pycache__/subprocess_handler.cpython-310.pyc,, +torch/distributed/elastic/multiprocessing/subprocess_handler/handlers.py,sha256=6W9OkP4g5TZ3vJVMUtHnoRl5KNggh9oF00sK9jcqqJM,759 +torch/distributed/elastic/multiprocessing/subprocess_handler/subprocess_handler.py,sha256=-i9PZMMwnwNkP8syEQ-xeyCzL5RR4fJvww66y3Ntjt8,2429 +torch/distributed/elastic/multiprocessing/tail_log.py,sha256=r8t7cUaSp6MvgQtzri57MeZplDpjcPOn1mv5ULImm_s,4848 +torch/distributed/elastic/rendezvous/__init__.py,sha256=6YCR77ZGpthjHi5LPBBgUQD7oTXcFkLkt3FAQW1_64U,5851 +torch/distributed/elastic/rendezvous/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/c10d_rendezvous_backend.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/dynamic_rendezvous.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/etcd_rendezvous.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/etcd_rendezvous_backend.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/etcd_server.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/etcd_store.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/registry.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/static_tcp_rendezvous.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/__pycache__/utils.cpython-310.pyc,, +torch/distributed/elastic/rendezvous/api.py,sha256=aaOb0eEhZTZKK6V1u0FSuR4LH0ix0QpBDF28Qyc34J4,9390 +torch/distributed/elastic/rendezvous/c10d_rendezvous_backend.py,sha256=KmYEEhs6hhAJvNfYy5dUg-C0QFI-8nk__xyzbFJhqww,10830 +torch/distributed/elastic/rendezvous/dynamic_rendezvous.py,sha256=_OuKnZzmOpyTEwVa4jrTG1tyjiauqCM1BDe8OUV0Os4,45470 +torch/distributed/elastic/rendezvous/etcd_rendezvous.py,sha256=XDnn9B5U2VLGmG13gezFCwfRRRVg9nRhPwt3da-sWj4,42583 +torch/distributed/elastic/rendezvous/etcd_rendezvous_backend.py,sha256=rDZewdk7NNTQ0CPXHBuH7OZ3hkcMnWK4Ge3iO28RcC4,7407 +torch/distributed/elastic/rendezvous/etcd_server.py,sha256=hS62lXSmDmJHHbeyc4-kGF8zM-3JS_QIju31d_mFpSE,8388 +torch/distributed/elastic/rendezvous/etcd_store.py,sha256=dR2RJPFX45B7DtYawZ7AdETbnt7BTOvQ5Ib3CV1Kvgg,6927 +torch/distributed/elastic/rendezvous/registry.py,sha256=w5XlCcQdE3Vuojo3qJsmJyqdydTYeOMOpbTmIcxHA5Q,2233 +torch/distributed/elastic/rendezvous/static_tcp_rendezvous.py,sha256=0Vv2R-TdBb_vo_Jm8cbh1IhbWjDkYPw-hN8YGflYlGw,3287 +torch/distributed/elastic/rendezvous/utils.py,sha256=EWKKEPuT1_ft7yGwr2MHfh6bFj4KlwKZCWJ8hi0B1rU,8355 +torch/distributed/elastic/timer/__init__.py,sha256=GYolVqGTBcFKb-3J1qBNs_57oS_hinySSCymd2hRryk,1708 +torch/distributed/elastic/timer/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/timer/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/timer/__pycache__/file_based_local_timer.cpython-310.pyc,, +torch/distributed/elastic/timer/__pycache__/local_timer.cpython-310.pyc,, +torch/distributed/elastic/timer/api.py,sha256=1OxqrLAPNCa2gJx4MSIEg1Tj4VXDPuraMi80JZksm9I,9609 +torch/distributed/elastic/timer/file_based_local_timer.py,sha256=LJTEc4Z_syVnUvPGl3wwQkQfufR2OCXg05h_f13SP_w,13447 +torch/distributed/elastic/timer/local_timer.py,sha256=NiYJD3rBsavtpqVBFCqy0DU6cIpz4q-UE9uWQ2HnDr0,4273 +torch/distributed/elastic/utils/__init__.py,sha256=ztvtzgzf5pR1ixbbYfY0lGx85VhyhJuHH8er7-XNVpE,318 +torch/distributed/elastic/utils/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/utils/__pycache__/api.cpython-310.pyc,, +torch/distributed/elastic/utils/__pycache__/distributed.cpython-310.pyc,, +torch/distributed/elastic/utils/__pycache__/log_level.cpython-310.pyc,, +torch/distributed/elastic/utils/__pycache__/logging.cpython-310.pyc,, +torch/distributed/elastic/utils/__pycache__/store.cpython-310.pyc,, +torch/distributed/elastic/utils/api.py,sha256=AbWf1QIenzn9YVkPrRZispFc61jhf-LvRWawFCMya5s,1716 +torch/distributed/elastic/utils/data/__init__.py,sha256=tF96JUuxZmWRkvGOzP7tbZT6s8CKNz29F6O_OYTcL3o,372 +torch/distributed/elastic/utils/data/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/elastic/utils/data/__pycache__/cycling_iterator.cpython-310.pyc,, +torch/distributed/elastic/utils/data/__pycache__/elastic_distributed_sampler.cpython-310.pyc,, +torch/distributed/elastic/utils/data/cycling_iterator.py,sha256=FIzrgqtQWfwvXlWgsEJN-2AqkNA1lDjNIUR3Jg7bAIk,1376 +torch/distributed/elastic/utils/data/elastic_distributed_sampler.py,sha256=8BcZnx3Kj-89LlQ8oDbbLCXInsQtasJIf5IZir2XK54,2456 +torch/distributed/elastic/utils/distributed.py,sha256=H8AB8Lhdy8WhgX7F3OGnKf2s-g9bp1hl_FxsBFjx-_4,4639 +torch/distributed/elastic/utils/log_level.py,sha256=1pOw0YanV5aPrMGwqkATk8OTXm6iLF2iuUYKbUf1b6Q,339 +torch/distributed/elastic/utils/logging.py,sha256=LTd0wNSQeQAzUYrHtriefdjOEmDojIoeL0IjOqXGxSE,2226 +torch/distributed/elastic/utils/store.py,sha256=dI6JCBW2WN74BuRtO5ZG-jbY0aqctVXvhXJQBDRtagk,2495 +torch/distributed/fsdp/__init__.py,sha256=E6Efha39xJvdMn-5MFP7pBf9ITWCqfRRaNym7dvfYrc,938 +torch/distributed/fsdp/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_common_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_debug_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_dynamo_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_exec_order_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_flat_param.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_fsdp_extensions.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_init_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_limiter_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_optim_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_runtime_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_shard_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_state_dict_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_trace_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_traversal_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_unshard_param_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/_wrap_utils.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/api.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/fully_sharded_data_parallel.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/sharded_grad_scaler.cpython-310.pyc,, +torch/distributed/fsdp/__pycache__/wrap.cpython-310.pyc,, +torch/distributed/fsdp/_common_utils.py,sha256=7PZmbiPnsuB0mw1I7CQ6_B_c-SLP2X8-TBgyAYtS4yU,23082 +torch/distributed/fsdp/_debug_utils.py,sha256=HpN9I5SHEDI4CGJMkph3D0HQbdEX40bgObsLXh2iWfY,5681 +torch/distributed/fsdp/_dynamo_utils.py,sha256=wFowGHvceCtXMrE-BPUgt9JoO1mFX6sue4B1Ny5c0Qc,2647 +torch/distributed/fsdp/_exec_order_utils.py,sha256=dr_tpjZjBo331YSPaUelp8CHP9ZPoNUY3q2t6z4Kpuo,16095 +torch/distributed/fsdp/_flat_param.py,sha256=s31NnWIKnvD3sKsHjwzJmMpWWFwepv9247dDmkrPbiI,120394 +torch/distributed/fsdp/_fsdp_extensions.py,sha256=UIEZ9Yn58M0Hkpx-jdARqzISbqQGEodX2mHwOYwJOzY,4970 +torch/distributed/fsdp/_init_utils.py,sha256=gVAk-HoNHRf88I3EHKD9ikpMZgFm7WyPXzaJsGdjTHc,45612 +torch/distributed/fsdp/_limiter_utils.py,sha256=DHelPE9Dk2OSuSW_i4xogTRUV6_rK95A2VOWBS8fOYg,1101 +torch/distributed/fsdp/_optim_utils.py,sha256=2mneKijBSXSODQd7qGLFocyyHWH37YTRGJXy2cdzaVA,86802 +torch/distributed/fsdp/_runtime_utils.py,sha256=l740xrldbUwN0r8XVQieJQ4JKslvPQzxq2WU-oFhA7Q,65940 +torch/distributed/fsdp/_shard_utils.py,sha256=qElc8v739SSZ3iwkXPQcREFq37O3KFx40jXQ-1Yt_6U,4266 +torch/distributed/fsdp/_state_dict_utils.py,sha256=3xXOHMjjnLF5y47vj9ZbwE0ahx2OnIlANVjWYlgNcGI,34211 +torch/distributed/fsdp/_trace_utils.py,sha256=KJWJAxVHpF3UBBHjl4CXDDHR_NYHUNl_4UVAetK3TYI,10576 +torch/distributed/fsdp/_traversal_utils.py,sha256=scEaKCmS4eUIOs0nUEDDAE5C23BPi8eSsNF5ngQ_yVE,4641 +torch/distributed/fsdp/_unshard_param_utils.py,sha256=bYs5hdMwt-Z9yXYWdeg8eeB-35t5Fgh_47l4Tkg8yAg,12415 +torch/distributed/fsdp/_wrap_utils.py,sha256=qlKsQeb8v-yYTWoBuNUoQEfFoyA_OP-ICVLLpYO0RTk,10899 +torch/distributed/fsdp/api.py,sha256=WUsu5jwRQ6R3Tci0tWOAczmXXmIM5XLqFEOpHGQRtIw,18880 +torch/distributed/fsdp/fully_sharded_data_parallel.py,sha256=srfJgxecjGT5hL5Isg-NGQxKuGBduFccNckXzIEKgT4,96487 +torch/distributed/fsdp/sharded_grad_scaler.py,sha256=VdqS1n8n-CJJW6vpKqZ_J0HVIaSXF_g736V2JsJCjZw,17416 +torch/distributed/fsdp/wrap.py,sha256=25f9KKZFrB42nKn9eo9U_QSIMHppm8tsNCdVs1TR-yk,22604 +torch/distributed/launch.py,sha256=-laDh_mwMHFTJsuCqjfKGIBPxD9cZCb4DW_4n0eU9_4,6909 +torch/distributed/launcher/__init__.py,sha256=6_8OrtT4YsaDG4MGEH2I8TXcokQQZKyYkahGOFRUYFg,349 +torch/distributed/launcher/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/launcher/__pycache__/api.cpython-310.pyc,, +torch/distributed/launcher/api.py,sha256=ofopELpbVJLRhGFxz3rtkx0tKTuI3DTClXj4COI2vd8,10935 +torch/distributed/logging_handlers.py,sha256=nfWJ7C4I3VkGNoVR9CH5yKIGYxAPa0KC8KQ_KAwFs8Y,388 +torch/distributed/nn/__init__.py,sha256=CDVu-SnwRQGyzKp37_uPHzbCAHA8amiVLyuGgTVYxyM,142 +torch/distributed/nn/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/nn/__pycache__/functional.cpython-310.pyc,, +torch/distributed/nn/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/nn/api/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/nn/api/__pycache__/remote_module.cpython-310.pyc,, +torch/distributed/nn/api/remote_module.py,sha256=VfuUy5uFFl3QYS8W8k7D4QqfpHfnjJkyyFoymj2QB1I,31226 +torch/distributed/nn/functional.py,sha256=pSJdeXRRUp5aaRKbgkjmIczBU-3FoH9qJUOo6yOtpYE,15064 +torch/distributed/nn/jit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/nn/jit/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/nn/jit/__pycache__/instantiator.cpython-310.pyc,, +torch/distributed/nn/jit/instantiator.py,sha256=G_EPpXxv2xDSUnWAPrRARA9vTjiDHPZu8C_pJ_FcrGU,5432 +torch/distributed/nn/jit/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/nn/jit/templates/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/nn/jit/templates/__pycache__/remote_module_template.cpython-310.pyc,, +torch/distributed/nn/jit/templates/remote_module_template.py,sha256=Z5hWZ8FT3qw9twQIRhAaP5LedD947B37fdhO7WjvtLA,3436 +torch/distributed/optim/__init__.py,sha256=Vp2hCs2X2TQRozflDNwJhNKYJ5FZqJYZcY5OYvIHhT0,1292 +torch/distributed/optim/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/optim/__pycache__/apply_optimizer_in_backward.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_adadelta.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_adagrad.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_adam.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_adamax.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_adamw.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_rmsprop.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_rprop.cpython-310.pyc,, +torch/distributed/optim/__pycache__/functional_sgd.cpython-310.pyc,, +torch/distributed/optim/__pycache__/named_optimizer.cpython-310.pyc,, +torch/distributed/optim/__pycache__/optimizer.cpython-310.pyc,, +torch/distributed/optim/__pycache__/post_localSGD_optimizer.cpython-310.pyc,, +torch/distributed/optim/__pycache__/utils.cpython-310.pyc,, +torch/distributed/optim/__pycache__/zero_redundancy_optimizer.cpython-310.pyc,, +torch/distributed/optim/apply_optimizer_in_backward.py,sha256=rkhwDr-87m5DExg6DCbcmUwAgxFdHjynPa_Ojaz-kUU,5184 +torch/distributed/optim/functional_adadelta.py,sha256=C_TTlsi9cfKmxDBIwS2BB7S4FCpVqBtFRQvYGnOpvUE,3643 +torch/distributed/optim/functional_adagrad.py,sha256=QYjWJsCmcKBud5spNfPoVjRAZnzIlzrzuwnKQRA7sPM,3943 +torch/distributed/optim/functional_adam.py,sha256=42O8RZL_R_c4UXWhGhQgTQ0J8_uYHF7LCBq9rDhXleg,7226 +torch/distributed/optim/functional_adamax.py,sha256=qq7pP9_parnr_W3smeKD-gXcSR0YrpbwXv4vhwSDxKA,4452 +torch/distributed/optim/functional_adamw.py,sha256=_IOmcxC7C6sA6m7R1q9QJErxKN0xISB6NM0aKEmDAJA,7346 +torch/distributed/optim/functional_rmsprop.py,sha256=hSXooxo6vjoFDgdV3zrw-GZAlsvaoT5oIZ0L2u87ltQ,4409 +torch/distributed/optim/functional_rprop.py,sha256=5Qd-wB7hYJpOSOKvztIfn0JHUzOjc3fmw6_pmniw5CY,3571 +torch/distributed/optim/functional_sgd.py,sha256=d3YGUJpcbAnG2HAkyaB98ENdaTmbjvnBWB6Ba6hQMNE,5732 +torch/distributed/optim/named_optimizer.py,sha256=_r573-uQEAYfhU6lVDW-thh6Q6aod70WQhi_LeRhiF0,13966 +torch/distributed/optim/optimizer.py,sha256=SGqcIz2WKu7Ui2sxPwFjWKgSZo2psjejh6nf20QcPdw,9799 +torch/distributed/optim/post_localSGD_optimizer.py,sha256=FIO63LwKfxAhdas7KiFjn8HI4VGcxmU7mM6WvdZEqrU,4387 +torch/distributed/optim/utils.py,sha256=tgS4YK47bg62nU033cFK7PREgHdK7SspF3iPqN_j5ig,2237 +torch/distributed/optim/zero_redundancy_optimizer.py,sha256=fMdi7AtUGUosc2I4HEH7UhxIrBvP6MNKFQqrH4bvB2A,71905 +torch/distributed/pipeline/__init__.py,sha256=7p2YP6nqWtFyeKjbjREkTC5hwOJ3GaSpESMIoWK9UoY,285 +torch/distributed/pipeline/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/pipeline/sync/__init__.py,sha256=uhP_i4WFCSNOnHd8ZNss8XVDX2VSMexbuzHrORvdXAI,451 +torch/distributed/pipeline/sync/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/batchnorm.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/checkpoint.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/copy.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/dependency.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/microbatch.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/phony.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/pipe.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/pipeline.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/stream.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/utils.cpython-310.pyc,, +torch/distributed/pipeline/sync/__pycache__/worker.cpython-310.pyc,, +torch/distributed/pipeline/sync/_balance/__init__.py,sha256=kyd1b1tK5iU57JeJ_exCkDlF33noUq2ePBWPfAPM45s,5316 +torch/distributed/pipeline/sync/_balance/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/pipeline/sync/_balance/__pycache__/blockpartition.cpython-310.pyc,, +torch/distributed/pipeline/sync/_balance/__pycache__/profile.cpython-310.pyc,, +torch/distributed/pipeline/sync/_balance/blockpartition.py,sha256=t0zBDjTHzFcrUqgyKKCHyrSrTAZPuiM66q28U66XfZQ,3161 +torch/distributed/pipeline/sync/_balance/profile.py,sha256=l0Fa3C7zRxyypCH-CftV6YeyUf52i74Mcj_lva8l_oA,3641 +torch/distributed/pipeline/sync/batchnorm.py,sha256=hoeOE3Rvjt6NMzk6s-5aBFwmXZ3W1buSfnv113dJizo,5565 +torch/distributed/pipeline/sync/checkpoint.py,sha256=xCjcEffR_C00q4M9IXpE7d7n75E67d3STLZe7rjf8KU,11675 +torch/distributed/pipeline/sync/copy.py,sha256=xoEk7yUwRTsyoC1rWSRQUvMCiwpD0eXDMICb9CQ-Aeg,3742 +torch/distributed/pipeline/sync/dependency.py,sha256=kkgsCnPpymlRBFIn0II4k7yElb63F09l9qXOLZ6-iNI,1723 +torch/distributed/pipeline/sync/microbatch.py,sha256=fOahRulgcFvCFFH3Dvswg_BCmOS5ZS5zbMrVzjXoRSI,7481 +torch/distributed/pipeline/sync/phony.py,sha256=945WRixiRATTIO02UJYWGl4FmCd08OtRH4b_ydEle2A,1547 +torch/distributed/pipeline/sync/pipe.py,sha256=DFEWhDkRdSeoGEefGAIh_7qM3ZsE7HGgMGVYLQBracc,18104 +torch/distributed/pipeline/sync/pipeline.py,sha256=Pgvj51VM2kTc9flhl4rE7hK8nREcurUYUV37hDLqDs8,9603 +torch/distributed/pipeline/sync/skip/__init__.py,sha256=AuGBWFk0ybIpaWbXk5fWyrxSSSrgzYp4X6nFeD9opaQ,450 +torch/distributed/pipeline/sync/skip/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/__pycache__/layout.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/__pycache__/namespace.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/__pycache__/portal.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/__pycache__/skippable.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/__pycache__/tracker.cpython-310.pyc,, +torch/distributed/pipeline/sync/skip/layout.py,sha256=6fm6FZSgUha-7_5aNt9Zj7NnAhQpe5vEQdJMOFwZpk0,3350 +torch/distributed/pipeline/sync/skip/namespace.py,sha256=w2jgNJvZ2tcX8EfWteT-syRBzwf96-Q6LdWqzuQxCVw,1465 +torch/distributed/pipeline/sync/skip/portal.py,sha256=8kmrs5CbgBTBlt_nl7R9_A26i3WHNtAThQFzDz95Y7s,7227 +torch/distributed/pipeline/sync/skip/skippable.py,sha256=MF7qyRH-PxxMoYcmFzwhtpwDoaeRbe8EukMPUS73gaA,13904 +torch/distributed/pipeline/sync/skip/tracker.py,sha256=X0B-WnGcP3mvWais7cF_D-IOgfyvwik3IW35g1wUwoM,6164 +torch/distributed/pipeline/sync/stream.py,sha256=R26914UoAFqKHpCEzWRfIYnlyPUcs8cSSA0Di4irPRo,4019 +torch/distributed/pipeline/sync/utils.py,sha256=v2Iq_Zen3GcCdHZF_LTcfk4OiT6dRVvdzrznHznWn3Q,1252 +torch/distributed/pipeline/sync/worker.py,sha256=J2wInTXH_tfMbszvk5YOEgzVj0MPIS-pDq_KOKPNUSw,4331 +torch/distributed/remote_device.py,sha256=XYyNCzXnkBy-kzVjB3pNn1ZFQXmw8bWYmg73rvpyUH4,4683 +torch/distributed/rendezvous.py,sha256=uMECk19VxaGWwE0crY3CJ-2-CFJpzmgMED5ZFSsZ_sY,9270 +torch/distributed/rpc/__init__.py,sha256=fA9fwZqVQAp4oFCK_ykczS0s50rqeqXOlnAkpj1JWRM,9696 +torch/distributed/rpc/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/_utils.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/api.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/backend_registry.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/constants.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/functions.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/internal.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/options.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/rref_proxy.cpython-310.pyc,, +torch/distributed/rpc/__pycache__/server_process_global_profiler.cpython-310.pyc,, +torch/distributed/rpc/_testing/__init__.py,sha256=dfg3h9fCYdgDbGDt6ezrqW5QgfUbVHqUcJKInWa-yEU,471 +torch/distributed/rpc/_testing/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/rpc/_testing/__pycache__/faulty_agent_backend_registry.cpython-310.pyc,, +torch/distributed/rpc/_testing/faulty_agent_backend_registry.py,sha256=vQuOGeuMGNZPdJtkmeCPs83z0bL5PBK8Op3eSkdLnzw,1640 +torch/distributed/rpc/_utils.py,sha256=kYVtyE3PvQ2RvK8qLzGtFKHT1wh3dgk91QH6_uyGUJc,1534 +torch/distributed/rpc/api.py,sha256=-x_gpSUnZTu3aybIwMCLWX_Et46_vJDNFUWXabWxm1c,36903 +torch/distributed/rpc/backend_registry.py,sha256=3wqiOggOjkw9-lv89siK-R4nZ_tn7_wOCSL7J1DXZcw,16265 +torch/distributed/rpc/constants.py,sha256=q2cZRiFvagx_AOD1k0EtLBuHf4kvbLQplYYZUdQrdlc,829 +torch/distributed/rpc/functions.py,sha256=-CtPSL1kA2RcgVunt7CUivokfV5baRQA8KIGUwxJUok,7243 +torch/distributed/rpc/internal.py,sha256=QQpbxO8pmmVhOsV7MRPQ92Uva9_yCkcwoJeyL9Gzwgw,11068 +torch/distributed/rpc/options.py,sha256=oeazpS3qu4wNUI4J_enJTE8VHTFkVWbH9VdXnbEzu4A,7044 +torch/distributed/rpc/rref_proxy.py,sha256=ayNqUvfE-t03h_wP2Kk7E0hunqxspxZDOF0jDkf6rk8,2632 +torch/distributed/rpc/server_process_global_profiler.py,sha256=KCkKO_yaouPp6tKJcxczw-DH0lq35ZgAvYAjn9c5xuc,8296 +torch/distributed/run.py,sha256=gJkVO6IqoJCsjfNl-eqbCexp6cdxB-EeBfYfYvx1gI8,33109 +torch/distributed/tensor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/distributed/tensor/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/tensor/parallel/__init__.py,sha256=_4j5vsk-nYACd32ylD1G9g2_zctNJkb6Cyi75zUHEN4,580 +torch/distributed/tensor/parallel/__pycache__/__init__.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/_data_parallel_utils.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/_utils.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/api.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/ddp.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/fsdp.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/input_reshard.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/loss.cpython-310.pyc,, +torch/distributed/tensor/parallel/__pycache__/style.cpython-310.pyc,, +torch/distributed/tensor/parallel/_data_parallel_utils.py,sha256=-u-GpXwzI7t_uukJxXEyExTRWREOGBtYNJvc37SCKZc,1521 +torch/distributed/tensor/parallel/_utils.py,sha256=n4Xmqxeo4sXpwxgIFEchr_ekGffSr94LKcTNfAKsmz0,2270 +torch/distributed/tensor/parallel/api.py,sha256=QbDJMpIgKdWd1rmcYuShHEGCdZnuWimiF8v_t3p3eTs,4707 +torch/distributed/tensor/parallel/ddp.py,sha256=RFLFWhLaUn7UUE4eTtnJb9_n5bTJl0g3gEqUBDeZdV8,3532 +torch/distributed/tensor/parallel/fsdp.py,sha256=S4_RPn2kYzpEtJ9np8MIzAwbVLt91BNqKL3N4SR_Sbc,13690 +torch/distributed/tensor/parallel/input_reshard.py,sha256=_y2jwAq-cpjdzMNE33F0d7lC7YbE2wAJd2Kt4IeyyjE,3748 +torch/distributed/tensor/parallel/loss.py,sha256=CwlwGDtihsLg7d4p3CYiulaA8-rvIlwne4GIQwIKDpE,17706 +torch/distributed/tensor/parallel/style.py,sha256=1Wz_t34hepJXJZQm6608KehF6zyRNF53ZNFPOFYKUhY,23797 +torch/distributed/utils.py,sha256=1j5_N8x3-SVA1ZjZIezkI3yTvKjlDUvMY8PzK5uktHE,12353 +torch/distributions/__init__.py,sha256=bYWu3MQ0KUytopIxl4WqDEjZV-eAWG779zUSKQA1v9s,6035 +torch/distributions/__pycache__/__init__.cpython-310.pyc,, +torch/distributions/__pycache__/bernoulli.cpython-310.pyc,, +torch/distributions/__pycache__/beta.cpython-310.pyc,, +torch/distributions/__pycache__/binomial.cpython-310.pyc,, +torch/distributions/__pycache__/categorical.cpython-310.pyc,, +torch/distributions/__pycache__/cauchy.cpython-310.pyc,, +torch/distributions/__pycache__/chi2.cpython-310.pyc,, +torch/distributions/__pycache__/constraint_registry.cpython-310.pyc,, +torch/distributions/__pycache__/constraints.cpython-310.pyc,, +torch/distributions/__pycache__/continuous_bernoulli.cpython-310.pyc,, +torch/distributions/__pycache__/dirichlet.cpython-310.pyc,, +torch/distributions/__pycache__/distribution.cpython-310.pyc,, +torch/distributions/__pycache__/exp_family.cpython-310.pyc,, +torch/distributions/__pycache__/exponential.cpython-310.pyc,, +torch/distributions/__pycache__/fishersnedecor.cpython-310.pyc,, +torch/distributions/__pycache__/gamma.cpython-310.pyc,, +torch/distributions/__pycache__/geometric.cpython-310.pyc,, +torch/distributions/__pycache__/gumbel.cpython-310.pyc,, +torch/distributions/__pycache__/half_cauchy.cpython-310.pyc,, +torch/distributions/__pycache__/half_normal.cpython-310.pyc,, +torch/distributions/__pycache__/independent.cpython-310.pyc,, +torch/distributions/__pycache__/inverse_gamma.cpython-310.pyc,, +torch/distributions/__pycache__/kl.cpython-310.pyc,, +torch/distributions/__pycache__/kumaraswamy.cpython-310.pyc,, +torch/distributions/__pycache__/laplace.cpython-310.pyc,, +torch/distributions/__pycache__/lkj_cholesky.cpython-310.pyc,, +torch/distributions/__pycache__/log_normal.cpython-310.pyc,, +torch/distributions/__pycache__/logistic_normal.cpython-310.pyc,, +torch/distributions/__pycache__/lowrank_multivariate_normal.cpython-310.pyc,, +torch/distributions/__pycache__/mixture_same_family.cpython-310.pyc,, +torch/distributions/__pycache__/multinomial.cpython-310.pyc,, +torch/distributions/__pycache__/multivariate_normal.cpython-310.pyc,, +torch/distributions/__pycache__/negative_binomial.cpython-310.pyc,, +torch/distributions/__pycache__/normal.cpython-310.pyc,, +torch/distributions/__pycache__/one_hot_categorical.cpython-310.pyc,, +torch/distributions/__pycache__/pareto.cpython-310.pyc,, +torch/distributions/__pycache__/poisson.cpython-310.pyc,, +torch/distributions/__pycache__/relaxed_bernoulli.cpython-310.pyc,, +torch/distributions/__pycache__/relaxed_categorical.cpython-310.pyc,, +torch/distributions/__pycache__/studentT.cpython-310.pyc,, +torch/distributions/__pycache__/transformed_distribution.cpython-310.pyc,, +torch/distributions/__pycache__/transforms.cpython-310.pyc,, +torch/distributions/__pycache__/uniform.cpython-310.pyc,, +torch/distributions/__pycache__/utils.cpython-310.pyc,, +torch/distributions/__pycache__/von_mises.cpython-310.pyc,, +torch/distributions/__pycache__/weibull.cpython-310.pyc,, +torch/distributions/__pycache__/wishart.cpython-310.pyc,, +torch/distributions/bernoulli.py,sha256=RPe79IcRj6pXAehuFqqHITSaphmhzquX3pFb1UB_DQI,4171 +torch/distributions/beta.py,sha256=ZZszB4CFP7Q2b4s0K9IpE-I6XVMhLxCGTdQjPZ4u2s0,3670 +torch/distributions/binomial.py,sha256=v1Y33-8F6jHC21Qd4rCHmEH0vsXusxOC1TTAuGYi0zI,5977 +torch/distributions/categorical.py,sha256=d3paHTqUebex4yfgPj7pzpCkes4nOnuLojaURq9azME,5777 +torch/distributions/cauchy.py,sha256=CJkDeFC_kW_2otB8Y4giaY1hQGdOj3P4xGQ9aZnesEE,2928 +torch/distributions/chi2.py,sha256=bymdtQeixiivHE20ofdid-31UMa_Fdv6BFwM1oLEpoU,974 +torch/distributions/constraint_registry.py,sha256=W9dx8uTQVLcAiEt9JM18QHVJpWYRAToAOoVSAC-34k0,10301 +torch/distributions/constraints.py,sha256=1pYC-dnr1RuE6_OlPgxTSybCMMndqWwpoo7PwK3v2xw,18615 +torch/distributions/continuous_bernoulli.py,sha256=dKyWa9aSWMOkC_0hTBPToXAfgolfoBt0vZVmBjq1UYg,8688 +torch/distributions/dirichlet.py,sha256=SHD2dPZf_ugfEpfn-zy9aOSg4WiQGNhz3GFEiJ1Qzcs,4171 +torch/distributions/distribution.py,sha256=_Pa1BbwoKlPyhkBpuqyPYAWSqWIfszYHlKlftetBqU4,12324 +torch/distributions/exp_family.py,sha256=Wts3zBJMvY6vwOyGehD1NDdu3n-x6NKZLRzGBZnTuiM,2353 +torch/distributions/exponential.py,sha256=YXwKu7AWgOUkfgVXnetM7s0nFWMfb-fANwHWtppL2MU,2438 +torch/distributions/fishersnedecor.py,sha256=IEIcWgoYBsDdK1KhXAeATlth55Msdh1ZT3Spae-BMko,3434 +torch/distributions/gamma.py,sha256=88NEzg2xhoz859PAgy69Xp7b4U5qIu4U6lhKG0dThq4,3606 +torch/distributions/geometric.py,sha256=mR4PXz5s-cvxsD_C1gnvE0gSug0qefpYUfMlt8vLzOY,4652 +torch/distributions/gumbel.py,sha256=fIfkOzOK5hleyU8cKbLEX7gzX2i_1scLSUIBJeA-QhI,2770 +torch/distributions/half_cauchy.py,sha256=c0jbnYOjsJ-9_YTbdDTJggNHdK5rgBdfNeqYHnY8lpc,2395 +torch/distributions/half_normal.py,sha256=zcM-KBHDDY5u_yiW39XgM8df7EFdG5VxNa3tA0kKlXY,2160 +torch/distributions/independent.py,sha256=ZWlhm_BpDWBz_SdTrXsknv1v-Xg490sAh5MgbdSoVvk,4605 +torch/distributions/inverse_gamma.py,sha256=QOf9aB9cY3sR6SP5D1JmVLPnhUC-k2mEHefgqsWiQi4,2478 +torch/distributions/kl.py,sha256=ONv4BgEaC4_KeC9ClhlrhTg4i2Qhm-NDDeyiSCtTCxs,31731 +torch/distributions/kumaraswamy.py,sha256=221peO4jn9S6AfM5tNFKEOg43Los-EKOKRbqO8rHeaM,3495 +torch/distributions/laplace.py,sha256=tXXtEHXtgTNzEPRiha29fL3SOqa1it4cYxG9YSDVlwE,3232 +torch/distributions/lkj_cholesky.py,sha256=x-OAlxCH0iag94K1qotyTLvfONarWpll6Py3lyRyXfw,6373 +torch/distributions/log_normal.py,sha256=6Gb7K2zIP9-Z3iGNA8LS_q7PcnIO11-5XOfQvEt4_jw,1929 +torch/distributions/logistic_normal.py,sha256=p8aUz8hlC1T9FpL6tqlRDcGU2-LxsCXqd7gXUBceuyM,1949 +torch/distributions/lowrank_multivariate_normal.py,sha256=BtBD2I-z8K6I5GQg9QgHNfiZV0enKi5IMSixT-4JRSU,9780 +torch/distributions/mixture_same_family.py,sha256=MPlA02MqKA4OkhChylKSHvSKKqKwF4tvxFpNSYIbt6w,8461 +torch/distributions/multinomial.py,sha256=LNU6XFnfu36q4JK8BPA33IlNmjC6slCAZA2eJVNGeII,5400 +torch/distributions/multivariate_normal.py,sha256=APNwJFe6fxxS5UBSRyzlPxa0miyFNDA-21XaNq47ErE,10746 +torch/distributions/negative_binomial.py,sha256=xLyVUsJSWbbgH5LtGuX7AUiXBD1mPicd31Wd99Ki7xQ,4671 +torch/distributions/normal.py,sha256=V3SVCrr8kghmeXNPWT9q7s452wOj1QZI3VuknkI4zYw,3549 +torch/distributions/one_hot_categorical.py,sha256=PUZUAHkvuwilu35uBzZCrso3OrJXpFmMFrArfLwBBXY,4679 +torch/distributions/pareto.py,sha256=k_eHHbQ3_APAdJ0eAkiLiS7Ni7eIImT5xATuDZNny3w,2175 +torch/distributions/poisson.py,sha256=7VDTS-WUP1pG5aiS3TMOVQocSJpHM4sdLewh-_L6w70,2217 +torch/distributions/relaxed_bernoulli.py,sha256=XLg5GzNvAIFV41yPL9zp1cRZS_YuBCGR6UL8u1VKrLo,5368 +torch/distributions/relaxed_categorical.py,sha256=TT5Ok0DA9MDhRr7b40kxwxy7lkoj_-qTkYgsrGVCW9Q,5163 +torch/distributions/studentT.py,sha256=2T5XQbtHA7gnjv6o24rBGpqgkkSpmzwS-nPFiQciSXg,3856 +torch/distributions/transformed_distribution.py,sha256=Ex57d7g3h7u3IkDmafzuYwcGTOwWenxxBF_Hv255Df4,8660 +torch/distributions/transforms.py,sha256=tQa9SgIkAqs7YGLsW_s23sorgClpRxTB3UWYgYFNtqc,40934 +torch/distributions/uniform.py,sha256=_gfQLn2kSxL6zZdp-NRSzkC47Hw4yFGsNtcsOLvoV3Y,3240 +torch/distributions/utils.py,sha256=BMJiAkBDOeeRAHcUd2YGYTVWhv2itIkkwbo83L6lDx4,6350 +torch/distributions/von_mises.py,sha256=WllECPJcXQpiBvPhXmzu3nwP0Qc82t1FyjmG3uGi_fI,6061 +torch/distributions/weibull.py,sha256=NCctBNGYUo9EhJ-IFkf05U1YKX8g-AQz-qrxESkX5Tg,3069 +torch/distributions/wishart.py,sha256=kHT5u_7rut7MTlpCRyoTFQiUs0F6sYgIO_OJ9vGOwSc,13621 +torch/export/__init__.py,sha256=L9R_p6fsiijG9K6ATNgRrfT3e6e5piwzt5wJMx4_WqM,11935 +torch/export/__pycache__/__init__.cpython-310.pyc,, +torch/export/__pycache__/_remove_auto_functionalized_pass.cpython-310.pyc,, +torch/export/__pycache__/_remove_effect_tokens_pass.cpython-310.pyc,, +torch/export/__pycache__/_safeguard.cpython-310.pyc,, +torch/export/__pycache__/_trace.cpython-310.pyc,, +torch/export/__pycache__/_tree_utils.cpython-310.pyc,, +torch/export/__pycache__/_unlift.cpython-310.pyc,, +torch/export/__pycache__/custom_obj.cpython-310.pyc,, +torch/export/__pycache__/dynamic_shapes.cpython-310.pyc,, +torch/export/__pycache__/exported_program.cpython-310.pyc,, +torch/export/__pycache__/graph_signature.cpython-310.pyc,, +torch/export/__pycache__/unflatten.cpython-310.pyc,, +torch/export/_remove_auto_functionalized_pass.py,sha256=qEFKsn9T_JCFja4a1_7WDbfOTaXUVjpfhtC7Yoy1Mtc,3997 +torch/export/_remove_effect_tokens_pass.py,sha256=zVWLJsMWQReJhJPPHeCEAiBjXsxbNys1Kfb6s94f9pA,4398 +torch/export/_safeguard.py,sha256=hXkpEnKPNf5Y2uIwBQjWJu44RGOryLb7yuHjpep_r5I,1829 +torch/export/_trace.py,sha256=ee2-zppzdOTTfGqRikHdKDZ0BFeCd8-yUPrviBFh36A,40053 +torch/export/_tree_utils.py,sha256=E2SxZ08IqAl-CZXmZU21V38GdPeV5gGanWQlJnQ3K74,2230 +torch/export/_unlift.py,sha256=VfKdTmGvEq2XK1cdR2z4RydhH9UT9UXOH9ryAceb_OI,10267 +torch/export/custom_obj.py,sha256=H6j0qawn-qiMlmafZDdjAuOOQY7YvQ7pbhiFW71hOMY,296 +torch/export/dynamic_shapes.py,sha256=q4c5e_voj6evmTwSrCsNSwPhdHV4uFOyYt8kAEBlmt8,35240 +torch/export/exported_program.py,sha256=E6TULU2HyBc2jfpp-wtmJHJfPhv-Ry0hPrKcXgsGvNA,27932 +torch/export/graph_signature.py,sha256=2UCSFANDCRClhYS9TBnoDKr_qRKJ3Iq-T6EsOcA3IWY,18117 +torch/export/unflatten.py,sha256=TO33nep-oDV-B02jds-KUq4GmjhsSsrBAPpWW_w9jU4,33697 +torch/fft/__init__.py,sha256=X8JNOgYQ0V9PEDWhiqOr7WKJvcb4SXKLkMOb6XWB2i8,55060 +torch/fft/__pycache__/__init__.cpython-310.pyc,, +torch/func/__init__.py,sha256=Ww3pIuyf3N97iQ9lRRhFOK0jdfzpZ6PKnTjuEJPjieI,397 +torch/func/__pycache__/__init__.cpython-310.pyc,, +torch/functional.py,sha256=leB5T2sPNw5gq_H9mB33kwuKvxZVgraGmYvm28Y5F80,85621 +torch/futures/__init__.py,sha256=rNwSU8rY3NFVkHEtzH3v3vaHH4f5kbt4Xr_5rc2W5ow,14392 +torch/futures/__pycache__/__init__.cpython-310.pyc,, +torch/fx/__init__.py,sha256=vKm-N5rNFuUID7okSpz4LxhGgNeOnHyPcAM3q54AvQo,3810 +torch/fx/__init__.pyi,sha256=wzQLHIhlG_Kn0oDU_nauEn0eVkx33QYN8Fch_Ag7K5c,465 +torch/fx/__pycache__/__init__.cpython-310.pyc,, +torch/fx/__pycache__/_compatibility.cpython-310.pyc,, +torch/fx/__pycache__/_lazy_graph_module.cpython-310.pyc,, +torch/fx/__pycache__/_pytree.cpython-310.pyc,, +torch/fx/__pycache__/_symbolic_trace.cpython-310.pyc,, +torch/fx/__pycache__/annotate.cpython-310.pyc,, +torch/fx/__pycache__/config.cpython-310.pyc,, +torch/fx/__pycache__/graph.cpython-310.pyc,, +torch/fx/__pycache__/graph_module.cpython-310.pyc,, +torch/fx/__pycache__/immutable_collections.cpython-310.pyc,, +torch/fx/__pycache__/interpreter.cpython-310.pyc,, +torch/fx/__pycache__/node.cpython-310.pyc,, +torch/fx/__pycache__/operator_schemas.cpython-310.pyc,, +torch/fx/__pycache__/proxy.cpython-310.pyc,, +torch/fx/__pycache__/subgraph_rewriter.cpython-310.pyc,, +torch/fx/__pycache__/tensor_type.cpython-310.pyc,, +torch/fx/__pycache__/traceback.cpython-310.pyc,, +torch/fx/_compatibility.py,sha256=_wIYk-XWWi_X0bgTg99dCryxvurhYx8EsJeXK3bmLos,1006 +torch/fx/_lazy_graph_module.py,sha256=LHfGHT0jjgpbDsXfxqGhw01EwL1FLIE83erlb5US4iQ,7145 +torch/fx/_pytree.py,sha256=rJoEwFTGNxyVzi-wvFMDKvtuZzgZ7eCJvMYgIxjw6oI,3475 +torch/fx/_symbolic_trace.py,sha256=Yi6iaVhusBKGhxPaRPWfQd_ZzUFSOZ3r09jm-MAiFTo,46433 +torch/fx/annotate.py,sha256=KftuDh5eOI3-n9npsVwvaL5GAJg9cVH5OAMW1mXIIns,929 +torch/fx/config.py,sha256=Vq4ADVOR87qBcbL9BMOX7DObs6TJQGEIiT3LivH4mkg,328 +torch/fx/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/experimental/__pycache__/__init__.cpython-310.pyc,, +torch/fx/experimental/__pycache__/_backward_state.cpython-310.pyc,, +torch/fx/experimental/__pycache__/_config.cpython-310.pyc,, +torch/fx/experimental/__pycache__/_sym_dispatch_mode.cpython-310.pyc,, +torch/fx/experimental/__pycache__/accelerator_partitioner.cpython-310.pyc,, +torch/fx/experimental/__pycache__/const_fold.cpython-310.pyc,, +torch/fx/experimental/__pycache__/debug.cpython-310.pyc,, +torch/fx/experimental/__pycache__/graph_gradual_typechecker.cpython-310.pyc,, +torch/fx/experimental/__pycache__/merge_matmul.cpython-310.pyc,, +torch/fx/experimental/__pycache__/meta_tracer.cpython-310.pyc,, +torch/fx/experimental/__pycache__/normalize.cpython-310.pyc,, +torch/fx/experimental/__pycache__/optimization.cpython-310.pyc,, +torch/fx/experimental/__pycache__/partitioner_utils.cpython-310.pyc,, +torch/fx/experimental/__pycache__/proxy_tensor.cpython-310.pyc,, +torch/fx/experimental/__pycache__/recording.cpython-310.pyc,, +torch/fx/experimental/__pycache__/refinement_types.cpython-310.pyc,, +torch/fx/experimental/__pycache__/rewriter.cpython-310.pyc,, +torch/fx/experimental/__pycache__/schema_type_annotation.cpython-310.pyc,, +torch/fx/experimental/__pycache__/sym_node.cpython-310.pyc,, +torch/fx/experimental/__pycache__/symbolic_shapes.cpython-310.pyc,, +torch/fx/experimental/__pycache__/unify_refinements.cpython-310.pyc,, +torch/fx/experimental/__pycache__/validator.cpython-310.pyc,, +torch/fx/experimental/_backward_state.py,sha256=TzC9Uin0ccyk7oG5z7HQPhRP6I0_6-HC28DOXpzUZzE,967 +torch/fx/experimental/_config.py,sha256=C_e4HQI04n5-KtIxGAtLYt8XiusTzN1ydQaZK9KUKQU,3268 +torch/fx/experimental/_sym_dispatch_mode.py,sha256=sv2lFtl-2sdMtLPJAbKWt0tT_aLxmYlsZH6RZ-4hhD4,1944 +torch/fx/experimental/accelerator_partitioner.py,sha256=T8VvGniQN8NFRkRCivlyOC79UC-XF2-GQbmDZRgh_FI,47938 +torch/fx/experimental/const_fold.py,sha256=d5TLSWtvWFqzMgscJbWsrc2L-wK1bGff8cHX21LBp04,11921 +torch/fx/experimental/debug.py,sha256=gVAFQp2OO2FGPYThJBM3y1LieFK6C72rmNrf2CJEaNY,805 +torch/fx/experimental/graph_gradual_typechecker.py,sha256=kIek4vMbE2OJYCGGi2qs6uuIISln8FRe4dHENgzoEwc,32310 +torch/fx/experimental/merge_matmul.py,sha256=f8MDNHfMzsBMdg1M_hfiO3rfrj5YXeZiKHyLST86iTE,5981 +torch/fx/experimental/meta_tracer.py,sha256=Rf4eYrHAknEynDI8aw_TwqyPEgiXZvA8SY0QVylrigI,10025 +torch/fx/experimental/migrate_gradual_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/experimental/migrate_gradual_types/__pycache__/__init__.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/constraint.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/constraint_generator.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/constraint_transformation.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/operation.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/transform_to_z3.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/util.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/__pycache__/z3_types.cpython-310.pyc,, +torch/fx/experimental/migrate_gradual_types/constraint.py,sha256=ZwrkEz-XDX3sXtGL509JgM3wVdeZEK2ekEj4cfZor14,16367 +torch/fx/experimental/migrate_gradual_types/constraint_generator.py,sha256=hR9jZnbvNFDWC-2_buJCM7RJZiZ-gkI-tI_WE6ZXpyI,47534 +torch/fx/experimental/migrate_gradual_types/constraint_transformation.py,sha256=5Vuh8jmrg1w5b6vPkV1MVQqhfTnGFmV_PYjAbC5ws5w,39376 +torch/fx/experimental/migrate_gradual_types/operation.py,sha256=-m6ss5-iKLJVS9D1oDBNrYKKWPubwdAV3211SIPQpm4,206 +torch/fx/experimental/migrate_gradual_types/transform_to_z3.py,sha256=Ad8CbEujHxqWpt859ssuKjFxDeY5xJPAJDyxkJLfK9w,14704 +torch/fx/experimental/migrate_gradual_types/util.py,sha256=zzEWfui0hKdW9Pvkg5AdcXg4FZHierCprmdfw9Xwjng,1321 +torch/fx/experimental/migrate_gradual_types/z3_types.py,sha256=w27YOUiMJ0idGox7f76kMPtOp7mKYqb_TQuOFlb5kX4,806 +torch/fx/experimental/normalize.py,sha256=UW8UtGsGYLCvsQ7xTRArpWeYGA2fIGXoRo3jY6hsALc,5478 +torch/fx/experimental/optimization.py,sha256=d3AVXkC4IaScx6HS5Lz3Y3SQXkzA8Re9uQT9s32OOtc,16665 +torch/fx/experimental/partitioner_utils.py,sha256=QSN46WXIuwJUOL7BTSsgkt0-3muHIIT8bxD0Bogj97w,12370 +torch/fx/experimental/proxy_tensor.py,sha256=AN4GnNHUzlxZU5H_pL9yy8PG9-vk6fIJ0IEzar-yPL0,45973 +torch/fx/experimental/recording.py,sha256=68nCq6qOQNiWQqg8T_4QXk8nPCT_xe_U5ggofYrw48U,17475 +torch/fx/experimental/refinement_types.py,sha256=bmEVM6UqSSGB2MX7yEsvau1ed35nkSDvyHF7WDmJyqo,405 +torch/fx/experimental/rewriter.py,sha256=z1U8dOxYqzocfYI1ubAL7rja5X14nZo1ZuyJEcz_zRk,4943 +torch/fx/experimental/schema_type_annotation.py,sha256=uQwy2sqrALncACflJ0eL7SZAQMo00edJfAx0wWIsdEU,5000 +torch/fx/experimental/sym_node.py,sha256=eBdoqW71XTB3h_VJzumGXPw_YefLQ17cBGy8H0AmBAg,41545 +torch/fx/experimental/symbolic_shapes.py,sha256=bAoq3QgKl579V0Sw0Ul-NmCUTw2YB27w6LOf6a5KgaE,195808 +torch/fx/experimental/unification/__init__.py,sha256=JSX_I7TpG_gVkuwRSoZquk9ND-shjCgrTEQytg9krq0,196 +torch/fx/experimental/unification/__pycache__/__init__.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/core.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/dispatch.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/match.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/more.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/unification_tools.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/utils.cpython-310.pyc,, +torch/fx/experimental/unification/__pycache__/variable.cpython-310.pyc,, +torch/fx/experimental/unification/core.py,sha256=UM1vX6aAKfNxRpJtMl-J-e7F3FmYXdnlYYTeBeZWCJU,2707 +torch/fx/experimental/unification/dispatch.py,sha256=Lkd0aJd7o8XM6GcnBmhK7O1HUlbQ_xKKdiZfj0Wo24U,191 +torch/fx/experimental/unification/match.py,sha256=dgqHYOv42Y2LTD1WYQw3R8-Y-2Ey0IR4dp8A5LLKcq4,3365 +torch/fx/experimental/unification/more.py,sha256=aTrnPt_6EnrQVPuG28d2TVbeNSLGQqdyMnNFCfc7054,2917 +torch/fx/experimental/unification/multipledispatch/__init__.py,sha256=zm7LfTwHQ3IoYiEBKKDFz8BH_m_8AfQ3zwjTRoH15ho,145 +torch/fx/experimental/unification/multipledispatch/__pycache__/__init__.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/__pycache__/conflict.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/__pycache__/core.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/__pycache__/dispatcher.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/__pycache__/utils.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/__pycache__/variadic.cpython-310.pyc,, +torch/fx/experimental/unification/multipledispatch/conflict.py,sha256=w9eUpVmdASoc6rXjYCqyq6jZB6W_TXWcLD4uyuPXsAg,4113 +torch/fx/experimental/unification/multipledispatch/core.py,sha256=FcgcG7tEo8e9q_yVFLnqocsC0BikSk9Rj-hnbzMPqEU,2670 +torch/fx/experimental/unification/multipledispatch/dispatcher.py,sha256=9qMqz6G0dTDT6O-zbp5rN7Y9LKPp7Xe6vIGxg13QMUA,13797 +torch/fx/experimental/unification/multipledispatch/utils.py,sha256=aZ3cFdNKiaB06_a4Lvs8IR9i2d4k3m5WaJZ4IjvIJ_c,3776 +torch/fx/experimental/unification/multipledispatch/variadic.py,sha256=KuQ-84U3LyPdiscFruC0oiNiOfsYiOrw7UIHExGUt3c,2942 +torch/fx/experimental/unification/unification_tools.py,sha256=YlxVSYpZXZTT-x1r_wl4c5tJtUwZy_4EDJp5cwseELg,10544 +torch/fx/experimental/unification/utils.py,sha256=ETMPmZ7gsOySGNWQW5MlwJ-bDtDGidhUwUeURNw3Hyo,2902 +torch/fx/experimental/unification/variable.py,sha256=CdDrhP1CbSn_Ug3a9usPAVGV8DVJkegIzblEXKw48kY,2036 +torch/fx/experimental/unify_refinements.py,sha256=Yg3VdTWTpZCsygUvRlS51boUqULgxB019Mt8g0o1d1o,3121 +torch/fx/experimental/validator.py,sha256=ESXfDE_8N7a-Hn1RMYIFmhTE4oG9uoEnKmciQFaaG1M,30723 +torch/fx/graph.py,sha256=2gNH4dhkjD2-c4biFj5fdPDbtiHTMixZYg2Jruy0dcQ,67708 +torch/fx/graph_module.py,sha256=9MD8-fHZoyFOwF6r3EoNcLntjrSeEJH7-oecUgvbwSw,35213 +torch/fx/immutable_collections.py,sha256=_oHFK0lLhuPTVYibc4q7TVxctR7ey-VqXofvsMeMA7E,2884 +torch/fx/interpreter.py,sha256=8q3zGNAfRh8_JLaXYH5Tirt4n6WN--OqMyVrwpz-X40,21723 +torch/fx/node.py,sha256=YjCnT-f7xengWNIxZ8WsJSZqNeOGRmEHj8OWxqdDv4Y,31305 +torch/fx/operator_schemas.py,sha256=WLC_41BZBpIDYarlR1kcUwwg4dc3pPzY5EROviF9HZs,20368 +torch/fx/passes/__init__.py,sha256=IVYzwVj4hA5CXT-6Z6sxJfEAFM0LKXTuVqqjijqReT4,301 +torch/fx/passes/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/__pycache__/annotate_getitem_nodes.cpython-310.pyc,, +torch/fx/passes/__pycache__/fake_tensor_prop.cpython-310.pyc,, +torch/fx/passes/__pycache__/graph_drawer.cpython-310.pyc,, +torch/fx/passes/__pycache__/graph_manipulation.cpython-310.pyc,, +torch/fx/passes/__pycache__/net_min_base.cpython-310.pyc,, +torch/fx/passes/__pycache__/operator_support.cpython-310.pyc,, +torch/fx/passes/__pycache__/param_fetch.cpython-310.pyc,, +torch/fx/passes/__pycache__/pass_manager.cpython-310.pyc,, +torch/fx/passes/__pycache__/reinplace.cpython-310.pyc,, +torch/fx/passes/__pycache__/shape_prop.cpython-310.pyc,, +torch/fx/passes/__pycache__/split_module.cpython-310.pyc,, +torch/fx/passes/__pycache__/split_utils.cpython-310.pyc,, +torch/fx/passes/__pycache__/splitter_base.cpython-310.pyc,, +torch/fx/passes/__pycache__/tools_common.cpython-310.pyc,, +torch/fx/passes/annotate_getitem_nodes.py,sha256=E0brWyfqEc0ZcKl5-Y2Ab-1SBhIOrc_d_QJbuVf4KFs,1953 +torch/fx/passes/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/passes/backends/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/backends/__pycache__/cudagraphs.cpython-310.pyc,, +torch/fx/passes/backends/cudagraphs.py,sha256=0tTRj_qd9SYR2ogNghk4iATS1W27vJarV8Rbjm4e8lo,2040 +torch/fx/passes/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/passes/dialect/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/dialect/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/passes/dialect/common/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/dialect/common/__pycache__/cse_pass.cpython-310.pyc,, +torch/fx/passes/dialect/common/cse_pass.py,sha256=ZV_BG8JVs2vaNKvkiC3QAt9HUf2jgxIP5AtzziavHKo,4911 +torch/fx/passes/fake_tensor_prop.py,sha256=LzoK0aPccFO_QcESNbMN2OpMNBR2oQcJLLVriWxIWrw,2708 +torch/fx/passes/graph_drawer.py,sha256=eS7T8lSG864mjflE26hDEbj2owaWo0o6028Gm9g4mKU,16647 +torch/fx/passes/graph_manipulation.py,sha256=7NL6WodpkK57LJ6gSmzdCWCIAP53e1U0xqL7tDGvftU,3981 +torch/fx/passes/infra/__init__.py,sha256=edegnIAKakNdSXu64OLBr7POgNQUF2NDlOhK6y5Aftw,28 +torch/fx/passes/infra/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/infra/__pycache__/partitioner.cpython-310.pyc,, +torch/fx/passes/infra/__pycache__/pass_base.cpython-310.pyc,, +torch/fx/passes/infra/__pycache__/pass_manager.cpython-310.pyc,, +torch/fx/passes/infra/partitioner.py,sha256=m3yL0dTAXXPKdeYZoL-ZWFmP1Qq-V6Y9XxG7EMQ7ovE,15649 +torch/fx/passes/infra/pass_base.py,sha256=pA_-w5a9HTnMvCdF4v2KqUJTR0Y-huLHen4Ous4slc0,2490 +torch/fx/passes/infra/pass_manager.py,sha256=uufYmPMdLDJRv0fb4sk9dw9390pOePUWmn1eWn9r8HI,10313 +torch/fx/passes/net_min_base.py,sha256=kegtodw2D3CdYYvWiU3SckeK6TlMAcBSWtE9cj0subo,26041 +torch/fx/passes/operator_support.py,sha256=3Z0DoMMca3B1lVlEEK7E9VRFeqOqvlI-E2Mv7NChK4o,7704 +torch/fx/passes/param_fetch.py,sha256=1W-DYjVRHQ99zk0djbwv66epYBJl7gBoTWbO1ejkrzg,3527 +torch/fx/passes/pass_manager.py,sha256=8wyOgEiMuZtBX0UUr28uCN4MVf3V9lnGajOzZ6vcWIs,7217 +torch/fx/passes/reinplace.py,sha256=KUf5sWOLEzLPf1_5qq7eGsKzgBCy6wQntaFiORvIssw,33274 +torch/fx/passes/shape_prop.py,sha256=kZkdB7-JVVd0DPAMeDM4kB7Mqaf9RJQxJvDl9hMJnI0,7213 +torch/fx/passes/split_module.py,sha256=zPqfXR1RVacNDJvBQBf6h-J4ztyAAE-Y720MNeX587g,21455 +torch/fx/passes/split_utils.py,sha256=1a4sITKhaXznky4xSyQTVlWxR8AYrCZlQimvr05GML4,11216 +torch/fx/passes/splitter_base.py,sha256=sF7HkynmWXddJfHeDecoxzi-q6qvUEUucoDfF5fYysI,32300 +torch/fx/passes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/fx/passes/tests/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/tests/__pycache__/test_pass_manager.cpython-310.pyc,, +torch/fx/passes/tests/test_pass_manager.py,sha256=eUjb15IskaC7b-_Lm_DAA4zs_KL9WAcjPaPSTZosUpA,1899 +torch/fx/passes/tools_common.py,sha256=iGpN-F6C2VDgbeFgXK6ik4LHOmt5SUTcEBysFqtt01Y,10134 +torch/fx/passes/utils/__init__.py,sha256=e6gxht-nNUZK2J_E0AkiEpa6UdKlXJA5cwwiu5XbXVc,74 +torch/fx/passes/utils/__pycache__/__init__.cpython-310.pyc,, +torch/fx/passes/utils/__pycache__/common.cpython-310.pyc,, +torch/fx/passes/utils/__pycache__/fuser_utils.cpython-310.pyc,, +torch/fx/passes/utils/__pycache__/matcher_utils.cpython-310.pyc,, +torch/fx/passes/utils/__pycache__/matcher_with_name_node_map_utils.cpython-310.pyc,, +torch/fx/passes/utils/__pycache__/source_matcher_utils.cpython-310.pyc,, +torch/fx/passes/utils/common.py,sha256=lYmaNxwJkKt4l2lwRlgZD8oJuDfgoztOglTHY_Dmcsg,3112 +torch/fx/passes/utils/fuser_utils.py,sha256=28NaDz4l-UA2F9q9VSHOhTSKCQYJEQ8hzbQbahvnijM,8644 +torch/fx/passes/utils/matcher_utils.py,sha256=lCMaLPvoJAccXjTWgNgpTxwgnIdDGy7IKfY7mbWzkYI,16988 +torch/fx/passes/utils/matcher_with_name_node_map_utils.py,sha256=J9Lu-ZdtvUypvldLBcAXZvQdmKbXg0A4uNsEM1wYVuE,4164 +torch/fx/passes/utils/source_matcher_utils.py,sha256=qBHRJ7eoqXBrnuy2wuhSlkqDAkpFS6YkZgM_HPocvvM,4792 +torch/fx/proxy.py,sha256=5kzaf7w8vW5LEfklYJeVT23NYErXnGkA8ZTQpHoYslo,22652 +torch/fx/subgraph_rewriter.py,sha256=b_XPxJzSglXHkV6mrJvlFYVMGGejEmOxFkYc7i74ryk,13797 +torch/fx/tensor_type.py,sha256=XN0UDam2dPe66l7r7atjZf2JqPCXWCmyLUXwFa8xhRU,2932 +torch/fx/traceback.py,sha256=8fsCM7O6yrFLiDLekbi0onSDz9_9VOgbm06mShQ5uIs,3161 +torch/hub.py,sha256=1SNuTs4xHhowrvv8iDQeI45oSTynutNbU8w7Hwj1CTw,32685 +torch/include/ATen/ATen.h,sha256=mkjW3p2EH-mgdyzM_Nn8t3Mu9IneuDNjDyNHTlRYSrg,1107 +torch/include/ATen/AccumulateType.h,sha256=oGsNg1qidiANCOWaXDWl2SlC_QCPCl2b788YldBgXLU,5466 +torch/include/ATen/ArrayRef.h,sha256=Oj53usfNJkz8L3fSOjmE20rpC0NUjhOVz4bmu68R28w,44 +torch/include/ATen/Backend.h,sha256=uKLWU9cBX4ldaPyhSACkAAe1BDHaJFKAS8yVHexzEuo,43 +torch/include/ATen/Backtrace.h,sha256=iQwNYKFPK-sNKn5Ngwy2vzkESKV84wJSLIQD1O7GGxg,46 +torch/include/ATen/CPUApplyUtils.h,sha256=mXDQF4MV8JMJ8ALxcWi_uoZdLn_6obxh6ONJ2gpT98g,10203 +torch/include/ATen/CPUFixedAllocator.h,sha256=ePZtym2ZPfh0EldwpzgFn23DohoHWM9Yx4Q5UJkUUnc,845 +torch/include/ATen/CPUFunctions.h,sha256=4cBJuS_SSe9gkWBaqJv2I4TNOtatWw0_kUy8nYYXAH8,1949 +torch/include/ATen/CPUFunctions_inl.h,sha256=EBv9PvunJCQNM78cmSyEggBVCGb0qAV0BUmWc62hrC0,28805 +torch/include/ATen/CPUGeneratorImpl.h,sha256=CUs44l8g_6kYi-yLdSuPIfE6bXFrIKKsBh-KUx36Ykk,1538 +torch/include/ATen/CUDAFunctions.h,sha256=WjTAkU2Xu4Ngb6b2rGorhNx5ZqgohX1cEC881uL_Nnk,1950 +torch/include/ATen/CUDAFunctions_inl.h,sha256=nNjDBz9GZzaybTRJ8MbBXA-AMk8zmBioensCaEenoN0,31685 +torch/include/ATen/CachedTensorUtils.h,sha256=A7gaS6-sexogUv0aYx8H9EYbRZxvaNXyNtgy4ovaZfM,1007 +torch/include/ATen/CollapseDims.h,sha256=YcFbH1j-lkxTcwHr5trswl3WJEZTp8VcW6sfsm11_oA,2560 +torch/include/ATen/CompositeExplicitAutogradFunctions.h,sha256=BJpZzuYLgLK--GQfTXH-YcFtW2869S79UUuxSib_sTE,1971 +torch/include/ATen/CompositeExplicitAutogradFunctions_inl.h,sha256=Za086tBt6wHYDqGfyQxXE99q3TuLAUZduGK0jqzwnuY,39222 +torch/include/ATen/CompositeExplicitAutogradNonFunctionalFunctions.h,sha256=K9KLMEQh9VPe0LEvW82v3FdxONqEUpv9L_I4EgTCzmA,1984 +torch/include/ATen/CompositeExplicitAutogradNonFunctionalFunctions_inl.h,sha256=jnt23hMGJcAgfx6SBp52_mLThvBI-AzDPfKFsWEIsPU,26244 +torch/include/ATen/CompositeImplicitAutogradFunctions.h,sha256=3REKnKqUvdXDA9PDGmmx3B2Lu3ta__eBQX55ntQI5IM,1971 +torch/include/ATen/CompositeImplicitAutogradFunctions_inl.h,sha256=qGdgFvxuVOFlhj4PzOm_ENzIl6dShoJziQTteNO0rLo,34865 +torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions.h,sha256=R2Nb5wbr3bbfOSiqLZtJa2JazDXnbg2XX-xUn0aZQkU,1983 +torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions_inl.h,sha256=zPpmzVcthe0efVJmcYnz1EnWbn04TkoWlfsQ2-qlH-s,1126 +torch/include/ATen/Config.h,sha256=L7OLQRf6_GBdGnC8GX-rUuIETYpI6Q9CzkcJyaSI8zA,770 +torch/include/ATen/Context.h,sha256=q1EX9Agcq1xstXXWyNwbJCILPllrnTtSBtbb-IabANo,19237 +torch/include/ATen/DLConvertor.h,sha256=DIYUBdOoY8W9hlxJYiq1YManGWfiWcdZW0a-508Y_OI,834 +torch/include/ATen/Device.h,sha256=woU2HH6ul-aOLsILb-xFTxGbtA7mGnaMaJzzB-CrlBI,42 +torch/include/ATen/DeviceAccelerator.h,sha256=o5hQjmU88YiB_VQsit3usx3bEvPzhCbzmcQwlzaTowg,932 +torch/include/ATen/DeviceGuard.h,sha256=Gti6aPs2ibw2l3Ek4reRaGPRmQuLQIL9cxK7lJ_4TVo,1185 +torch/include/ATen/DimVector.h,sha256=hDtEu7TLm-rmIlopY3DudvGcP7BopSyWYAoce6SRrKM,46 +torch/include/ATen/Dimname.h,sha256=ODvWq78JatYnrvxjZb8taxy-nOBOC6VE0sZnSpxiwFs,31 +torch/include/ATen/Dispatch.h,sha256=Fyn3eM3PrYamv_qjasg-Xrav0e0Ct23Zj6673-MytRk,39757 +torch/include/ATen/Dispatch_v2.h,sha256=Kgf3eSoKmq9YRhFlgvrfJYcPt2OMGi5o3U4Mmr7tvGM,36313 +torch/include/ATen/DynamicLibrary.h,sha256=4MJsQ_OZ5MndH29Hi_FTPdxEEuCvMJM8LJdcHwqFMDE,572 +torch/include/ATen/EmptyTensor.h,sha256=Xm0VqHjMQXEWvmrq53FXRfLwjk9LJvRtqnAj7lpsh6M,4537 +torch/include/ATen/ExpandBase.h,sha256=nUXXodL4QrMGHb0xV9QpDjEJsG67gD6GHosIfNnrfxA,914 +torch/include/ATen/ExpandUtils.h,sha256=BvqQcM9nat6EU1vC-9stgPAmpkoMgsKAe77ieVrIdIQ,16263 +torch/include/ATen/Formatting.h,sha256=u9t8xVe-WAEXzWvHqFJ93K566ukel9wsbLhSEUeEqyc,34 +torch/include/ATen/FuncTorchTLS.h,sha256=1Rh_Sl0r0UOMpwzcl6_P1GEJXBgAtIGra6xE5t_B69o,1816 +torch/include/ATen/FunctionalStorageImpl.h,sha256=giJ7toki8ydM3BWwuKJP2dACvbmnzBao_OVYAa5DSfY,4572 +torch/include/ATen/FunctionalTensorWrapper.h,sha256=v4N49RvmQscQQ6R-gIlXN-oGOMnirIxBhenHRHVIzAI,16367 +torch/include/ATen/Functions.h,sha256=Apu0dxXVyPdyPEnwKYXt1fZpDAyizdjPsRD5W4h24g4,53221 +torch/include/ATen/Generator.h,sha256=KBeu-DIZBnbAWTvlDIPNIA7PMY3wFODHbAR0l-kToLc,46 +torch/include/ATen/InferSize.h,sha256=Llo6fygVimPrD2AXFkxTEEy4WhjV_5nnqZn8eMVCVh8,2613 +torch/include/ATen/InitialTensorOptions.h,sha256=Hwbswfmyx2diKA1DCTPukc246Fnm7kn_MOVXQmVrVDw,439 +torch/include/ATen/Layout.h,sha256=l9TpZf-gLtmQbbV7_dn0UFiOuV88PVS7V047YMCtM-A,42 +torch/include/ATen/LegacyBatchedFallback.h,sha256=QNBsZOnkz1buoh0I2HhKGyf3uxGh8NGcHq-AtADej7U,974 +torch/include/ATen/LegacyBatchedTensorImpl.h,sha256=LER0yf8y39WWD3WR27q_nJMXlAP6tf-026WbS3iRIHs,5559 +torch/include/ATen/LegacyVmapMode.h,sha256=w8ZTj-VP5xE5NMHEAGXqZE64gMm-i141FiOdWdNQU7Q,927 +torch/include/ATen/LegacyVmapTransforms.h,sha256=g0lBIYJ793Z5bMsvchyDxfExUt14w8ghWbjB-6t3nfU,7815 +torch/include/ATen/LinalgBackend.h,sha256=8FGeL3F7EUk5i_VVs5SHukfJhAQuXi7WtN5BNXXhDlw,719 +torch/include/ATen/MapAllocator.h,sha256=2QCORbUN5qqX8-3v9nwlCo0ldhiVo7BeVZyrvhPdEi4,3315 +torch/include/ATen/MatrixRef.h,sha256=vmdP82p5zmjixhn083cm68XzABVdVYG7Gq84DQWHQGw,2903 +torch/include/ATen/MemoryOverlap.h,sha256=VMIgtWjB4dUQORQL0AwDnVO7KBVmGYqQTaGhESKS5FM,1287 +torch/include/ATen/MetaFunctions.h,sha256=-j9AVqBE9r11XDj4Jp9l_1ywN8dTWXGDhRnhe_VGcYI,1950 +torch/include/ATen/MetaFunctions_inl.h,sha256=_nBGOOwjiUNtaC-SnsuuWK5imUbhDlhm5iH1jPg1CqI,15807 +torch/include/ATen/MethodOperators.h,sha256=zUlTJXKFi8LTThmkJ1ChMr33vmdTqoZoLjtMMeQUr7Q,15445 +torch/include/ATen/NamedTensor.h,sha256=DMs7TFFl5X2V_3sRIg9-qaiiC94x9s0n0SEdYf2SaHE,35 +torch/include/ATen/NamedTensorUtils.h,sha256=rgai9ySH21mI5eq-TJYNasX95UeHP0wzi9Y-kyEOBQs,6816 +torch/include/ATen/NativeFunctions.h,sha256=r7mC2YbQy4uGbdmlj4fyXkR37UMKR8a7Q8hq4y0Cc74,58682 +torch/include/ATen/NativeMetaFunctions.h,sha256=Myk7PdSuWiNGviLNrVf38ojaXdQNNPNqur6MhM8yAmQ,55254 +torch/include/ATen/NestedTensorImpl.h,sha256=Xej-lJvivoE3cIRCBezjI65gBhiD2IfvVIQVqAsgIHE,10051 +torch/include/ATen/NumericUtils.h,sha256=qHKlKqE502GATTuCdtI2Gme_QIKmrUQKJTt9QTIqByg,5086 +torch/include/ATen/OpMathType.h,sha256=mbrJU6cZdNFX-dJu_Je1FedoQCcHJsWRZjTIsZV8Lf0,1504 +torch/include/ATen/OpaqueTensorImpl.h,sha256=yelm7W9LY4haAf1jOqA_au0wkZkEgY3QMZHv0E6GbVU,6163 +torch/include/ATen/Operators.h,sha256=yADEe12pVX8NhcU0aId4yI9_g9nt8yJQQV6QjgOxAjk,56873 +torch/include/ATen/PTThreadPool.h,sha256=X2FolpcFacvui54S5s9CQPBQ5gvbG8VoF5sH1jkGtkI,391 +torch/include/ATen/PadNd.h,sha256=3JsvcDMvpdMZYbxJchOajFJ9dSZkJPMRqoUteVexHGo,593 +torch/include/ATen/Parallel-inl.h,sha256=P18LiFR88qOlKWs3Eq6bp_K3si6VmNvy02kYsIT3tHM,2293 +torch/include/ATen/Parallel.h,sha256=3CR1vYwRePktHasY4tiHkbV8mVk45hzF4Gv0Ujga8F8,4829 +torch/include/ATen/ParallelFuture.h,sha256=-VXbafsV86rduj8z2iD-VgPvFTiguQksGZWbjEUIflE,292 +torch/include/ATen/ParallelNative.h,sha256=5mm6FAj_i1f_XUv_uG8mwyE9Vuveg2xzOYu2UoOvXPk,354 +torch/include/ATen/ParallelNativeTBB.h,sha256=8LEgy32v5Me08IjCqbkBAOEFhhLwXrrSjv9Q70gpPDo,1286 +torch/include/ATen/ParallelOpenMP.h,sha256=VHE3xZuh-I2ijBlTBpsVUIAUfMpO3XQeajMJ7t0I-ao,1283 +torch/include/ATen/PythonTorchFunctionTLS.h,sha256=cYU_y4UtOz_UF1r0zctoFbUkR2Q0M-AJU7yJp12KtP8,1146 +torch/include/ATen/RedispatchFunctions.h,sha256=ClhPPCSNQSKOgXKbzebPTIqIpUpGzNcEe9qtAtdcpk0,2154960 +torch/include/ATen/RegistrationDeclarations.h,sha256=yF_AqYd1P706tF7R55WNcCGQP2GwIMBwbx_BYtavy3c,833476 +torch/include/ATen/SavedTensorHooks.h,sha256=rbVHA2Fvj4bPFJwLVGERO70hSdRlEo849o5l_anedN8,1772 +torch/include/ATen/Scalar.h,sha256=4uRhX5Y1wZouuAi4M8BriFoqJziRckfzIh1o7E3YS9k,44 +torch/include/ATen/ScalarOps.h,sha256=JmLX_R1RL80rE65DZGvrFzSr9Qi6kuANGCZqQvV69xY,1595 +torch/include/ATen/ScalarType.h,sha256=YpUjgU8zTuDmlNt8pnUpNYjKVs-sJ-YUs4enjKJr72k,129 +torch/include/ATen/SequenceNumber.h,sha256=kkx0_BUyfdTbwboiGso0GwMNJG_KMxCjjibslHit6M0,333 +torch/include/ATen/SmallVector.h,sha256=b0zRaURtL0paOFhxGgB4flh3HczjPSX6gQ_GQzOOtHs,47 +torch/include/ATen/SparseCsrTensorImpl.h,sha256=9d7DxUeB6ZTqqXzVW5E04yoIAWSe3-nOlgijondIK4U,6113 +torch/include/ATen/SparseCsrTensorUtils.h,sha256=SPYlUsWYQkvfQzXtkeUBuESIVKjQoWN3FyUljijs9cE,16130 +torch/include/ATen/SparseTensorImpl.h,sha256=JQkUP9AUlBWhoDIffXw0d1MOo_-vg9T1v24US7Qgy0k,14250 +torch/include/ATen/Storage.h,sha256=EgzD3SO1khvg7pZDcTsqoI0FFSlsZobb6FadLbAhJ5c,43 +torch/include/ATen/StorageUtils.h,sha256=2YW2GztTWHfE493VWxPhtJDvHpExCtwFl69ZTwk_OzM,1308 +torch/include/ATen/Tensor.h,sha256=ercOzXbYX_U4x-QpJ9H5rNwZ8kR6vku_MYQlzRInW28,44 +torch/include/ATen/TensorAccessor.h,sha256=0oPU5QjZ5q_5qJ54cCEa18Zas4Z_IMTVAT09j39idII,51 +torch/include/ATen/TensorGeometry.h,sha256=EXJGUyagrTcaj22uEDZQlNmsfBP8C1zZd33cR3zsTXA,4273 +torch/include/ATen/TensorIndexing.h,sha256=cCNqE9Ym8EBr1Pg2JHEMLuF6kB9K5igdprL9_esXm0U,23969 +torch/include/ATen/TensorIterator.h,sha256=nYX2UWr0SOagv8BPDhdOFooVgVGk18c9de7nQr4o_5s,37402 +torch/include/ATen/TensorIteratorInternal.h,sha256=AJwnjP_kN7rvQREEyoH2iOcRTow0xL6Vp5_NCWXntQI,1931 +torch/include/ATen/TensorMeta.h,sha256=nGgmEZS3d9bjDtv7T7BTf-LgohiSy9TmlWTJySFv378,4864 +torch/include/ATen/TensorNames.h,sha256=O492vZXH2YzIkKs08vpwRf0cvsguCXNZ8EZIvDsTUuk,2571 +torch/include/ATen/TensorOperators.h,sha256=OT8Pkg6DXXZDZoPjIHEBetJgsNyoTzBGB618lzzVxak,2554 +torch/include/ATen/TensorOptions.h,sha256=0YGOolxkjb6QzEmeZ6xuo0bamoTct5GvrHAtPoMH-fU,49 +torch/include/ATen/TensorSubclassLikeUtils.h,sha256=nGvG0gvacmv-W4KcDqXBQKSR7j7lwv57J25M5mu2sQA,3212 +torch/include/ATen/TensorUtils.h,sha256=6-zD6PC4fmwDLCoD8RjM683qEqfxgToeYZwcDuK9Omg,5958 +torch/include/ATen/ThreadLocalPythonObjects.h,sha256=EqG46_18Hph7JIFewnv3wiJlY4j1uowbGNa3JR23xUM,607 +torch/include/ATen/ThreadLocalState.h,sha256=9ZxJFdvL7tQ3TKq_sDadEg8ps_XZsbi_fxHBLr0nUr4,3806 +torch/include/ATen/TracerMode.h,sha256=QigJ0TulTga8gPinbwvwtZgUwi9xQmOUAwureQzsQeI,5522 +torch/include/ATen/TypeDefault.h,sha256=1KUqlbYBvhQj6kuRqvVwK3GpVoCgYWNIYGvEv35vUPQ,666 +torch/include/ATen/Utils.h,sha256=J8ozoc9oo1ZgCdHnl_Nl6_4pFfWzWl6hWYCAKok7DLI,3569 +torch/include/ATen/Version.h,sha256=sTW04hFh7RGM5RkbXoQKLDcwTP4Ks7GNDyTLr3tQJdY,384 +torch/include/ATen/VmapGeneratedPlumbing.h,sha256=XpI97EEqTDnEi9ct0hIUxkvcRROM5K0F_o_bUPXjS-k,1828156 +torch/include/ATen/WrapDimUtils.h,sha256=akUXA3JtwRH6oDuXly83ftoVTfpMJIbeJlOESvbiB00,4778 +torch/include/ATen/WrapDimUtilsMulti.h,sha256=in5mUs8tc_KbXMQSrnIHNA5ZSAr0mG1pYPN1gxsKdVg,1082 +torch/include/ATen/autocast_mode.h,sha256=ifHWioLo2cjW2wYR2XprHPI_N_9Lx2M3rkVNhiF_amQ,24219 +torch/include/ATen/ceil_div.h,sha256=TtkKnqzlAlpfznlNBIDaNUHxD8q1QRERVklj-VEm5Q4,497 +torch/include/ATen/code_template.h,sha256=S57xOHweK7LsCnjawbYGEpyi68gdoSaoGnSrX92ALbA,6863 +torch/include/ATen/core/ATenGeneral.h,sha256=dcnASl2yEZMXGYbsBQkH1W-KLBoQTSSoEfujumNJHjM,45 +torch/include/ATen/core/ATenOpList.h,sha256=aTsrO4WWb4s2HIBiOyha28F9RXajxvzINAGv3eQ5AEs,246 +torch/include/ATen/core/ATen_fwd.h,sha256=dj37GXi3sI-7Hoz4M4JLEHO2wh-cIENzENiDcYIZqn8,1024 +torch/include/ATen/core/ATen_pch.h,sha256=RTFebKocSHUxO6GjXDqGendNDulyNfjHVR0i6_D96rs,5250 +torch/include/ATen/core/Array.h,sha256=ddR3Ab8CuQh-WoO9_5waKKuP_Q130gkTzf-OU0XJv0k,838 +torch/include/ATen/core/Backtrace.h,sha256=Vi1LiTrJX5BY0ADLxoJkwC7H27H30tTPM89xZ04A5GU,59 +torch/include/ATen/core/CheckMemoryFormat.h,sha256=5bQA7sNFWHB4aJWV1qOGuw2urCnQrEDWpOUUr0ZSvfA,864 +torch/include/ATen/core/DeprecatedTypeProperties.h,sha256=HHRdXXkXici1l8KS4SAvZzTXtcshbrmx2OW7-G3e__I,3879 +torch/include/ATen/core/DeprecatedTypePropertiesRegistry.h,sha256=lsfZYkbb53SxjT9Tu-llz_Ams8mdKliTK6KAb0aMApM,813 +torch/include/ATen/core/Dict.h,sha256=jpIwmsES_ZGowrQds9ydu3fIOVcKjee8hhOMOKfY7oo,13250 +torch/include/ATen/core/Dict_inl.h,sha256=TYaiTIQJTvbfFym-bs8xc7W-7h_NsPdMAJ-OjqBx0NY,7518 +torch/include/ATen/core/DimVector.h,sha256=yOKoGLTzpQNSO-5Dc1iemVnT6Aa9mnjwtT6JpBhOfXs,279 +torch/include/ATen/core/Dimname.h,sha256=fmTk0qYzFGk1m3kwezkPs3Hjmon9_wnngna5CUmxD2Y,1178 +torch/include/ATen/core/DistributionsHelper.h,sha256=g-Roiqs_-_iboIA4igU5vDeINaW7xOQw-oR8IG3PvmY,12578 +torch/include/ATen/core/Formatting.h,sha256=Lmglbd4dcMvnHyAPeCHJXwujSNFZFMRg4w9CD1kwbrM,700 +torch/include/ATen/core/Generator.h,sha256=WSEfgLV9Hf1X1tCew80_1U109k-f16tOdHwUk4UhkTI,6385 +torch/include/ATen/core/GeneratorForPrivateuseone.h,sha256=yL2oxcTdSvNrfMB4UgGAkUBloWwuQ8nVH05TsSQAKmA,1071 +torch/include/ATen/core/IListRef.h,sha256=eDVQt0jRf75ByQkNczaq7ybVv5jIzPPIsbDcP_8WT9c,20974 +torch/include/ATen/core/IListRef_inl.h,sha256=b0eKGeNV--Q9S15UDjblx2IXV5wERlqZ0I4uJO3saVI,6127 +torch/include/ATen/core/LegacyTypeDispatch.h,sha256=OtpiQhk03P4M9Cxv7lihyc7sTNkEvbgyJSCyHzwh1dA,4857 +torch/include/ATen/core/List.h,sha256=QfnoB3aiiEvUzn8VBXh01zplHQgkbdM8tw6dy0x67Bc,16018 +torch/include/ATen/core/List_inl.h,sha256=bJ37vCqlsnCz7DzS96bG01OtR8ZKTIqOdvwcfSm7HhM,10895 +torch/include/ATen/core/MT19937RNGEngine.h,sha256=UE78lVAVtnNeB_XkGLD08Qaj-mW678NMmy7tf8qNKH8,6510 +torch/include/ATen/core/NamedTensor.h,sha256=BLLuZ6oUaj1KJ7LVRMMkyof23ByyEvFMg_d5NglB_Ak,5022 +torch/include/ATen/core/NestedIntSymNodeImpl.h,sha256=E8rSz7bhpM4W6Y3NHT48a5su53RUtznOzrvCioPb6jg,5968 +torch/include/ATen/core/PhiloxRNGEngine.h,sha256=nT1duXK3nsHoOuMt-HEOAGl_1vau4X5HYn9xNj8tY5g,7814 +torch/include/ATen/core/PythonFallbackKernel.h,sha256=iVeGxnFLNfhdDI0kk_zj6tWDkMTykt6pRurafEW9X_k,530 +torch/include/ATen/core/PythonOpRegistrationTrampoline.h,sha256=XCU-zPCjXswi9dtGOaTenkkcWxGos-ipbwZ2lvGIYD4,619 +torch/include/ATen/core/QuantizerBase.h,sha256=XqeyGj9_9k5-O8cnYeJ-3pxGFJKBV_KakN2muEPf6_g,2606 +torch/include/ATen/core/Range.h,sha256=v_kVnAoeiHq0eRTodrFqDV8nudjBOX1mwhdeiDrJRt4,418 +torch/include/ATen/core/Reduction.h,sha256=xGUWvO-GEE0IzsMSoCDZksIh5A0Sf1ZjQBGyBBRvqXc,461 +torch/include/ATen/core/Scalar.h,sha256=6_8TdN11df5vabWQCR30zjSFTLQbwnsUMTWfzKaM_sM,29 +torch/include/ATen/core/ScalarType.h,sha256=o6WgbV6_nD4gO6tVJo7Hx_NQfeXC-iB3TFXbfRusbBI,33 +torch/include/ATen/core/Tensor.h,sha256=ic0iD13h7a-4d9Cug9IdTRQ5DCJwqRaktitlQNz4ZAU,2108 +torch/include/ATen/core/TensorAccessor.h,sha256=AZaQHJAxPMX-5382XvtvvsGzBfp_eanh3dxztmVU57w,10556 +torch/include/ATen/core/TensorBase.h,sha256=XFn-7NVCw6Lld_lepAMDA6sCrWGAdSs26-VmWdUnXMk,38076 +torch/include/ATen/core/TensorBody.h,sha256=dSkqkjz-l5Q1zvkh8KFezC_5zRzw8BN1ROKPjY94rNw,289105 +torch/include/ATen/core/TorchDispatchUtils.h,sha256=eqHYKOR49kelVxC8FXHvadtkmVayulRLHr0XXzs-fWE,480 +torch/include/ATen/core/TransformationHelper.h,sha256=TmWTfQh6LLMY2Yb-mb10p_hzF_Hyl7ef6IYQ7K-953I,6857 +torch/include/ATen/core/UndefinedTensorImpl.h,sha256=gC73nEbVD9sYFdMxGPovAHH997995eRiDYXO3S1y5Uo,42 +torch/include/ATen/core/UnsafeFromTH.h,sha256=bQyv5mA6MEL7f6hp0LIQYaHBaQVilgt_frmUzNCD28c,708 +torch/include/ATen/core/VariableHooksInterface.h,sha256=s81mzA8dtGFx6Ely8CVI1IZG9HCFzZsTheWT_11TI18,3505 +torch/include/ATen/core/Variadic.h,sha256=O3ruXr8uO-sWugvth-UMczE9Bzd-nZICMXf9aJmF-js,2439 +torch/include/ATen/core/Vitals.h,sha256=bMBRjftWlyzAlU5p-qVMs5Am_ppfMV4exyXdT9B5XQE,2386 +torch/include/ATen/core/alias_info.h,sha256=nk_ndcIKgjcGxJ8sko4IzWfY0JGzIk8XYaZwAdfjHxM,4160 +torch/include/ATen/core/aten_interned_strings.h,sha256=gU_gWLkCXYZHMrSjAcDRF4ePj_z02vwJTVGRCiEiBbE,54030 +torch/include/ATen/core/blob.h,sha256=C5cv0-nwoFI0P3Lua1hCfJT8U1R76D_bof-z4g22TJw,5372 +torch/include/ATen/core/boxing/BoxedKernel.h,sha256=SY8En44wDTk8vtWO1CzPUdokN5x3YWehacJoJLx7N4c,7924 +torch/include/ATen/core/boxing/BoxedKernel_impl.h,sha256=pHz9otw_XAcNlLX2jXtkIUjqT1Wg8q_W9a4oRvfTkRE,3261 +torch/include/ATen/core/boxing/KernelFunction.h,sha256=LTWZ9HvCkDZjkqhMBHnPE3SVMfBoDNx8-3IocU3hFpU,8535 +torch/include/ATen/core/boxing/KernelFunction_impl.h,sha256=q8pXmzPgLinH0s_OGbaesDZXSaFeHxIp1Qz4PS8awcA,10690 +torch/include/ATen/core/boxing/OperatorKernel.h,sha256=fkeWwwDc-UjCqu10E0K69Jdf5h5Uay_BXsEv1Do8wHs,692 +torch/include/ATen/core/boxing/impl/WrapFunctionIntoFunctor.h,sha256=AvWOZxgDAqErgFwkc1s2wVMod8j4lBv5H4aW6XIQZBk,1313 +torch/include/ATen/core/boxing/impl/WrapFunctionIntoRuntimeFunctor.h,sha256=nIpD8XFNKEIJdR6RgF9d3-N0uOSBgqKYIzBw6P0iBVs,1454 +torch/include/ATen/core/boxing/impl/boxing.h,sha256=N6Vj4UQPRUGRgr23LXpjLbJWwQZzBIuW0fDVde209E8,13245 +torch/include/ATen/core/boxing/impl/make_boxed_from_unboxed_functor.h,sha256=wFsNAh1sN1lOwz8hx3N5cKIQYtCPsY46mLU0ig52yw0,30873 +torch/include/ATen/core/boxing/impl/test_helpers.h,sha256=4Mm5y1fbiG2WAz-hExEm-JmEUd38iktQenClw64q2Qc,4296 +torch/include/ATen/core/builtin_function.h,sha256=EOobCpJeaEZKID46YX3CcJ1C9KsYofZny7xqMPXob1A,2044 +torch/include/ATen/core/class_type.h,sha256=kaNpTw9iFHbcWB9mP30jO_vzNJnxgVSL_0bZkt415Aw,14067 +torch/include/ATen/core/custom_class.h,sha256=K5zORoYA965P8p4mtrEBnTXN7HzMA1x7KECVMrvTPG8,744 +torch/include/ATen/core/dispatch/CppSignature.h,sha256=_TpTmgWGkSTiqcKevLVZOJMdDZsekVjcXUdiYvpTDEc,2455 +torch/include/ATen/core/dispatch/DispatchKeyExtractor.h,sha256=D1aVipyP95t0kbIZW7ZMUtwZsHRDaEbugogpwy3IK3A,9676 +torch/include/ATen/core/dispatch/Dispatcher.h,sha256=qi-xFFkT4xutue-7kfnE9H0hwnIz-gtCpauME33dWKc,33308 +torch/include/ATen/core/dispatch/ObservedOperators.h,sha256=GKoSUqGxIkIkNOO415E5tOFAUr33uxrk_tL1vWpo6G4,329 +torch/include/ATen/core/dispatch/OperatorEntry.h,sha256=3N9odrpxn-2EkIXlyF5B3KyETpOy-Tvi5WgNmTOLUa0,12898 +torch/include/ATen/core/dispatch/OperatorOptions.h,sha256=Kzc_qB8w3bMoyojv5RuhPcPaSRd64V_etw_n4blnHIQ,923 +torch/include/ATen/core/dispatch/RegistrationHandleRAII.h,sha256=e-Mj1D2ucxcOFm_VvYWsNuRxasim7WyrfkXvlfSTIhY,858 +torch/include/ATen/core/dynamic_type.h,sha256=cWV0ErFVGSQHBNrYwK0Duux7D8uvBvP7oRU0zvTOK9w,10407 +torch/include/ATen/core/enum_tag.h,sha256=tZGEsJTRZNp2OrLKMeCKKFiu8esM-MaB-k9BxWhpR5o,455 +torch/include/ATen/core/enum_type.h,sha256=CPPPdvoO9weu3fMQ428x1vv8viiM3IUfdYOv3P9TaDc,2758 +torch/include/ATen/core/function.h,sha256=YibcseRYQojBpVAT2zetGRBWsj1W_z6SgBt3AdUxh7A,3393 +torch/include/ATen/core/function_schema.h,sha256=HwvD5IXadPaorV3tr2JxnHfZatP8v00u2W032kqM0B4,23947 +torch/include/ATen/core/function_schema_inl.h,sha256=lRuLdbt1u8mH-_iUy0H-nRwVKucxHx_Mi6ZQgkYmQoQ,14988 +torch/include/ATen/core/functional.h,sha256=sbPeH2KDNZ2JnaexgBlYvLg4ZV4GJrs3XY8HLov3Rbw,1460 +torch/include/ATen/core/grad_mode.h,sha256=uhkLSjH7WfIVojVuftgyWZ92HPS41dQiwclS9Sk4QOQ,210 +torch/include/ATen/core/interned_strings.h,sha256=bQeyda-izgyjM2J5uULW9fj1JFobC9RSWyqae03Aqq8,13431 +torch/include/ATen/core/interned_strings_class.h,sha256=Cbq56u1FJD8op8r1kX4G96PCOb2Lw7xdGMYZcqX7ajk,760 +torch/include/ATen/core/ivalue.h,sha256=zaQxIrTbxEyPOVZpj_0FQP8iN6wgtgZyLyi-ejGLmuw,50254 +torch/include/ATen/core/ivalue_inl.h,sha256=WX9J0-vqulvskVm4Aum3Eh7MyTJevxyU3xkXWa8N2X8,86865 +torch/include/ATen/core/ivalue_to.h,sha256=8EZ5vbME27AVJ8AiBbT7jcvxzWCvGlTNS_12MWCdXK4,756 +torch/include/ATen/core/jit_type.h,sha256=purQd4UygGscx6asUKGazOKXySWPuChaxd8-4ev2fX8,71775 +torch/include/ATen/core/jit_type_base.h,sha256=e-47dwyC7OIXnAbu1mEWCjUZEKHxMtxfpNx_2Tmg1EE,23206 +torch/include/ATen/core/op_registration/adaption.h,sha256=R--_LD1PxrecO5xzYLR_Df_bSZeaz15ODDBSvxapdiM,3201 +torch/include/ATen/core/op_registration/infer_schema.h,sha256=1afrXaYrEnSY7-_ILwQjKl3meo2aH4yeh0S1T8Jv-Io,6781 +torch/include/ATen/core/op_registration/op_allowlist.h,sha256=2K-zPwiBAzTNsa0-db0xatdI2h0IgcUpZlj2jNakzvk,6891 +torch/include/ATen/core/op_registration/op_registration.h,sha256=VOp1HXeIiW3gF5Vq66NTByW0l7VI87k7aB-kOimfMH0,28639 +torch/include/ATen/core/operator_name.h,sha256=Bigj5XgdGA63OBT_5f44Bf0KkO7cRo530FkVva-lOrk,3018 +torch/include/ATen/core/qualified_name.h,sha256=0dN_w0uzEKRTrRVkIifW685vE2MZRte5XrQJeMnluZo,4373 +torch/include/ATen/core/rref_interface.h,sha256=-R8DtC-57uYmqAgGXh-3Guu7gHLRnxpkgJO4L5wMEnQ,1138 +torch/include/ATen/core/stack.h,sha256=bXUd2uHlT9Onhc0AuiOu9t_dpTK0YxU5PqVaAad4Feo,6076 +torch/include/ATen/core/symbol.h,sha256=2biKjnmqHB4tRsXCmK_ioN6RcBq_DCUN9ntusaosqj4,5874 +torch/include/ATen/core/type_factory.h,sha256=SUgeuP5s3d4XP0GKMviJP5VZdQrssZ1I38CfLH6duSs,3252 +torch/include/ATen/core/type_ptr.h,sha256=W6BF90VCwf-4hEKj357ZldZFdOBQPskm9z32s5Oe8d4,1223 +torch/include/ATen/core/typeid.h,sha256=kuExuy1u5A34ATIuUUgf_aPWYvKKXQwfE0OLtHs8hhM,29 +torch/include/ATen/cpp_custom_type_hack.h,sha256=j_wxuMgOWKLv9uotd8SW3Fm3QMyvVU9XQQePdrao1fM,5430 +torch/include/ATen/cpu/FlushDenormal.h,sha256=QqfyFZmXGzLL1WuhGhc7SWsNq6-TARAJufstsTuMjQw,537 +torch/include/ATen/cpu/Utils.h,sha256=015QCShlG2__MCLyvcyZjrJddz3RM7pu61DP2cH2hl0,189 +torch/include/ATen/cpu/vec/functional.h,sha256=PznpXDxQCMjC8FX6vXq8opByq5PY1JElx5blu6kIttA,102 +torch/include/ATen/cpu/vec/functional_base.h,sha256=plznKgg52-WsNYbYPx6t-Sizu4RzHY_cBg96LudHC_g,11760 +torch/include/ATen/cpu/vec/functional_bfloat16.h,sha256=V-9mMXiSH0er9dYY7_vqdomTkIveLx02EPQbBsMHfX4,24678 +torch/include/ATen/cpu/vec/intrinsics.h,sha256=9qCBxPS6Bk0QQ94mj8OVlZ5f-cHuq31J0waxvnsQfcg,1880 +torch/include/ATen/cpu/vec/vec.h,sha256=THgzw89WYyXflSsqA-qvwfFV39r-i4t8mkS-xkUk1e4,1284 +torch/include/ATen/cpu/vec/vec256/missing_vld1_neon.h,sha256=iUZEGw4kcopg806wRIVP-R5Z8YWxRpUTqXauRcy8yKY,13559 +torch/include/ATen/cpu/vec/vec256/missing_vst1_neon.h,sha256=1bgQ5STR5_8v-jf2MPYWv9b-q8Px_aUKcI_BKN18BTs,282 +torch/include/ATen/cpu/vec/vec256/vec256.h,sha256=0l0DCJ3KICeLiUIYwszj1IAA4TtFaYCaoX5R_7eS8Z8,10680 +torch/include/ATen/cpu/vec/vec256/vec256_bfloat16.h,sha256=hnrhWAamHfe7db43Ayvt252G8CVPA1oyqlbuPWbEBdM,39256 +torch/include/ATen/cpu/vec/vec256/vec256_complex_double.h,sha256=ZOLRz1mvLezWoFdgWgSKVnqD9wOUpSL7IlU6GztsAr8,18145 +torch/include/ATen/cpu/vec/vec256/vec256_complex_float.h,sha256=NFzki8Y-JWXP0UA0TIjd8JdDpk9swLCQRq8qNOblRwc,19950 +torch/include/ATen/cpu/vec/vec256/vec256_double.h,sha256=i3w3IH7OLI_OcGRN5nOKrcHEJi81ZIX2mfg7TP_jqIA,14657 +torch/include/ATen/cpu/vec/vec256/vec256_float.h,sha256=L4sq08B0Edw7Jm2ma-_nTuQVDwj6OYQoRPQFC4rXAI4,22219 +torch/include/ATen/cpu/vec/vec256/vec256_float_neon.h,sha256=UkVc5fKRLjXAMWEnTQhYTLUuRxJhu_XFLc1pSD3zYd0,29600 +torch/include/ATen/cpu/vec/vec256/vec256_int.h,sha256=d8_yhCcQwbeD6RV4HdHNe7n6ax4aiPQRbkyieNxEhIM,60627 +torch/include/ATen/cpu/vec/vec256/vec256_qint.h,sha256=COv-aKPI6m3AeqbRu6DBZSeaBis24Gp7pflf5PnYbp8,47162 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_bfloat16_vsx.h,sha256=BBlP5r-I2q2DRRJtU2TR810coROiLtZqRm8Es5F0-1g,2113 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_common_vsx.h,sha256=JXWFwf8ksihkmePgOVKaNqOIY-O3FOCzoZlLYGOSF7U,8052 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_complex_double_vsx.h,sha256=v3PPxSdHtSrkkV976UFfSDlz-qCWsg1noBQBfKZLTWM,17902 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_complex_float_vsx.h,sha256=l67cObgRnHusk656n4jy6_ueQdaoO-b26uHsDTMtCQU,20282 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_double_vsx.h,sha256=hICywtrJrR3on24aOfY7SojJ4qEC284Cd1J7seTXYcI,14287 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_float_vsx.h,sha256=kpPh97qG4zOhwpRXbrTQaFkEGH0_X6FcRR9unzGNPCI,14715 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_int16_vsx.h,sha256=4oocOZ-v7tarE18kkjoUSb2P6-NH36A4MlCbNIM6_ho,12619 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_int32_vsx.h,sha256=5DwLXRz69_FaLO5f7owU8dSnNmJCbEiqeuQj-v1557w,10447 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_int64_vsx.h,sha256=afGq99Ht4_LImVdkmdrRMO4Wt-SZjiDWvq7DfTRnjDk,8686 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_qint32_vsx.h,sha256=6rJOaIoTV-3v1vkODHhqtai39sQ7xYp1Wnh0yKVB9P0,8197 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_qint8_vsx.h,sha256=tHbnjhMYFSjaLk2_opNEz45RUZuKf_kzgoB7S8tD050,15137 +torch/include/ATen/cpu/vec/vec256/vsx/vec256_quint8_vsx.h,sha256=Phs-7EMZbvDJRrI9Hj_qSBwvJNz97C2jyY_uYfsVCBI,15793 +torch/include/ATen/cpu/vec/vec256/vsx/vsx_helpers.h,sha256=YTXDZsKMSfQN8eN37sxnTDzEtfVUlkNEXutDTvwb6RE,20059 +torch/include/ATen/cpu/vec/vec256/zarch/vec256_zarch.h,sha256=zx3lj2qi32CpyIMFVOmUU5bp0sJ_MuKiH_EVnrZDDag,85140 +torch/include/ATen/cpu/vec/vec512/vec512.h,sha256=kvfF_ZfQYH9D38YKNaKFjRNRck7PC1BLDUhN-5khpaY,9788 +torch/include/ATen/cpu/vec/vec512/vec512_bfloat16.h,sha256=JMNn8yEjC94mlniiYZJZD6OU0qj5Iluiah1N0Z6xKN4,62225 +torch/include/ATen/cpu/vec/vec512/vec512_complex_double.h,sha256=s9QQSW2yCuUMhCLurFUox4HfsAyK7MP1OuGIdlyqyVI,23506 +torch/include/ATen/cpu/vec/vec512/vec512_complex_float.h,sha256=a8jzgusRzZqNQmWNHsRcIvyTQzN0-xcsTdWqMan_FyY,43700 +torch/include/ATen/cpu/vec/vec512/vec512_double.h,sha256=UOguJJGuFVJbckJH4XmI0yFxTBQuQLy00yG9KtQxaXw,16588 +torch/include/ATen/cpu/vec/vec512/vec512_float.h,sha256=k64al61QF8P53TgJEfDBILwp3CF-8xpALwlM_p5Vgqo,29362 +torch/include/ATen/cpu/vec/vec512/vec512_int.h,sha256=EWOTd0q7AlENt6A49MUOjXZIgaBKvChrlQq5OSetjhQ,54519 +torch/include/ATen/cpu/vec/vec512/vec512_qint.h,sha256=GRl26suntSfuanWKzUh60nIJhTl51jB_G1nVCS9jX6E,47084 +torch/include/ATen/cpu/vec/vec_base.h,sha256=r1KBAwfa-gmsgGNz1bkWy9fMRx5ImfKt0PhlYrpTMbo,41023 +torch/include/ATen/cpu/vec/vec_half.h,sha256=UuK6ECbFwsYk2WkxuY9lDq4O3LQEQdpTsldHzZne3Qg,1388 +torch/include/ATen/cpu/vec/vec_n.h,sha256=ukK2qaCuS0cTCZN-5fesyAYprm-OYF3_LpcdAQJzjqk,11402 +torch/include/ATen/cpu/vml.h,sha256=E9OeTgsVJl0tDFjUVWZ44d5PouXQ-qUO_BD6i5XhPR4,6099 +torch/include/ATen/cuda/ATenCUDAGeneral.h,sha256=hzsZuf9MUxBbRSSpsefJgyxO9RnmYcnfdKYOKFEfIwE,190 +torch/include/ATen/cuda/ApplyGridUtils.cuh,sha256=OznX8USe4TdDRxZMO2O0VH7wlbxOY6wkGOdw1Ycdpfo,1309 +torch/include/ATen/cuda/AsmUtils.cuh,sha256=LQzRGYOe3jlVaNogJAUH-v9fldTuGQQshcNNeU4JzD4,3394 +torch/include/ATen/cuda/Atomic.cuh,sha256=443ddaBbPsM5aKHaUpgQl3YaL653gsZM9QeWKZtXlRU,26818 +torch/include/ATen/cuda/CUDAApplyUtils.cuh,sha256=QRPaDCmeCNrozKO-m9OcJEoIYgJHvxAdB1dMOYIoyN8,20446 +torch/include/ATen/cuda/CUDABlas.h,sha256=O_7VrZnd9_4GXkwhF0OW-BwaV9pxwE4t382cRxfQULQ,13693 +torch/include/ATen/cuda/CUDAConfig.h,sha256=cwpliAylvjcwIGEyIpqB86v-He9quxJ3mWEKmJk-N84,886 +torch/include/ATen/cuda/CUDAContext.h,sha256=Ig-8EeKPP61vhcGchq20bULnvd-b4RkqJE-PGXs0qcY,238 +torch/include/ATen/cuda/CUDAContextLight.h,sha256=Vrq88hTgE4FDAnOi_aB4pxHO9WSsxvf0tbh6xRECm9w,2852 +torch/include/ATen/cuda/CUDADataType.h,sha256=WsyaYFkIufNxQoqFwoc_8iLV30yZzhjDB78GDF0C6AU,3115 +torch/include/ATen/cuda/CUDADevice.h,sha256=1n4a7Uxt4i3pixkfEVCh0fiz8ExGeaeQ-kdUzFp4Dlo,532 +torch/include/ATen/cuda/CUDAEvent.h,sha256=9tLf18UAfenJ9yfwrQIKWx-fE8GdoEzp8uAj7L3QThc,6783 +torch/include/ATen/cuda/CUDAGeneratorImpl.h,sha256=1hy8nfzGZo7LrSCov9lLcmYvLK90TI9uheEcF0kgdIA,4848 +torch/include/ATen/cuda/CUDAGraph.h,sha256=Fw3aOyzrFcwVKqDDy_EVGl2FTdQdbfL6JEXUVkcWtnk,2989 +torch/include/ATen/cuda/CUDAGraphsUtils.cuh,sha256=xfjQVlz9XD5vtCr_cOQ_BVBRsGATNHhdSAC0JImqyXY,1978 +torch/include/ATen/cuda/CUDASparse.h,sha256=T1uHf6dcvLFCwapOCNhUkZ0ZQS264vJ_fPnE-Q1iZ_k,2659 +torch/include/ATen/cuda/CUDASparseBlas.h,sha256=2fSHeA4LmKmiEfrU4l0mVKS_3WxkG2k4uTrp4Lr9cdc,12703 +torch/include/ATen/cuda/CUDASparseDescriptors.h,sha256=LEbhM88hvAZj7FuyBo93-CSpqe6sXH0G65gX6BKEYwg,9377 +torch/include/ATen/cuda/CUDATensorMethods.cuh,sha256=cyQq_CW-cqTVYG5n2yQKI552IDhMnlGZqFPurRzdUk4,270 +torch/include/ATen/cuda/CUDAUtils.h,sha256=agWW0ofbSjZFEJyLb5rueLR4p0-4S6Z-AN8trrvch40,416 +torch/include/ATen/cuda/CachingHostAllocator.h,sha256=RrHe7XCgvS6heFj4nBU7GjBKhJQqvWlToA5wtRKRYk0,1395 +torch/include/ATen/cuda/DeviceUtils.cuh,sha256=M6xUbeOJBa9xF8gPLhSG7AIMDbK4e9B1avhM2eXLXXU,3280 +torch/include/ATen/cuda/EmptyTensor.h,sha256=9kcrFfIGV2npF6GgAfVd__WOy5dqjB57Xj5_FwpcJb8,1206 +torch/include/ATen/cuda/Exceptions.h,sha256=ItOrCvrhFoJK-VA3H7WNAgj3sfgrTonqquVE2vrTrpg,9894 +torch/include/ATen/cuda/NumericLimits.cuh,sha256=Pucf4S3VEL-sT52Es3G9iXpX9WUXGjwR1-RvN1-6Hww,5214 +torch/include/ATen/cuda/PeerToPeerAccess.h,sha256=EMjud2nmOSYQsodrAYW_N6ph8zsRXYRPjrAn-s1NrZo,239 +torch/include/ATen/cuda/PhiloxCudaState.h,sha256=9ChfldlFF4J6Qcr7VNBtrQ_-jKVoQquIOuJKLYPXz0k,85 +torch/include/ATen/cuda/PhiloxUtils.cuh,sha256=pVnvthsuIHgFnebV4_gj01KXpuo3Fgddc3cWi1uswzE,95 +torch/include/ATen/cuda/PinnedMemoryAllocator.h,sha256=bfqZXydAQC59Kv3VBwTvVyUVoK2aazh9Qoh9Qvo9m94,245 +torch/include/ATen/cuda/ScanUtils.cuh,sha256=OolU3qBsTJupQmcl407sFTkepxZ7gdUO5xi1i1iBQxI,2027 +torch/include/ATen/cuda/Sleep.h,sha256=oh__MbfA1smV8bkqZIwz9-W4R4PB9vuh2G7BQzGs6mc,225 +torch/include/ATen/cuda/ThrustAllocator.h,sha256=JgK1MhDwoM1x_OSXcRaZqE6WmZ3DonmAWc0Z8WKiEyg,505 +torch/include/ATen/cuda/cub.cuh,sha256=pnvntiE9ZAXs0H_UD3sNYyZ5Pa11T2V10pNtU0PJS8w,15263 +torch/include/ATen/cuda/cub.h,sha256=ShHxTFdAfPPq6Kv6qWibU1C6nkulnBX-hkIgBJVm1S8,3373 +torch/include/ATen/cuda/cub_definitions.cuh,sha256=oZ_AOGaE8MaiagHPLDyoI39QhX23HNMwnOyKAMRck1U,1452 +torch/include/ATen/cuda/detail/CUDAHooks.h,sha256=d0WQ3kTRROLQohsFqcbRmcIBRt0yv4iHAbsAgYJZfIs,2214 +torch/include/ATen/cuda/detail/DeviceThreadHandles.h,sha256=F57VRaNBgNlvDq618YLluy14j3zFypTm7YIxseW_Ep8,7008 +torch/include/ATen/cuda/detail/IndexUtils.cuh,sha256=QsNiULyx5AnY9QiQwxLDxOHWAyKGCynWM22UOXa65e8,872 +torch/include/ATen/cuda/detail/IntegerDivider.cuh,sha256=qPJfE_dg2VjrM8lgNt7YVA7ltRg-X1qt92XJCSW-w_o,4019 +torch/include/ATen/cuda/detail/KernelUtils.h,sha256=6B57xlTkXWn5KX9uMJzDpU6w11OVyLNsufwj1pcRDl4,1523 +torch/include/ATen/cuda/detail/LazyNVRTC.h,sha256=mxEGFOoO7658DXR0jEe_TtUN0UShNHVM7xokcFufs3c,220 +torch/include/ATen/cuda/detail/OffsetCalculator.cuh,sha256=95SweK3n8bOBlLqLEaJNKQpuZbOrbW6F_PUUD1VzHm8,4431 +torch/include/ATen/cuda/detail/PhiloxCudaStateRaw.cuh,sha256=ZRzQ2coo7J_Cl65p_FtMZ092-oSfX71NtBzSXf-mKVQ,1354 +torch/include/ATen/cuda/detail/TensorInfo.cuh,sha256=Oq02D7A8aFXr0A1f5IG8vUa5arVyGiLJwI1B2sFhpIk,3239 +torch/include/ATen/cuda/detail/UnpackRaw.cuh,sha256=pMSjIYoTq_pLkG-Tvwlzd2nagrp3gSJlCpI_yXPYnhM,1462 +torch/include/ATen/cuda/jiterator.h,sha256=yfP0SBXGIcp0aZq4N5TqNF8XDSmIqgENZeGac4xd9ik,960 +torch/include/ATen/cuda/jiterator_impl.h,sha256=_v2_Ms8lNjS2LFQ14JAV1F2xnHylqcc_sk4u9oOE8ZA,7104 +torch/include/ATen/cuda/llvm_jit_strings.h,sha256=xBnyc1FWrmVgnFrIS-tvwHdINw5reXg7j1W6wAHsa7c,428 +torch/include/ATen/cuda/tunable/GemmCommon.h,sha256=z12YEFdwunBBooVFq1_ScMUqc9dJRlsJQgiHQjLTBpI,4988 +torch/include/ATen/cuda/tunable/GemmHipblaslt.h,sha256=TVs6A1-Qin7jMdim2zfkEIl_hzpp3vETvyGG_4QkxVo,11993 +torch/include/ATen/cuda/tunable/GemmRocblas.h,sha256=XIH_6tbY6dZoWk8Dk-f__wVt1ANPdgPaTsVrWIOmm9E,10198 +torch/include/ATen/cuda/tunable/StreamTimer.h,sha256=KPKVTHwA0Kfd7zdzpBmu_L-TLGK_QccBSXy6kXSvkIA,776 +torch/include/ATen/cuda/tunable/Tunable.h,sha256=u1sYXzNfMEo8gT5NG0EYNJTtajwI6P2Q5ugabYidXEU,5948 +torch/include/ATen/cuda/tunable/TunableGemm.h,sha256=T__SKJIZ4_R53j_Y1DRg1cuWTD7Buf6VXsd6t2MVCL4,9159 +torch/include/ATen/cuda/tunable/TunableOp.h,sha256=D4Jd5y5cgJnxNhKmNKzAAqUe5Snpk4Atnt66jY4IOMw,8387 +torch/include/ATen/cudnn/Descriptors.h,sha256=6kS5k3yj0logSqW7jKAJZhCb3a2z7K8Xq-mkVZQEcYo,14298 +torch/include/ATen/cudnn/Exceptions.h,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/include/ATen/cudnn/Handle.h,sha256=TuMzX-lyr4_V_qekHi39lJeLx-Gm0V4XDET-Qxo1z7k,205 +torch/include/ATen/cudnn/Handles.h,sha256=y6xfj3ZCKYNVzohfiFqsqeNSeXCpHSVqtB7a5WLhF3g,44 +torch/include/ATen/cudnn/Types.h,sha256=vyaGyS9Fbez77D-02fpsAcsj7P82KXOJmJBQoaETECU,322 +torch/include/ATen/cudnn/Utils.h,sha256=OAADb_jWUmykKpMTWDgCOz5LotXGjbuzIgO_9mVF4qw,577 +torch/include/ATen/cudnn/cudnn-wrapper.h,sha256=jN_nEntbXSmalFO91iIdjHawvefbEahucG8oHZGy6-8,493 +torch/include/ATen/detail/AcceleratorHooksInterface.h,sha256=DZSmiASF2yG4fgoEzd9teX931GoI5rWAoRAqx6wpFpM,666 +torch/include/ATen/detail/CUDAHooksInterface.h,sha256=qnBXe0B2yhB16wy23bWtIUz-lkPXB0D3YICCA9vMs0o,6983 +torch/include/ATen/detail/FunctionTraits.h,sha256=gZXUnOwqrUBfgLMosAfQQmfqVuF6rmZTlAB9TJZBk3E,3056 +torch/include/ATen/detail/HIPHooksInterface.h,sha256=fXDuoJXNooUyHJYS2m8twsRlUhLEFW8pYp8zmWA7OV0,1902 +torch/include/ATen/detail/IPUHooksInterface.h,sha256=7qE902FJwvpkgiX8WQO-RpZTzOjOf-o-wdANa_95oSI,942 +torch/include/ATen/detail/MPSHooksInterface.h,sha256=HOH3B7kyttTK5a2efx8svXtQi_czwybvdvx_02KAvE8,3111 +torch/include/ATen/detail/MTIAHooksInterface.h,sha256=OoV6KNY5IStWdetZRK6z4QAsCOLSbn8vUQ0uK1Y2CGM,1478 +torch/include/ATen/detail/ORTHooksInterface.h,sha256=w7bxdmdKsM8IgrRa1bmqkr0WmdrDhO7MKMBn3--6fu8,1113 +torch/include/ATen/detail/PrivateUse1HooksInterface.h,sha256=Kb93mKea8WuSEH9_v9yKREEYc_mDAd7ra89xiTplsN0,1984 +torch/include/ATen/detail/XPUHooksInterface.h,sha256=EhdDAsEXkc-3yOPezFFZRo37aRc5riMXhecabqrBCmI,2456 +torch/include/ATen/div_rtn.h,sha256=sPoWObIG7LtKrAxw_5aTCP-bqVotCNujmu_P0kzgN-g,211 +torch/include/ATen/dlpack.h,sha256=Ez2J0vriZJ6zhxAB8gyW1LYpbHaQ9Z65KkQgIbu9RzU,6854 +torch/include/ATen/functorch/ADInterpreters.h,sha256=-29jJLOGOyQb3oEA9TC5VEJig-INBgJiYAoh1GpUWX0,1560 +torch/include/ATen/functorch/BatchRulesHelper.h,sha256=vP4Mg7BTj-RyRxlYCCBFCEVPu3VcYpoRpYitw5MloVM,18200 +torch/include/ATen/functorch/BatchedFallback.h,sha256=bVftski7cdzVm1XocpesCC01mKpuw10BK7f_MDUlV3U,3439 +torch/include/ATen/functorch/BatchedTensorImpl.h,sha256=OXIswooKaH7M0aK17PFVv0EkiBbmcSMUqC_LyGEg6ec,6396 +torch/include/ATen/functorch/BatchingMetaprogramming.h,sha256=enOI3mOiGHkDt0lyD4-psit0pfUdi0DN0VdoSwBM3K4,4940 +torch/include/ATen/functorch/DynamicLayer.h,sha256=vMxkzD_O0omVFHpu9Q-ltMh_mYWXde6Phywm38486W4,5472 +torch/include/ATen/functorch/FunctionalizeInterpreter.h,sha256=1wgCr1aYCHCafvUISKOkRq4UKq32Xb2Bu5vAVhejnOs,907 +torch/include/ATen/functorch/Interpreter.h,sha256=tIMXFs53XkOGVUij0-A7aZP0HtT9cKlBswQ2IE8Nstg,7863 +torch/include/ATen/functorch/LegacyVmapTransforms.h,sha256=U7xVwSM6IhczoBOhwup2PAHCI0cFgi90EWs7MZWXA5M,8241 +torch/include/ATen/functorch/Macros.h,sha256=KVN3mhngmrlRkvlHdP-X28YRu4zrvfxVBW_j9PFoR-w,50 +torch/include/ATen/functorch/PlumbingHelper.h,sha256=LHdLlEJZYK3cJJmLFT6kjX5I58LrdZvqen3PLSGWclE,2838 +torch/include/ATen/functorch/TensorWrapper.h,sha256=oHUF3f9ZTersfTNQoYzshKiaUZq8aCnMxr9M74mO754,4021 +torch/include/ATen/functorch/VmapInterpreter.h,sha256=n_Qh7KijuFE9YImBryejjToM735303IN1K9LbwchexA,957 +torch/include/ATen/hip/impl/HIPAllocatorMasqueradingAsCUDA.h,sha256=47pJM09o3ljXjP-_iBQsXkMe1FMcdDU7dT18E1L9Pw8,997 +torch/include/ATen/hip/impl/HIPCachingAllocatorMasqueradingAsCUDA.h,sha256=lwoGk5s7GA1FSagtjE0T1C0xEnhNbWWia9TOu3sbkg0,517 +torch/include/ATen/hip/impl/HIPGuardImplMasqueradingAsCUDA.h,sha256=6IdKSUZw-vrrWp_rFAOc789l7gO6ELk9K6yr9JGXHDk,13949 +torch/include/ATen/hip/impl/HIPStreamMasqueradingAsCUDA.h,sha256=d39swm5oDRE1s69j80HLUU2ieaLURWvMrllrOs-4J2s,4318 +torch/include/ATen/jit_macros.h,sha256=P9m1lVGf1syAvF20g-tKHFIc8eGCp8gO2rV5Fem9gfc,230 +torch/include/ATen/jiterator_macros.h,sha256=X8fFoFw_LAws7_Hw5k1APlSvvu03ahBZhGYQ_Qpfvi8,1506 +torch/include/ATen/miopen/Descriptors.h,sha256=fzctcbp90QDQfAYScC4ExDxavJJq5YQdPAH25i-_BOE,4761 +torch/include/ATen/miopen/Exceptions.h,sha256=iphmGt4foYp-oHbK3ZLW3vblofLb83gNnHY506HS5o8,1076 +torch/include/ATen/miopen/Handle.h,sha256=X4mpxUvHXTiqmtmKlD-cPHYMHb5u-XF0U2tPJr5k_0c,141 +torch/include/ATen/miopen/Types.h,sha256=P1iunZ2QG0vFpb1QON-4Dn199S_I5rppfdoJmnjNAiQ,233 +torch/include/ATen/miopen/Utils.h,sha256=-NuO-vc2fpcO3dLawvuoRnXRibX8W0qzYxW-31BCQGo,401 +torch/include/ATen/miopen/miopen-wrapper.h,sha256=F3RQZuVLB6BxC5084QGXs1o3vrehQdZpnzQ4TE5fLLc,41 +torch/include/ATen/mps/EmptyTensor.h,sha256=rMxmU3iK2joTcBxzQPZWdhel_v9SPQmCzniihZoHJJ0,760 +torch/include/ATen/mps/IndexKernels.h,sha256=EABNuk3-tTqLXWC5srqs92aN9EE9IonJNDgFA6_hQQU,29132 +torch/include/ATen/mps/MPSAllocator.h,sha256=jARA23d6PVUPPOzCYtnxXvf0A6dE1ivB6L8X2bl-vNI,18484 +torch/include/ATen/mps/MPSAllocatorInterface.h,sha256=vG4G1oX5WOFSn5yN24z6rM6EP4o71krvCBHFT5ZMc-A,2606 +torch/include/ATen/mps/MPSDevice.h,sha256=vwEhRFpOCSN_CYyPAGXYGOsBgKlSj616iBok33RxRB8,2123 +torch/include/ATen/mps/MPSEvent.h,sha256=T2uUFjesoudny-Hnns8A7WJBqMQZwURJdldbyku-aws,3547 +torch/include/ATen/mps/MPSGeneratorImpl.h,sha256=MoH1bFMjhmr4lEHfZ8TlHu7lQfnfPX27F8VS-s-FLa4,1554 +torch/include/ATen/mps/MPSGuardImpl.h,sha256=A6c1quPR3tnb_I2hNeylaM-aoqXi29mCVnPi40vVyLc,4963 +torch/include/ATen/mps/MPSHooks.h,sha256=lw0QjXth3vuiLStYWsRWpS3Rg5mmMwL3MIZLmsnjClo,1903 +torch/include/ATen/mps/MPSProfiler.h,sha256=nS6TqpwPdEeTsUl5wNR4JNkmBNHaSLhLHEXO4pMqj1A,16689 +torch/include/ATen/mps/MPSStream.h,sha256=4mrco9iXBmZEfrsD0qfYb5UsbMtyMXkGRN9pu72Vjsc,4273 +torch/include/ATen/native/Activation.h,sha256=FC1A_oWpfo5XvtGvFw_06wQq5gsfU5KJgAeBvk3F9jQ,4270 +torch/include/ATen/native/AdaptivePooling.h,sha256=qc1GOkHeuVq1eZTlYCssCD4sAipPzR-7vDr6yOz3e3U,1645 +torch/include/ATen/native/AmpKernels.h,sha256=5-R_s1Rh1YgWB87s_wCyU2XRH6vpaMHCr1SeH6RaSqk,619 +torch/include/ATen/native/BatchLinearAlgebra.h,sha256=ZV0UJcS2-QJdhqDu7I_nvD-F98BEYXbc_FYUyt6nzRU,9933 +torch/include/ATen/native/BinaryOps.h,sha256=SM3XVUlHxwsSoyjF_NdSGX9jDVSm-kIEpjBgv8ICdUQ,5993 +torch/include/ATen/native/BucketizationUtils.h,sha256=PazegwF3rjhiOICZZ72P0UXQSwdbz3Vv2ebV_WC436s,7789 +torch/include/ATen/native/CPUBlas.h,sha256=b4eaz8SCBcppJoS55axTw-5dJbrSSC_hrECMySI8NZc,5909 +torch/include/ATen/native/CPUFallback.h,sha256=D4r0mmVwRoFTzMjiA2tAY8NVH12W-X58yykQ14T_loE,2326 +torch/include/ATen/native/CanUse32BitIndexMath.h,sha256=gHAOodx1KsektVgmllOKAX4n1QvGJfKyzx8qSGE8GDk,242 +torch/include/ATen/native/ComplexHelper.h,sha256=7sEGqDlt7a0a3xLegzx7xwrHinryo4bilWY_2SEQnqE,4038 +torch/include/ATen/native/CompositeRandomAccessor.h,sha256=BMz1QA7muxCi1EoKhTSfzjI_Zsr-EM6HvVfIRrKamBI,876 +torch/include/ATen/native/CompositeRandomAccessorCommon.h,sha256=R46csHYWaGheNhcj3irxcvZv2RfTYMwVaeTT-hQp_08,6733 +torch/include/ATen/native/ConvUtils.h,sha256=qddEsLa7Zck0rjPbXIvk331VA75Vq4c9MQxB1hbrvIA,19610 +torch/include/ATen/native/ConvolutionMM3d.h,sha256=LPOz-FenTJ6sch4u2UYsmEfXHDC-qDvpLFNCV_wXDsg,340 +torch/include/ATen/native/Copy.h,sha256=GYvJ0m1DoSgVv4I8AIwIZJNsby9x1CZrwA9qiww-98w,373 +torch/include/ATen/native/Cross.h,sha256=YuhuqDz9bvGFqUJp2K3fh4LEd63plfrK1HkKCpnEHi8,260 +torch/include/ATen/native/DilatedConvolutionUtils.h,sha256=s0SPWkwNQEaPiBwa1OkN1bNtvhfdRkvAJ18Z-nqlN5E,6402 +torch/include/ATen/native/DispatchStub.h,sha256=sl4rh4e9vsi1QwZ7PLn_LYKDBPaM-5eD2agspi9oyRc,9971 +torch/include/ATen/native/Distance.h,sha256=u0wUeUc7yOr3eog8qwQcTkaOlXqt5mYy4eYsk2Ql6dU,724 +torch/include/ATen/native/DistributionTemplates.h,sha256=QBOQr-im4tMyaByHL3AAHLca0AQf6_sG51c81RGrGlg,18518 +torch/include/ATen/native/Distributions.h,sha256=nIgbp0bzOvjhQNJdbE36JgKxK5x7an54y9-7g8ZOErc,21601 +torch/include/ATen/native/EmbeddingBag.h,sha256=M9Hz-LCHg3apZVlvpd4cQtwB9FwyQPCItYhZGk2TgTg,4920 +torch/include/ATen/native/Fill.h,sha256=gv7QIvTW4Q337qi4Lcm_qZX-V2P_Z3DoZieAtn-88CU,397 +torch/include/ATen/native/ForeachUtils.h,sha256=UGASj70Il-KVD4B-6EBaaHE9dZAJ3_cVbDguu_5zZMw,13605 +torch/include/ATen/native/FractionalMaxPooling.h,sha256=RX0zkqtFAChACw2fEu_qxirsHZbDUoQdqN7GMq10gVw,2159 +torch/include/ATen/native/FunctionOfAMatrixUtils.h,sha256=VkGp6Qn2bQuZCm1Psgk7xEkDUggfSXS5hE4G2_37WCI,389 +torch/include/ATen/native/GridSampler.h,sha256=Xl5T64Aghe6YGizdW4N9ewzaprtguc9LNmnJw4hX8LU,10401 +torch/include/ATen/native/GridSamplerUtils.h,sha256=jEXgXfOvhiP1dZotn-PDJ4MgKRzLYXJdlmTzFPAKEXM,3510 +torch/include/ATen/native/Histogram.h,sha256=rWPvzPNc42g5-j4A-N_fNMRWdWa1BMuk2qU-nEMj4xk,748 +torch/include/ATen/native/IndexKernel.h,sha256=EAAZkWVJuppJTFYpLGm8ciN7RtfYgRyz4gYv_hJJXFg,1714 +torch/include/ATen/native/IndexingUtils.h,sha256=cmITxvTnWKnNgKcm9To0N56kqSbk9lJa5NjL6Dlkm4U,5570 +torch/include/ATen/native/Lerp.h,sha256=IeOOeCmpL4gJVHEErIhEK6vvXHvcbUgpOi5tGWOJ7xs,1463 +torch/include/ATen/native/LinearAlgebra.h,sha256=ps1zvs2J84CGUVLcTch0ZsIsugnDJBGHsHMx_6Fj2G4,331 +torch/include/ATen/native/LinearAlgebraUtils.h,sha256=WMqNaSs_tQ15tuDGJIqQ-iwARtHAOR-KQVY8WUum3gE,26583 +torch/include/ATen/native/LossMulti.h,sha256=kAZq7MnwuNxAldEAcwy_nKkc4h92_qXNR2cVPaanxvM,2175 +torch/include/ATen/native/Math.h,sha256=5cW03t_iJGzQJdtPhI_axFpUHm0p32d4bT6DbxiAfYU,141779 +torch/include/ATen/native/MathBitFallThroughLists.h,sha256=Zqlt930nF4Gf0VDFlBv19LgxauGaOIP7u7Y16wWvKSk,4136 +torch/include/ATen/native/MathBitsFallback.h,sha256=bEDpMkVe6e6N9jf8rgGslmq_9jqpbp2wbF7wCKgwKBg,7308 +torch/include/ATen/native/MaxPooling.h,sha256=5g2dDELfydvffOVfDvzceXgD10QQXB4PcsgFLonhNtM,3269 +torch/include/ATen/native/NonEmptyUtils.h,sha256=GssuIa3_Nbo70prkoJCxp8O7_6XqsNkAossTxmjuXoc,599 +torch/include/ATen/native/NonSymbolicBC.h,sha256=7fSyIgmOOcHjbNqiIASUqy-F7J62t4JripwZNkeqE_I,2876 +torch/include/ATen/native/Normalization.h,sha256=zH6zBjZwfNtXnyNYM8ONNmTKWe7NQOOrR-UH9EV6iB0,290 +torch/include/ATen/native/Padding.h,sha256=JN0jDdZRYwXcy7Yd_NFVTGBmQNhzcEKn-TtMoGVqonc,2026 +torch/include/ATen/native/PixelShuffle.h,sha256=eR377A8l82A9nyzqVdsKwkrWOq7DQVI_CPl2ZgS-JR0,1756 +torch/include/ATen/native/PointwiseOps.h,sha256=-ZCD27h22Imw-Fffq9l0Zyc4GhH5Oz5-0F_7mvsvLqc,786 +torch/include/ATen/native/Pool.h,sha256=uceDuMTFY_XVh2HBfs4FH9Za_VLlutrdFj14nK1cHPY,12396 +torch/include/ATen/native/Pow.h,sha256=6K4cUYxxLAcjC9xG9NsGxq4FDvmyErJ_e0XU4vrVWQM,1736 +torch/include/ATen/native/RNN.h,sha256=JX0WRObE8Z04hOZLtTikqZUYE5LagQH3rWkZvcLp_j8,2521 +torch/include/ATen/native/RangeFactories.h,sha256=Hipw9FPv9BiYw8yt2OXIRAQKbaGkiuGwQ2U2oB0bGOo,356 +torch/include/ATen/native/ReduceAllOps.h,sha256=d-elOBlAUrCrveYEYin3JqBGgcs6rZRWFuYp88nyqXg,399 +torch/include/ATen/native/ReduceOps.h,sha256=Dg1SbwFCD1RiTa0cADWLcR8BWTwPrHvKFGVSbi42jdY,1795 +torch/include/ATen/native/ReduceOpsUtils.h,sha256=NmRh8AiuhDmoRWAjmD732atFVg6mreDv1dw6Jezcp4w,16118 +torch/include/ATen/native/ReductionType.h,sha256=JkIzyCJIBQfrRuU2fihIMpm67IDqP0LybB67UyxFC0Y,1153 +torch/include/ATen/native/Repeat.h,sha256=7M18VcgHZdBA18GV_w3OpZXmd_-GevPcZ8Qs0l3KG5U,1437 +torch/include/ATen/native/Resize.h,sha256=mqWQA7MEB0W6DRDsfOy9Y7AGGFK_9TR4D3xoKXY4muY,6594 +torch/include/ATen/native/ResizeCommon.h,sha256=SI9FlJjB3zI2FrRHi2ShSDHdWImHei1n1_CXcs09Cwk,2491 +torch/include/ATen/native/ScatterGatherChecks.h,sha256=x4uKiISn_jBs9ifMjxR9FbDWDaxyq63yS2PUzwSJLNc,3698 +torch/include/ATen/native/SegmentReduce.h,sha256=xtAcejU5LDM7QEIqPvyJqM9eN9hZBYPo2-WYNzi0ifQ,1280 +torch/include/ATen/native/SharedReduceOps.h,sha256=J8jXEUdosM1vPTSPLZgQ6Ygo6ujsuXtC6Gb8minTLP0,15989 +torch/include/ATen/native/SobolEngineOpsUtils.h,sha256=cxzZBRujtqn8MqU8oHtxqVu9Z94tr9jLD3f8YQlIUNs,1835 +torch/include/ATen/native/Sorting.h,sha256=pOjncf_4DapbmsWeIlamKQJ7D0Z2xw-Ylea9Ke7zZag,618 +torch/include/ATen/native/SortingUtils.h,sha256=i3rlh9XmYm2DnlDmvbqvd3jym6slpXuYZszscT7GzhU,2672 +torch/include/ATen/native/SparseTensorUtils.h,sha256=srkJh_TAtVVnUPuj7vJt6wQKdSk3yv6E-gDlDy8gR4U,6500 +torch/include/ATen/native/SpectralOpsUtils.h,sha256=JyEHAbwPE6OyPE5-vKArHbqklOI71jzU7Fml74Cy7jQ,3274 +torch/include/ATen/native/StridedRandomAccessor.h,sha256=cPMgSAbNq5QR8zwKYPa9mKxRl_1xPQlAsUgi-T4xe6Q,6835 +torch/include/ATen/native/TensorAdvancedIndexing.h,sha256=45WEngvQhbyzA5sr1GZIF0dQA-8T_nB40JCF-9X0hro,2782 +torch/include/ATen/native/TensorAdvancedIndexingUtils.h,sha256=No5UgoGkSUM-yAYlj_2eaH-V_9lItOefuc_pXbWXECw,3035 +torch/include/ATen/native/TensorCompare.h,sha256=iwfjJJ_vb9qah9iIKrvLlRd5kFfFTW2679XxSnMCEEA,1490 +torch/include/ATen/native/TensorConversions.h,sha256=xXSXubQXESMbAW-fIaZji1ZNzPvhW0jT-t7BTb795-c,830 +torch/include/ATen/native/TensorDimApply.h,sha256=HZglRNLPFRCUcEjywt9Nq8iIlt3fwjO_fI24RCZUKaY,1739 +torch/include/ATen/native/TensorFactories.h,sha256=anmR5cy8NQiNx8izKgpTLGjmVeQZhuzk_C4zvkavv4M,4986 +torch/include/ATen/native/TensorIterator.h,sha256=Q7J_N0bs9xO5NSiLO74hLIE5NUIcmr2FmkSS_eLf1GI,46 +torch/include/ATen/native/TensorIteratorDynamicCasting.h,sha256=bHTH87on8BiLGVklbqKLiKjzJMJT-LhZi6rYs_hrdFk,1801 +torch/include/ATen/native/TensorProperties.h,sha256=S2KRCG52XtPNLE30U1z9NEr-lg7GJNCme19ynl5iGAQ,198 +torch/include/ATen/native/TensorShape.h,sha256=luQdVAyMpD_tZq_meXJM41nBdtH0qhITZkftgYqWD4I,4344 +torch/include/ATen/native/TensorTransformations.h,sha256=wbnqc9UnfnF-Chexr4e3Eayl94NDPDue3Ibt9P578sQ,896 +torch/include/ATen/native/TopKImpl.h,sha256=3d9fyYLn0l-bo4_h69ZkX7iFFIXyX9XpdYIq6QgoY1o,3459 +torch/include/ATen/native/TransposeType.h,sha256=Ge4VLRl4sgZVIlqyOXjY7WarTsulnfG26a1QTljGWlQ,578 +torch/include/ATen/native/TriangularOpsUtils.h,sha256=U_pmKG-BzKvr5lCzXu_V70vpAdfrklsNCxzIqS_c0ko,2002 +torch/include/ATen/native/TypeProperties.h,sha256=37P3hHIx2SpByQQfOse5RTyJlH31uJNmyz_rQHBXeNA,658 +torch/include/ATen/native/UnaryOps.h,sha256=h50z1wMhATB76HzOW7LF8KALu-NQdWW7ce4Z-FulZKE,5612 +torch/include/ATen/native/Unfold2d.h,sha256=uTH14g0CMaolRRr5cTjciCt1LPItMjssS_UolPL_YK8,609 +torch/include/ATen/native/Unfold3d.h,sha256=u-4T4k0XRQ09rOEOOHdKFGPnTMWb3zSvrx5sa9T6lQA,873 +torch/include/ATen/native/UnfoldBackward.h,sha256=WA1lX0SsQUc_DOsDMUBtLUNKN6sltOfc-WHDJabDP5w,3075 +torch/include/ATen/native/UpSample.h,sha256=zQP2zifHvCk74zK_u7ezqtenXlOZSzNE-Mjq0HJg43I,19370 +torch/include/ATen/native/batch_norm.h,sha256=aTXna3N4ftEbcUxE86vl84Bu5kJiQVzgDbO5Gbgb-5g,1265 +torch/include/ATen/native/cpu/AtomicAddFloat.h,sha256=90ttAHoUfZSaD8x2wACxPWiyrBPiJAuMAzuAb-aQa3s,857 +torch/include/ATen/native/cpu/CatKernel.h,sha256=172bTLxnfq2liPP30dzLpaXXNLMufmBoHHs_Pb2QwLY,320 +torch/include/ATen/native/cpu/ChannelShuffleKernel.h,sha256=Z6GXrX8gzOCWTFBXdm9gqLOg79g6JyztetdJFA6XyN4,299 +torch/include/ATen/native/cpu/CopyKernel.h,sha256=pGN9Mcbyd4KxGqrSobU4pmKDkKwm5ERAnk5wy_uyBao,271 +torch/include/ATen/native/cpu/DepthwiseConvKernel.h,sha256=9izS3h41SEB_vJQkJArIfuL6WpGshwdJh-emc5_rBRg,471 +torch/include/ATen/native/cpu/DistributionTemplates.h,sha256=VvCrj9t7hNIj3BsMGIYeGpytPnL4qUddm2X-Kf3eCrc,14507 +torch/include/ATen/native/cpu/GridSamplerKernel.h,sha256=SQXZx1_nX9fUmynO2yRsn1WLeOd8RFZjXBDP_mByfAs,838 +torch/include/ATen/native/cpu/IndexKernelUtils.h,sha256=mmDhNycBgReMOV0i8rS1CcY5nKhbzZ0Xym4mQtqd-Us,2977 +torch/include/ATen/native/cpu/Intrinsics.h,sha256=Wb3_syiw1pcSafKzSTvrsYFxA9H5BnNhkfTd9Tnc9Js,1212 +torch/include/ATen/native/cpu/IsContiguous.h,sha256=elPM3Sk6yG8G2-JYv7SW4vrhoDFNoUkudxqUHMUXR7U,2440 +torch/include/ATen/native/cpu/LogAddExp.h,sha256=2Wsd8ecLE48TcVvv8MPaKAiqyYyth9Gmu8pmDZHR2EU,2458 +torch/include/ATen/native/cpu/Loops.h,sha256=kQY-XRfNz3MqyQU81HQxnOKyLUNGdLm6nRQxtmKR5VQ,14930 +torch/include/ATen/native/cpu/MaxUnpoolKernel.h,sha256=PnZPzRGT_YoGU8rMBWFq1Ik8L0fBJG8HpcD2NYYOdug,308 +torch/include/ATen/native/cpu/PixelShuffleKernel.h,sha256=cqkxBNtdvc6R85AGaK63X8hjHmEBXSzxj9M2a-aqxao,334 +torch/include/ATen/native/cpu/Reduce.h,sha256=Okbmg0AeSIbyZzf8i69f8ktToMibM5tdXkZlS5_-urc,12206 +torch/include/ATen/native/cpu/ReduceUtils.h,sha256=WS8eDrkkpPVamkY9pBxofTNQCFvcAPiplzsYTOzvD0M,8810 +torch/include/ATen/native/cpu/SampledAddmmKernel.h,sha256=S3KToF2GglCGlBOVnsHK4oGTZGeFjjkGKrOL9lirFFw,335 +torch/include/ATen/native/cpu/SerialStackImpl.h,sha256=UauGC9yWeUNZ3I4b8aWaEU3pXiIcxo08ipLYiMrZoDo,5447 +torch/include/ATen/native/cpu/SoftmaxKernel.h,sha256=UBNcP3lmiaC7l3D28FIAHwZbPs9DuCMzRL0iN4O2qRc,943 +torch/include/ATen/native/cpu/SpmmReduceKernel.h,sha256=N5ZV1t3r70FsGPsGtmTSwhG4oqMhgEGfvph8YRBqhL0,1358 +torch/include/ATen/native/cpu/StackKernel.h,sha256=Au6Np8o6HmqWrm7hW-PhyZENmuejs7x6sndAASXPIK0,322 +torch/include/ATen/native/cpu/UpSampleKernelAVXAntialias.h,sha256=fX-4xiB0VjXkOJ6rch7b4o12QBCm66UkreiQJDCPayE,58118 +torch/include/ATen/native/cpu/WeightNormKernel.h,sha256=zgTyBdHYh86Qf5hvdLi9tUCDmo24ezkqZ8nc2_BLWCs,565 +torch/include/ATen/native/cpu/avx_mathfun.h,sha256=myM3TvQ8ENSdsLchEId1advZBrVtLGdH75UcPDFS6Gg,17449 +torch/include/ATen/native/cpu/int_mm_kernel.h,sha256=2e3g286Qu4hvv-OvfjIpq02edCdvSyBVj1ZHBFHJgVo,583 +torch/include/ATen/native/cpu/mixed_data_type.h,sha256=Fhabzk0PTs-NJE9i-rqRwbH7v4rzuJdysfV0-C0H2JU,1421 +torch/include/ATen/native/cpu/moments_utils.h,sha256=qSbB8fZi7dZ245cgTlEMFTSqSwmTwmBsFw3ETopHaZw,6675 +torch/include/ATen/native/cpu/utils.h,sha256=ZGuduIOLSnq_zwvQE8HkYpbXSLcpso8negY9XIIbeJg,6514 +torch/include/ATen/native/cpu/zmath.h,sha256=tYGbdTu6xBN9hMbghS8bU6uxPUHnQkl0X5v1bxeyJsc,6634 +torch/include/ATen/native/cuda/Activation.h,sha256=P5cfZgC8E8x-E4IHrTGWJsp-bvSfd93iEV0zUbA3L5M,548 +torch/include/ATen/native/cuda/BinaryInternal.h,sha256=BpaOkeNO7HljHl1xUbYVikQxnX7jKRZhY7OqCadLTkw,1237 +torch/include/ATen/native/cuda/CUDAJitLoops.cuh,sha256=J8oFKg3vSWE25kIabNHiV6at35kBVG1WcWL9JK245kI,10804 +torch/include/ATen/native/cuda/CUDALoops.cuh,sha256=oWqQsH1be0HZI0I39c4DR6QS7D0k6WZC0RdWVfaWJEo,11341 +torch/include/ATen/native/cuda/CompositeRandomAccessor.h,sha256=XtnBCyL15XJYIjUN0B2DQLkeXDqFsn5BPd6U-jj1-TM,929 +torch/include/ATen/native/cuda/Copy.h,sha256=MkXCb-zta0imFs_rA-CzVWXa3rqh4cZ5q8jZriuIxgM,162 +torch/include/ATen/native/cuda/CuFFTPlanCache.h,sha256=w4di6bqSH31BZfCcn_JTTlUZFJwpYiaEnhi7w0KXRVQ,17961 +torch/include/ATen/native/cuda/CuFFTUtils.h,sha256=qP2OwOGhPnEbQIm09Rcx_J0Svhlvk-CjuEY2EOtskJA,1863 +torch/include/ATen/native/cuda/DeviceSqrt.cuh,sha256=AdZWqFvanSwRhnzlFK9vyhLDXoMpy9gwfW9dhRn0xN4,573 +torch/include/ATen/native/cuda/DistributionTemplates.h,sha256=6qFSPqGfIcRbVfPSrj9aDUawom-8AhD5CZf8LTc39gs,28216 +torch/include/ATen/native/cuda/Distributions.h,sha256=12qzUlaPXjPsS9aqFt8o2r2bfp4IPLnZb0sBFH9AedI,641 +torch/include/ATen/native/cuda/EmbeddingBackwardKernel.cuh,sha256=bk76DSvQvBTgsXU0RHb9D0cxKlIlfQwcpDV9x8-SuTs,543 +torch/include/ATen/native/cuda/ForeachFunctors.cuh,sha256=ffNOYb1OdrVOzlbYzM9cgOXC_qQxmS26m0-fmt1iYRA,22505 +torch/include/ATen/native/cuda/ForeachMinMaxFunctors.cuh,sha256=UxN958DDHsTZXfypAx-jsBPcj-M4DM8sXJYcC18oTns,426 +torch/include/ATen/native/cuda/GridSampler.cuh,sha256=ICNNX-iV69eUDfr-Qrl58Rz0Fwi-MlkZFU0SS5Y2Jkc,11100 +torch/include/ATen/native/cuda/GridSampler.h,sha256=P_B6yQiM4A279_cKWZz9DEFL397xWjNcz--8pzIT1T4,1157 +torch/include/ATen/native/cuda/IndexKernel.h,sha256=Nb58RQW5mPLguGZTgOGRtBDqXKDKCbLEcFMET6hM36k,350 +torch/include/ATen/native/cuda/JitLoops.cuh,sha256=YESWWJLTTBpyKLuVV_PZPXmZE9d5wbREcDNXHDDCIFA,6909 +torch/include/ATen/native/cuda/KernelUtils.cuh,sha256=DSfDCs_xdIxQTjqqHHHq2-RU-64aR8F_PDah2mVDuH8,4836 +torch/include/ATen/native/cuda/LaunchUtils.h,sha256=r0PwPRvBDaSUHEQm3CmFMKYM9LxatU3Zr3SYGoNf8bs,306 +torch/include/ATen/native/cuda/Loops.cuh,sha256=VsEHK_Mh4ovcokiikNIGKU8hxciZ5iqyIHJoWSemgAc,11605 +torch/include/ATen/native/cuda/Math.cuh,sha256=tMPqsrs6fu2f6OBAgOqCafr7tMCmJNa2QDEWobyeJso,122806 +torch/include/ATen/native/cuda/MemoryAccess.cuh,sha256=sMvz-RlSb63uGB3kJmviLL6lrmBo8855dyU9vo17VXY,13538 +torch/include/ATen/native/cuda/MiscUtils.h,sha256=Az-goaDi_bSPbHvbKtODEZcfKCdviw3XLalPqtLi24o,958 +torch/include/ATen/native/cuda/MultiTensorApply.cuh,sha256=dPtaHlZosTPQGCxTIKRq5OjzCqJPV1o6GCIQsi5aoFw,13880 +torch/include/ATen/native/cuda/Normalization.cuh,sha256=CKDfbQKZGC84A2SHSq3UsO_8GVWbTLdVxymm84umI3E,74077 +torch/include/ATen/native/cuda/PersistentSoftmax.cuh,sha256=EkNpM8roweQJavNCMTBwzoc-7609ahY3Z173gNH96h4,17932 +torch/include/ATen/native/cuda/Pow.cuh,sha256=nmuniiZfa1G0eEFSg8FLDSTgANz92vZJXMyOdlF_2go,2170 +torch/include/ATen/native/cuda/Randperm.cuh,sha256=JRj6ki2aqCRug0Kq_Jc62FixVUMrgRO_qh0-KT-qgbg,2119 +torch/include/ATen/native/cuda/Reduce.cuh,sha256=bJcSNGRvTk5QKB6IbrrDOjBNWNQlqPcugR6PNtVLYgU,48124 +torch/include/ATen/native/cuda/ReduceOps.h,sha256=qmtqmP3p0nTVFynzZ8EsBqvM1xlLOhLhzmJnmrjBuZQ,500 +torch/include/ATen/native/cuda/Resize.h,sha256=jf9VyFW6Us3R3sc_5wpJ_F6cMzHPGYTdsVZSzxtT8gc,1771 +torch/include/ATen/native/cuda/ScanKernels.h,sha256=YwFzB36CbHF6ELtQg5_QNq541L-YNT_BkabZwFcrnaI,779 +torch/include/ATen/native/cuda/ScanUtils.cuh,sha256=B_f6JMvrEUfXX5T7acaqzU2gXR0-VsU2_3_TB8rEnDI,20219 +torch/include/ATen/native/cuda/Sort.h,sha256=mpeobYqLP6-tToMrfwyr2y6ei_pIAHy0neX-CZ3ldMk,409 +torch/include/ATen/native/cuda/SortStable.h,sha256=yNg75vcvcJt78I8250zSXn_H7UW3uZBxPlKQSbB0HqU,464 +torch/include/ATen/native/cuda/SortUtils.cuh,sha256=7LFw65rsQnJASzlkQgTH9h8KIobBz9ASLiS4rdvb3WE,12408 +torch/include/ATen/native/cuda/Sorting.h,sha256=tyOJg167vdu5y2_oahkDmQMkxE2wWIAA_Sd1-mxeMmQ,408 +torch/include/ATen/native/cuda/SortingCommon.cuh,sha256=UOmaRN5tK7NHt_Hsf5wNqCzzVBTOCGDbAvejM8RftWY,5373 +torch/include/ATen/native/cuda/SortingRadixSelect.cuh,sha256=MMkusWH1l3qmMQeHSqcWXtXQ0-DKGBPCbYJtMyNdk_E,12339 +torch/include/ATen/native/cuda/TensorModeKernel.cuh,sha256=5lZXByGjt6-xQrS5Euu3ZxJh_hyAzPSLTlRIVwUu2Wo,14512 +torch/include/ATen/native/cuda/TensorModeKernel.h,sha256=Ts6qovjkJSHzmmJZMdC7i048cYRdGsXZXJMJSGIk1hk,431 +torch/include/ATen/native/cuda/TensorTopK.h,sha256=ES-i6xXC1ktxDsoILkqO7fdXFOhAO7TGCZz93pIAVNA,266 +torch/include/ATen/native/cuda/UniqueCub.cuh,sha256=9IrI9RFom8G3OWESkqn_eDOhd2nF97ZBICXxlU-0lU0,352 +torch/include/ATen/native/cuda/UpSample.cuh,sha256=N2XkWlaqp5txV4DBTbtoEV0093hL2pHt_lMDkLvmf3E,11774 +torch/include/ATen/native/cuda/block_reduce.cuh,sha256=zb0rloVwPkqdTHkRLDxwCtTDl3v7iu3bLB1boM1Exds,4247 +torch/include/ATen/native/cuda/fused_adam_amsgrad_impl.cuh,sha256=jrJy6VThqST4N9tQaBGFyK4zQKLNIGvEh4CVKdkjMHw,1054 +torch/include/ATen/native/cuda/fused_adam_impl.cuh,sha256=5sjTwObgt3YfwIJkNqzB3LXm00w5wk5tYqcalmze7Z0,966 +torch/include/ATen/native/cuda/fused_adam_utils.cuh,sha256=s14oS0XrJi_hp7PLP5pHWv4n5OYV1IqL9J3sHkEj-R4,7022 +torch/include/ATen/native/cuda/fused_adamw_amsgrad_impl.cuh,sha256=r3Oob2qJPqDBH1q7JGAqF1HqOjOeSuLQ1TODfpqx8VA,1056 +torch/include/ATen/native/cuda/fused_adamw_impl.cuh,sha256=QTpjXvyaZSSEA8bWCwHOLbCqtEiqbLvDuVRO7leBl0A,968 +torch/include/ATen/native/cuda/im2col.cuh,sha256=jwwpJImSEKW2zYYQYKe2839o7vaD821UL7o_gSxSagA,9871 +torch/include/ATen/native/cuda/jit_utils.h,sha256=1O1--QUX0FAtGgRe4YUCx-9mpZF9n0V89zVtUF6TZv0,6095 +torch/include/ATen/native/cuda/reduction_template.cuh,sha256=jpBipwIn73G6n4yPGX1jXoAPUB4SQVANd2r4qKdP-aE,21618 +torch/include/ATen/native/cuda/thread_constants.h,sha256=zIqWk31kGD_-TgB0Zokq_PKYmtbNILZzhPMueOBckz0,611 +torch/include/ATen/native/cuda/vol2col.cuh,sha256=t_EI8AkPkMxohenAqF4w2Lasaw65frM5YSBrfuAgbkc,8078 +torch/include/ATen/native/group_norm.h,sha256=rkPRett8cs5FdUXbVwVoc1qvN7l0KSrKn6MZlOayXHI,907 +torch/include/ATen/native/im2col.h,sha256=0Ho5Km0ZJvPbhKmsOPcE1PuYHaUaaNGrDlsNWaYhivE,5223 +torch/include/ATen/native/im2col_shape_check.h,sha256=HLmXnwM_Vhcdkg_Fm9egsma7gdmdnPMDQXAtceYZ_JQ,6913 +torch/include/ATen/native/layer_norm.h,sha256=fm3598f8CxRLkVRW-nKviNcGOLA1eKs_uCGVixRT6OM,2796 +torch/include/ATen/native/mps/Copy.h,sha256=oxrgJdnHb97in2lpyB4k637i15qk-B2L_pr3ph_W_tI,332 +torch/include/ATen/native/mps/MPSGraphSonomaOps.h,sha256=oZWlmuSRzfN24P3E9HBTJjlSL-SivCK-8t_p-J9QJf4,2346 +torch/include/ATen/native/mps/MPSGraphVenturaOps.h,sha256=zP3-OPUSy3MPUU_7Wf7BCtKUjc5U_9EeKvcEYPglKxw,12735 +torch/include/ATen/native/mps/OperationUtils.h,sha256=ONDglePKZIm5SFW0ab1bbHhXv2o9catSXgVCmdJLaz8,14301 +torch/include/ATen/native/mps/TensorFactory.h,sha256=-sjtEk0Ehlgo7IYeWOONV0AesCQOvLgwz48Qj55lufc,759 +torch/include/ATen/native/mps/UnaryConstants.h,sha256=T35FH2VQvaPOizi8p1NZpnrTPBaP2cSz4-bAoZ7OpJI,1265 +torch/include/ATen/native/nested/NestedTensorBinaryOps.h,sha256=iSzRYuqdqFhdvibsyMXW4LHx9fs_FQLkOiZYXzpWG5I,421 +torch/include/ATen/native/nested/NestedTensorFactories.h,sha256=UGH253Nc55QoDzh2Qsp-K5bcbCWYB3czmjMrB-tJf_4,89 +torch/include/ATen/native/nested/NestedTensorMath.h,sha256=JWffeLkCDipFEBtBD-w05uHFFAXC8PECWGdh7yEB9kg,2748 +torch/include/ATen/native/nested/NestedTensorTransformerFunctions.h,sha256=Qn2e_vhWuS7gWNkTB-6yaGWr_6dPMePTCejwGpYJxIk,2817 +torch/include/ATen/native/nested/NestedTensorTransformerUtils.h,sha256=JIAfosUsC-qwDoYIQOg0nnIBmfeTT67NB6Vtg_AHe_M,1429 +torch/include/ATen/native/nested/NestedTensorUtils.h,sha256=idsnUmeJQqWQGqwAskdB7SyBxOEj3EU81QV0aHcFMdI,14178 +torch/include/ATen/native/quantized/AffineQuantizer.h,sha256=ajMS--h63K4JMSDYfTCMeKOV42Qob_wlYM1ttyPY49E,3654 +torch/include/ATen/native/quantized/AffineQuantizerBase.h,sha256=_QFFrK5F78aZY9XEpv8kCqd2DRNy7rbd7U1RDgGU0aE,1460 +torch/include/ATen/native/quantized/ConvUtils.h,sha256=TDqUwX4q3fcVmYD4XLcYEwzVA7QMgAYVJnb6_4QnV-s,2240 +torch/include/ATen/native/quantized/Copy.h,sha256=IPBQcU7gPA6UsoZ0LssBH6zNrIK-R08byy7KLnpQD3c,169 +torch/include/ATen/native/quantized/FakeQuantAffine.h,sha256=J3Zt2zhwoUWLY_FUjq1uxIEUpFtd_E-osh8GPLAtwQ0,1792 +torch/include/ATen/native/quantized/IndexKernel.h,sha256=xbgIIP4_ERQIdeMjFsiRVv2fEsJfaA9dUwbIgYjTOG4,567 +torch/include/ATen/native/quantized/PackedParams.h,sha256=Z1ptmvhqkwes4qywju5O9S9eQ9zzkny5Tcr8sfQSC-A,4739 +torch/include/ATen/native/quantized/cpu/BinaryOps.h,sha256=Sk9Ynu9H2sZSOPDMfe1skLDtsvtlEbofdbYP4Fd74Rw,173 +torch/include/ATen/native/quantized/cpu/EmbeddingPackedParams.h,sha256=i2KTZIVgnGDodnlIlk1p2PEjZv4J5CkzHnbmJWjQVYQ,921 +torch/include/ATen/native/quantized/cpu/OnednnUtils.h,sha256=ytW2xVL_3bYaXF7ODWp_vD5UblgJUnGjTn5qbVoiuHc,12780 +torch/include/ATen/native/quantized/cpu/QnnpackUtils.h,sha256=YXzFQuyxR_yYWT8qkzIiud2_CujvVr7E8OlQgaqlHkE,17723 +torch/include/ATen/native/quantized/cpu/QuantUtils.h,sha256=CilOigJWOnTBhAAORiKeC0jecm8Fv3OTY1uIZkeqn2w,8361 +torch/include/ATen/native/quantized/cpu/QuantizedOps.h,sha256=ISPwi6I0JOi1eMz8gJZhhbGawSt82c1ZfGsMTWVQe3o,7861 +torch/include/ATen/native/quantized/cpu/RuyUtils.h,sha256=83PvlzQs-kUbWBT__Wk_sEYH-7eFPeviJIcGwjaUC1Y,385 +torch/include/ATen/native/quantized/cpu/XnnpackUtils.h,sha256=AVtaDPbS4PHSlcj_UgCNtvy8DKwlIagB5Gqa4dnu2hI,14155 +torch/include/ATen/native/quantized/cpu/conv_serialization.h,sha256=M-6kXYbZf33pfBkM98yUlB9D_fF-a9THSY0hvBcubJs,12650 +torch/include/ATen/native/quantized/cpu/fbgemm_utils.h,sha256=edltxV_C99Y9CR9zpY-4YQiZ_wWX4TUa_Ofk-r3eM_E,11912 +torch/include/ATen/native/quantized/cpu/init_qnnpack.h,sha256=ZiH_VsIdp7AG6DNL49ia3_grOjjiQHM3iTKk7TKXuTw,146 +torch/include/ATen/native/quantized/cpu/qembeddingbag.h,sha256=Kk8aCMVwNgPo2bpBTXSsn08KCnOvAtGQck0jN4iOFWo,1020 +torch/include/ATen/native/quantized/cpu/qembeddingbag_prepack.h,sha256=zT7mp_4ONdKsddkhtN_qiln_fKrmtnLYbiSsqeHM6mQ,319 +torch/include/ATen/native/utils/Factory.h,sha256=1b0r5l0wIzeGQKSa2hfMfTbWbPhaZ5VpSkDpD8qR7pE,553 +torch/include/ATen/native/utils/ParamUtils.h,sha256=BQrIXLsOh_dyduINcB9w6KWCsVxl9BalttfHl7PGIUo,1188 +torch/include/ATen/native/utils/ParamsHash.h,sha256=4d7c40z9WplS5EyNfBGU-QTnki9ta4M9QxufxTInsO0,3124 +torch/include/ATen/native/verbose_wrapper.h,sha256=3Xfi-C_0uzhaiTnuCN0KgTg3OAAUlIbK_-q9AglaUuY,193 +torch/include/ATen/native/vol2col.h,sha256=kl_QfjV0WOe1Z56JFeW3kaF8FhUatFMcrRItHBmNXF4,3569 +torch/include/ATen/ops/_adaptive_avg_pool2d.h,sha256=s6nxwiGo7vHoiEGzSWzvileqhNQrc3ElGl1UB11MEbQ,4159 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward.h,sha256=GVm4j0KX4IOa-J40cyH_NBNHbMDTfcjctwtr32jspUw,1440 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward_compositeexplicitautograd_dispatch.h,sha256=JeLI_X8mSdsmv7f3ukT7TkBg9Ot4oJLStchOWDwFRb8,977 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward_cpu_dispatch.h,sha256=Vvz5ASAMR98dEswKinTmRtFnS6jb9mEirjmGlx_2528,775 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward_cuda_dispatch.h,sha256=FjbZJMJ-hJc-fYJy7mrq-HOHArmXUpDAr1i1_PhL20g,777 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward_native.h,sha256=mfpoNY70HF2l7wwxT73jSMBA0jCHAQBVwKtRruAXfTE,791 +torch/include/ATen/ops/_adaptive_avg_pool2d_backward_ops.h,sha256=ad5quQ18gYRF58Fwur4_jddUamA3I_pbKRyasKyjq2U,1936 +torch/include/ATen/ops/_adaptive_avg_pool2d_compositeexplicitautograd_dispatch.h,sha256=eUhdfYXL5lFZYX_w3-c-4VKL1gHZ-yc-JHAZM9Xthzs,1218 +torch/include/ATen/ops/_adaptive_avg_pool2d_cpu_dispatch.h,sha256=9KAZBHTLzD3xgNFL1r8ZfVhMMjBZCv5ctC-IjkFTfeQ,871 +torch/include/ATen/ops/_adaptive_avg_pool2d_cuda_dispatch.h,sha256=_XzGCsZJJxQSDFt8obcbdzm0gyuk6VGQaecK_ot9YnI,873 +torch/include/ATen/ops/_adaptive_avg_pool2d_native.h,sha256=a7ud067uMIMzfHqo2OYeWigTSxjPXfVRPrTD7-8bJDI,987 +torch/include/ATen/ops/_adaptive_avg_pool2d_ops.h,sha256=RUKN6V-QyRlAW5oRgIgyUfisXtPDmQJArB6hkJ9QEyQ,1894 +torch/include/ATen/ops/_adaptive_avg_pool3d.h,sha256=5RyPmgXvRVJZOyvVg1LP7LX_ZbFSNizZ9H9AJeeIs-o,4159 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward.h,sha256=J4mvJA-GLekDl41jaEFJSn6WXX4gjaiscLtU8TU5O7o,1440 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward_compositeexplicitautograd_dispatch.h,sha256=IPSxlBRDTEOj8EpFcfVMmFsk8RrxyFVkrBVm__03nN0,977 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward_cpu_dispatch.h,sha256=Cd1XxUGabRmbgumz9a0W5PkkLpTxAf22SNE9OU_k5qQ,775 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward_cuda_dispatch.h,sha256=_oTYBZFPBPelRpzzJsqL-Z0TiztPCJ6YhdYyb1aT5BM,777 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward_native.h,sha256=VcRMn71GQiJWON1a_XZ6_ekaYBU1mYGLjg8Yvfl9oaQ,791 +torch/include/ATen/ops/_adaptive_avg_pool3d_backward_ops.h,sha256=fyHMa7Yckm4MeRbICScK_wXXGkTOAFfID26A4JHRr1I,1936 +torch/include/ATen/ops/_adaptive_avg_pool3d_compositeexplicitautograd_dispatch.h,sha256=JAWXab9CmSmvmBr1txqxwK1Fvvm5kR2Vc86geT8EX-4,1218 +torch/include/ATen/ops/_adaptive_avg_pool3d_cpu_dispatch.h,sha256=8ib8k2gXCFUBcJHjwLLarNCGlU9PcT_1B3_QO2VRTP4,871 +torch/include/ATen/ops/_adaptive_avg_pool3d_cuda_dispatch.h,sha256=rMC9fg0uRRKjIdsom01TIQdxDBw5r9wJR6rBKbFxZc8,873 +torch/include/ATen/ops/_adaptive_avg_pool3d_native.h,sha256=nTxlmMgiGUEoGw4_74zgibv92JzkwIAQfnTwE6kHF4c,876 +torch/include/ATen/ops/_adaptive_avg_pool3d_ops.h,sha256=7ZABsc4XOgH6fkjP6i847WqWWICwxlxE-Y3NA9-6xzE,1894 +torch/include/ATen/ops/_add_batch_dim.h,sha256=wDyKRCyKdvda9MVZBUp472LicvaT0xEhoXPUEy3ZXxg,735 +torch/include/ATen/ops/_add_batch_dim_compositeimplicitautograd_dispatch.h,sha256=XMCD0HQdcEVa1BVZ1-AQu9xbFTK2PEvtCl6qIHalbYk,806 +torch/include/ATen/ops/_add_batch_dim_native.h,sha256=CE7xIX3FBM8TtKlqO9utGIMrk0rBg-ixVyWZbUORFoA,529 +torch/include/ATen/ops/_add_batch_dim_ops.h,sha256=p_sdmLdmQaXYFTN0C3mlmdycAWbR_NDZGkt1d0YRAs4,1103 +torch/include/ATen/ops/_add_relu.h,sha256=Mn5Pq4gDTiCHzyGRw7m54sgBbXx7qymbg5WSJ8xIwis,2769 +torch/include/ATen/ops/_add_relu_compositeexplicitautograd_dispatch.h,sha256=vgIkXljW9LyU1ufXH1fSQOV8fTw6VeXeNA9Tfs_r7ow,979 +torch/include/ATen/ops/_add_relu_cpu_dispatch.h,sha256=W7fQahaeCmK8IjeYW7e3JcQSgfxAIor1d5wiaOO_wJM,1373 +torch/include/ATen/ops/_add_relu_meta_dispatch.h,sha256=nX5KL5CMnNFXOV7b2Cl5UHXWVX6cqIX5DatN3RjYhDg,884 +torch/include/ATen/ops/_add_relu_native.h,sha256=RJWKqdcEPTBZN6HWeEB5DxRjr8rQAUPuXpaiEQnhfCI,1139 +torch/include/ATen/ops/_add_relu_ops.h,sha256=EuxzjbMFeWSRGNgTHjzaLVdWcW_1kyqGbTYcwrqiqNA,5015 +torch/include/ATen/ops/_addmm_activation.h,sha256=ASPni3PPVj1JDycRJNnKS_yH6beZQIUpEzZFfNhpdFY,1835 +torch/include/ATen/ops/_addmm_activation_compositeexplicitautogradnonfunctional_dispatch.h,sha256=sIopst68KEwCsexgyCnhaKQcVewRkBhvuAambw3VR0w,927 +torch/include/ATen/ops/_addmm_activation_cpu_dispatch.h,sha256=QzxYnkcvNJS_ASTa8XGoe8NNNp8LX8WuaVqsQmbJ5OA,1278 +torch/include/ATen/ops/_addmm_activation_cuda_dispatch.h,sha256=0fer6SRslwjTIbqsNymKPeu-C6vbSZeq3gAoU04eOhs,1280 +torch/include/ATen/ops/_addmm_activation_meta.h,sha256=ya5-Gmqb9NCHk6mkJ-GqQmubhGprgYk1Dfnd3VJqHpQ,713 +torch/include/ATen/ops/_addmm_activation_meta_dispatch.h,sha256=D8lzWemIpHzxHTZptByJ2uFoKVhL3m_pRRPA8XJCKRY,1280 +torch/include/ATen/ops/_addmm_activation_native.h,sha256=3MAceoZbwgp_gsOQPbnmUi4uKaXPdhIGjUyGQMkpZsE,1042 +torch/include/ATen/ops/_addmm_activation_ops.h,sha256=TcM_q885IjeVNdRsmnBaAJ20MFxp1dNYCJh6w5DErgg,2451 +torch/include/ATen/ops/_aminmax.h,sha256=rcYg1SsaIKkGPcrGibO60bJgX5PdCedBeMrixPagHbM,2238 +torch/include/ATen/ops/_aminmax_compositeexplicitautograd_dispatch.h,sha256=MteznG0qyXebTbb2FKJ_USrhV4HcPaOQEbmk2gA_JP0,1280 +torch/include/ATen/ops/_aminmax_cpu_dispatch.h,sha256=1vCSuD3wnn9AjWbSFZAn8s6TiC3_TfzSd3KWlMZZi8s,861 +torch/include/ATen/ops/_aminmax_cuda_dispatch.h,sha256=-_PjNMZ7ZQw1P1Oiohpll7EcvCoDOmv_lgHrgApoYS0,863 +torch/include/ATen/ops/_aminmax_native.h,sha256=GQLS-qsU3KZ9sOAZY96uFfwPVJYr_TRLP36aZIPq8-o,917 +torch/include/ATen/ops/_aminmax_ops.h,sha256=9tUzmvEMe7gTc1eCbO633P0XLYS2v1BUcqMZ1DWDtLY,3493 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale.h,sha256=OQRCpF1nYe4my40DDkOuFMX59U0qDmoScO2ryktAmMc,2111 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale_compositeexplicitautograd_dispatch.h,sha256=fBpAv_Tw20SWKnINqW-Uyiql5FWE9WN6StvSpfoHq7w,1210 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale_cpu_dispatch.h,sha256=jbIIFTrmYxFN86O4j3ZkF_u4QWo4D67RIuQ1icewDhc,800 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale_cuda_dispatch.h,sha256=dQAHphuahsSeTuUWzDFme3yWmGF0je5Iotgc0yuNoH4,802 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale_native.h,sha256=TAchdUFypW9SA6y7_UEVlo6-hvnpHAeIccZ6s7f82v0,1052 +torch/include/ATen/ops/_amp_foreach_non_finite_check_and_unscale_ops.h,sha256=SieQ8H5mvFZWJzTYf-RuXaNNkiHJmVsZCwSeaXTkmIg,3084 +torch/include/ATen/ops/_amp_update_scale.h,sha256=ZXl31_fF7dxeSMjk_TxPnZwu9fknDx4RehIQwWEAZAA,2752 +torch/include/ATen/ops/_amp_update_scale_compositeexplicitautograd_dispatch.h,sha256=lPi7X-wyRB-Xx3Wq0Xy9PkMM-IvaBzZ0YhZ0ToS1Gg4,1408 +torch/include/ATen/ops/_amp_update_scale_cpu_dispatch.h,sha256=-FfPHTbLp7tcTkegrNEFc_BPFLu_NUNb2JxuYR0yr8c,869 +torch/include/ATen/ops/_amp_update_scale_cuda_dispatch.h,sha256=ImG8gSNPCZJcoD117AkuE92U5pHrCqwPRQ-tusYsIak,871 +torch/include/ATen/ops/_amp_update_scale_meta_dispatch.h,sha256=pN2BeNTQkOi3g5pIF9LviKd7yyso4fAP9gSjwDh7otU,871 +torch/include/ATen/ops/_amp_update_scale_native.h,sha256=eh5KGP8GW7wpjRMaV8oy1bI8GIH7vy8i3jnkdFjVs2c,1315 +torch/include/ATen/ops/_amp_update_scale_ops.h,sha256=aTeBjk7s__sUbqAW7wY1ZkrSn0nUnofDZLTMbnFbgqo,3725 +torch/include/ATen/ops/_assert_async.h,sha256=_DtARLjocmYyX3N00SOgWKySt5YadqqRZFM_VOV1kKc,854 +torch/include/ATen/ops/_assert_async_cpu_dispatch.h,sha256=XuHdadMdTJdaSXspDUHs6UG4U0ZkgcZCfIPP3i9THE8,805 +torch/include/ATen/ops/_assert_async_cuda_dispatch.h,sha256=_ajTb4byimj7KyPeWTxtpt0B9AuY6AyTAPOQjXO7DX4,807 +torch/include/ATen/ops/_assert_async_native.h,sha256=GPa3zfe4CdLGDOz3z19_vqrimv11HHdMh5_ct2kWQBs,737 +torch/include/ATen/ops/_assert_async_ops.h,sha256=t4x4GiDz9B2m_sFuCGOH-CCsQPR6GBL2si8_a-VzLFg,1601 +torch/include/ATen/ops/_assert_scalar.h,sha256=fp2NKhTIRHwlIQEc9P-EwqagZXcWIsPIiEi_cOgj3t8,704 +torch/include/ATen/ops/_assert_scalar_compositeexplicitautograd_dispatch.h,sha256=IZAR5M7TpD3ygs4ronC-qJ_I6WjhmIdMZfuULM7TjHg,795 +torch/include/ATen/ops/_assert_scalar_native.h,sha256=Lnag7xL6dDBZDyGixATEqzV51j4C2LtCgi_yBnhlkxY,518 +torch/include/ATen/ops/_assert_scalar_ops.h,sha256=kmtmSmLOWiQfm-vy16L8y8JRociMDJoXTlRTylsbAsk,1061 +torch/include/ATen/ops/_assert_tensor_metadata.h,sha256=s_ljDZrYoLN0pk6z5XULl87QFyPEYesrhqDu6npXtNI,2406 +torch/include/ATen/ops/_assert_tensor_metadata_compositeimplicitautograd_dispatch.h,sha256=cSx2V3WaZhEoSnMeB3rqHvsZj41NdNH8ch-j5hbI78E,1123 +torch/include/ATen/ops/_assert_tensor_metadata_native.h,sha256=Uolxh10IsqSajrwDHYu4AXG3K7VHr4YNKprdBThYR_Y,633 +torch/include/ATen/ops/_assert_tensor_metadata_ops.h,sha256=YHuFnYnD13PBmF1vmwgyeBhouYtpL3u2HurBU4PPN8Q,1352 +torch/include/ATen/ops/_autocast_to_full_precision.h,sha256=mP4z8uge9gaBko3sE_VvYmVSHvTAxvD2LgvxFNr_VfE,512 +torch/include/ATen/ops/_autocast_to_full_precision_compositeimplicitautograd_dispatch.h,sha256=6Ut2E5QD-UjXFmLachijmjXp_G3jtm7CF0ULFwnzP48,822 +torch/include/ATen/ops/_autocast_to_full_precision_native.h,sha256=FAWQsJRTWa-XLhVwkfMYjrFjDlR8NFkFZPMrY4FNIuI,545 +torch/include/ATen/ops/_autocast_to_full_precision_ops.h,sha256=6lK6PUbvsPjNvQaMP6KP6PN363ltMYsRBR2MR59fgc8,1159 +torch/include/ATen/ops/_autocast_to_reduced_precision.h,sha256=i9BjJa3SqQvnqDKVZFV3FbtqgKZgD7dzqGtd99ftTtk,515 +torch/include/ATen/ops/_autocast_to_reduced_precision_compositeimplicitautograd_dispatch.h,sha256=1aZkN7eFNg3n7_nQMXGuvb0cGVxGSh40KJl4Ge5Aeeo,878 +torch/include/ATen/ops/_autocast_to_reduced_precision_native.h,sha256=fqK0ORMr0_pMjdYxm_3yzV5XvuIkPcmMXszVjPMPN4o,601 +torch/include/ATen/ops/_autocast_to_reduced_precision_ops.h,sha256=sRRM_36W4PU_nnrY8F4YOlswli-WaXn7PzUHQUnOCow,1351 +torch/include/ATen/ops/_backward.h,sha256=BA3Ln7HJsdhMg4AN0Fc2ba07wLvFC6l5leJovbSR8jY,494 +torch/include/ATen/ops/_backward_compositeimplicitautograd_dispatch.h,sha256=oNHnjLF-n-PeJhpYalcJXUPuAihGmWoZY2gQPJSiPj0,903 +torch/include/ATen/ops/_backward_native.h,sha256=Fk3LXY6bQ1FyIPUr0Shte9nDUid890ii6Fpz7rX4phI,626 +torch/include/ATen/ops/_backward_ops.h,sha256=90_cXFmN76zS6itZLLURxIY5XNv-HyVIffkhgAdZGkU,1362 +torch/include/ATen/ops/_batch_norm_impl_index.h,sha256=zhfmf_hl4lrNCQxH01aKEpmzpkNwuzre8HCQ5I5bFa4,1235 +torch/include/ATen/ops/_batch_norm_impl_index_backward.h,sha256=RvOZgblDGrfaj1uVLWp0MqkaNCrh1Eo23HPYQimojMQ,1501 +torch/include/ATen/ops/_batch_norm_impl_index_backward_compositeimplicitautograd_dispatch.h,sha256=odH_bl7TSyM6WQyBygersQDwbiUVfvpsVVyC9topaiQ,1206 +torch/include/ATen/ops/_batch_norm_impl_index_backward_native.h,sha256=KQCFYdihuNqVMYeGEkK6lb0ZA3wzJycLBcf81WS82ek,929 +torch/include/ATen/ops/_batch_norm_impl_index_backward_ops.h,sha256=UZTYR78qT7AoRp9ksjlX65FLcGaHl_YDE26lokGL880,2399 +torch/include/ATen/ops/_batch_norm_impl_index_compositeimplicitautograd_dispatch.h,sha256=9RvGkGJSx4NMPwxncNcr-sj3nvZVz5HPtLPoWUCvp88,1077 +torch/include/ATen/ops/_batch_norm_impl_index_native.h,sha256=dGpciaPg61048t5ZgQliLOYTTAHttgTuM5HGb-FqXRg,800 +torch/include/ATen/ops/_batch_norm_impl_index_ops.h,sha256=k7xBSq5Q7zrgjkjv-BN0yLFfrIGOvCvaRZ_Qng5pbEk,1999 +torch/include/ATen/ops/_cast_Byte.h,sha256=RHiXVHgdjrm4g31qxx0WUOlY51NmfZKnonGZsZrvDq8,705 +torch/include/ATen/ops/_cast_Byte_compositeimplicitautograd_dispatch.h,sha256=A8Bo7FtgsCwo9Lw_qpxlX_dskXN6CkAF7Dm1HrIyBLc,793 +torch/include/ATen/ops/_cast_Byte_native.h,sha256=voqN4qoUpKZz1BW-45WtnBvYTNA8fNTFfnVGNjYhoXM,516 +torch/include/ATen/ops/_cast_Byte_ops.h,sha256=a6JBqArF14AQBG0cldEufzAoWFS363hJNkSlA-_Ny4M,1048 +torch/include/ATen/ops/_cast_Char.h,sha256=DdYVljWjBXStij-tgj-ra9MSBCWdZ3hOwFAEqrJb98c,705 +torch/include/ATen/ops/_cast_Char_compositeimplicitautograd_dispatch.h,sha256=l8_rLTLnKmPUDcFblxL9AqD1wFMYjNYOHTZG0r1FFxI,793 +torch/include/ATen/ops/_cast_Char_native.h,sha256=W657V9UUsBFnx5jOx_U5RBzBxzeQhyBf_Qm8u9cUeNY,516 +torch/include/ATen/ops/_cast_Char_ops.h,sha256=U3lx_gTayPjDjn3u4wS-lFStkOB8N_Dasbkw4mGcELE,1048 +torch/include/ATen/ops/_cast_Double.h,sha256=_bWFU3tM-9t1rX1vnRJDSOegs9Rh5knn458dnPUa5EI,713 +torch/include/ATen/ops/_cast_Double_compositeimplicitautograd_dispatch.h,sha256=NgPrwVgyMIcenixxf_Tt5WPCyciEscJzaTv0qYHDeHw,795 +torch/include/ATen/ops/_cast_Double_native.h,sha256=7syTJSNMmibT-NNxjocfveIq6TEpXTJkBt9Z2HifeuQ,518 +torch/include/ATen/ops/_cast_Double_ops.h,sha256=eBLuq5JKaAl1DRIXU7_K4XBBydk_87j0kWo20jrLsEg,1054 +torch/include/ATen/ops/_cast_Float.h,sha256=XNmwaCb5NB4P2mNkDz7PPw6EkOkpFpx3PkzIxfTRbq4,709 +torch/include/ATen/ops/_cast_Float_compositeimplicitautograd_dispatch.h,sha256=sGLB4Am5BKLcmkexHc-9CpK16SvW7KGbiapIiGBbS5Y,794 +torch/include/ATen/ops/_cast_Float_native.h,sha256=9ketoM1FCbHlgk_MdeNMGHcNeuCQtF6YdMw_IqB36Lo,517 +torch/include/ATen/ops/_cast_Float_ops.h,sha256=7pfRgI8PiwYAgUDMaKQyi-1KbgC9uuIboa4Yets1Uyk,1051 +torch/include/ATen/ops/_cast_Half.h,sha256=VjclSrE6fyXXWE0HSmwPozzeidi3qfOX2UKRzkcCX9A,705 +torch/include/ATen/ops/_cast_Half_compositeimplicitautograd_dispatch.h,sha256=tRyePzWVLwvGxZe3nLl4byZ4CWYCsXBzTwdUWZAvcXQ,793 +torch/include/ATen/ops/_cast_Half_native.h,sha256=guRyuUJcVZhTpozZFUgz5_z0_ucMaZBWQ-uBAouzGPY,516 +torch/include/ATen/ops/_cast_Half_ops.h,sha256=e6ditpYVySgsLiasjel7fh7T9h20Rvk0QJPlIQM2Iy0,1048 +torch/include/ATen/ops/_cast_Int.h,sha256=O6UWPaFOfpht40o_KV3KrDbIu-lyfJdj3LdeQagqAt4,701 +torch/include/ATen/ops/_cast_Int_compositeimplicitautograd_dispatch.h,sha256=-59XKkROrFchPfiecd31MhM8OEk7m_HBHyk1sA9CKhI,792 +torch/include/ATen/ops/_cast_Int_native.h,sha256=gsIb3FjUfZ3iUwLn8m1F0N5I7AqlH5_1Z0jUjyFU0G8,515 +torch/include/ATen/ops/_cast_Int_ops.h,sha256=MNAtzTZvi_maVvnOh6fFMkng1P5e-H7etNc_KwmgJQ0,1045 +torch/include/ATen/ops/_cast_Long.h,sha256=ETtont1-B60IrCCdByTOMZjisLnNUsXZxSSPcVbpibY,705 +torch/include/ATen/ops/_cast_Long_compositeimplicitautograd_dispatch.h,sha256=xUpMfaOaTlrop_EaFPhi3EITulMbMEMDSqK0gHx8SGg,793 +torch/include/ATen/ops/_cast_Long_native.h,sha256=dSP293RtoHW-c6cH9VRozRr81zwqL24DBi9wY_opUuw,516 +torch/include/ATen/ops/_cast_Long_ops.h,sha256=mOBIfXNXs7xd9ynSPtHTkaZtniZl-e0yjauswijUu4M,1048 +torch/include/ATen/ops/_cast_Short.h,sha256=6ihrKHrHHf81q_nhEzG_q0C4salpGW1W9NyIdVAc7ik,709 +torch/include/ATen/ops/_cast_Short_compositeimplicitautograd_dispatch.h,sha256=iMXfYViZJ1TyUQOfeI_XKhiGzo7yj0y960N7kbk7nVU,794 +torch/include/ATen/ops/_cast_Short_native.h,sha256=V7x-M7Whrt6-cx85tuwWXcxm9TZ1LtKS3JSUCyrhy1I,517 +torch/include/ATen/ops/_cast_Short_ops.h,sha256=UK99kO0FYtcD3Ak0KedXr6qvHtJIF-0DbvgD24B5HDM,1051 +torch/include/ATen/ops/_cdist_backward.h,sha256=dyrNhb2ExWN7HO8-DGlboeiupezmNY1JpsN3k8nbY1g,1540 +torch/include/ATen/ops/_cdist_backward_compositeexplicitautograd_dispatch.h,sha256=9A90H9iXtxiHJ1M8nIqWZXlljoWGMCOZCNZrBG18SMA,1049 +torch/include/ATen/ops/_cdist_backward_cpu_dispatch.h,sha256=Ni3BgfKM5kOEZT8Plxe-QW3vZd7ktBbGOkkycjUdV38,811 +torch/include/ATen/ops/_cdist_backward_cuda_dispatch.h,sha256=Ux_rbWPpQCYWfSANwgWuJAsbc7c0iG16lOOiUKHGKZA,813 +torch/include/ATen/ops/_cdist_backward_native.h,sha256=k6FxqsGuLDKs1Oqt9iTmjEAZM3v_pj7MT4XpG_buLSY,747 +torch/include/ATen/ops/_cdist_backward_ops.h,sha256=MmbFpFgX4yGy6PSv8QmJfx9Jc3axE7_Yte8C1xMLMOk,2198 +torch/include/ATen/ops/_cdist_forward.h,sha256=m4uE_gWYSVNX4prVjffAxL0SbiUU_sLoYaFnYGAJZgs,1467 +torch/include/ATen/ops/_cdist_forward_compositeexplicitautograd_dispatch.h,sha256=vQnKtazfxrL1u1w-bi8FyK5eldWK2oOWlBe8pI96taE,1019 +torch/include/ATen/ops/_cdist_forward_cpu_dispatch.h,sha256=1TXpzN4sfM6-L0qt0FB3mZGPis381Qtel274uGPROBU,796 +torch/include/ATen/ops/_cdist_forward_cuda_dispatch.h,sha256=JcTr9_Bw9X_h5H4WV56dAd4L6Yt4SCkFo0_x_Vjy_To,798 +torch/include/ATen/ops/_cdist_forward_native.h,sha256=SDkcs40SRLLoXrS_9zvYsad9gqKI-DU8TIIrLNcTbVw,717 +torch/include/ATen/ops/_cdist_forward_ops.h,sha256=KiEpF5UwnBUIrXZz3NIJX3pW_ciJCisuRkreplwTClo,2088 +torch/include/ATen/ops/_cholesky_solve_helper.h,sha256=fQOA0LYSKE3YF-wi06I608baXVMar4Uoc4cItyKKDzo,1373 +torch/include/ATen/ops/_cholesky_solve_helper_compositeexplicitautograd_dispatch.h,sha256=R9dhWqSsEkt1nkOVqMzBvQnKT45ljx72pFJzHv1FnSM,967 +torch/include/ATen/ops/_cholesky_solve_helper_cpu_dispatch.h,sha256=43oV4ihJqQtfaq8sY6TAGC6FsRU4XeSqw365JopW-Zw,770 +torch/include/ATen/ops/_cholesky_solve_helper_cuda_dispatch.h,sha256=JXYLAPjiIVfr4JECqAlolanWHcig2qcg5ntyYwKptK8,772 +torch/include/ATen/ops/_cholesky_solve_helper_native.h,sha256=ElLKydUMyUzygJcKurOhP73pqd2_mXHRALQ6WyCNlNI,778 +torch/include/ATen/ops/_cholesky_solve_helper_ops.h,sha256=ezBXam7CZu44XaAOvgFJLbZEdEoQa8Hhkp_6hiO1tv4,1918 +torch/include/ATen/ops/_choose_qparams_per_tensor.h,sha256=7G-uCZjSpJOi3kBSgTwj-x6Hr3E6y_RKmhX1NXet2wE,793 +torch/include/ATen/ops/_choose_qparams_per_tensor_compositeimplicitautograd_dispatch.h,sha256=esZEMdKWR5RkSQE4sCaDUMhBYvMLOE-DoAKjXFPFahQ,827 +torch/include/ATen/ops/_choose_qparams_per_tensor_native.h,sha256=_ZCK0RupMvLpBiEm0g9PxZnZPG-JOpFZ44EsfoGpiSA,550 +torch/include/ATen/ops/_choose_qparams_per_tensor_ops.h,sha256=ZzywxGvh5kzvfsqi0e-Fi6d2apa7UbrXBjApqZSCbxk,1156 +torch/include/ATen/ops/_chunk_cat.h,sha256=VJySPI2X54Jdvds7tV7qv-1DZQ2oqSOXZ0Balh0AOfM,1301 +torch/include/ATen/ops/_chunk_cat_compositeexplicitautograd_dispatch.h,sha256=Sv84YLH9XbleBK10RBeYW9r5g7flE-WhM1RPuO7MQC0,1029 +torch/include/ATen/ops/_chunk_cat_native.h,sha256=WdjzdB7hQ5ZZ5lqVFnTEVjuFpQbxk5JHvtZADJvmHlA,637 +torch/include/ATen/ops/_chunk_cat_ops.h,sha256=0dWpxGAH62PQgFju6_WwXYpXC3V1V3sbTFTQ_YCzjMI,1830 +torch/include/ATen/ops/_coalesce.h,sha256=fV1SQK18gGRghO3X-9UEUDw_uOS2q1mMVCnoSqlftoc,1045 +torch/include/ATen/ops/_coalesce_compositeexplicitautograd_dispatch.h,sha256=MqZGPzLt05vsPP3G2qlM-v14odHE9p_hFBho2phUCZ4,873 +torch/include/ATen/ops/_coalesce_native.h,sha256=7HbVZhbqQDH05DYLoQpPF4VXzVZC7nqVFOKQJPe1Tao,651 +torch/include/ATen/ops/_coalesce_ops.h,sha256=cfdIl40u0LQtV8MON3XJ63QD3KepG4UAPiMbywxY99U,1608 +torch/include/ATen/ops/_coalesced.h,sha256=iwV6dmaejIXRGYJdHfluUseXXREMvnTWhkmq_0d0QSc,1184 +torch/include/ATen/ops/_coalesced_compositeexplicitautograd_dispatch.h,sha256=y-77fkAkkrFMG6exwRBa3_jveOoWvSuLqF-EVlNUV3g,981 +torch/include/ATen/ops/_coalesced_meta_dispatch.h,sha256=xw8dgdJtozkYpwN_n6Jj-izJmM643tDjj3PV519DGEg,739 +torch/include/ATen/ops/_coalesced_native.h,sha256=3Gi4bQkG8vXzlH1h_9cMS2E2YxOFaK5iwMxtfNOKA2A,683 +torch/include/ATen/ops/_coalesced_ops.h,sha256=wd0q4UG7XGNEeOP9OW-TqAvAZdGVzxJe9mQVoJVHKak,2320 +torch/include/ATen/ops/_compute_linear_combination.h,sha256=aR_V7q6wah4wkWwfuZf1zXSP6NVCMEfgRj64vQtlBC8,1438 +torch/include/ATen/ops/_compute_linear_combination_cpu_dispatch.h,sha256=zMOsx4HlaNySt8Q6S2IztS8H12Jv7GslE7Tj4bYhyfM,1042 +torch/include/ATen/ops/_compute_linear_combination_cuda_dispatch.h,sha256=kL8uPnJ8onlkXzyYf5MpQXZcpkhlfvIyxgtf535Q-8o,1044 +torch/include/ATen/ops/_compute_linear_combination_native.h,sha256=0ds8lR3ZO4OkN7Il4ZQNACsJO09_-CFSbpu9SqTdgd4,675 +torch/include/ATen/ops/_compute_linear_combination_ops.h,sha256=YhGUYRz6dmi1CmXDngg3I7ut3gXfhtpUVKssDXceph8,1936 +torch/include/ATen/ops/_conj.h,sha256=YPGMiopGjcWTemfjIsSvUvhUxnnC4L5IPLh3vdD4gH8,627 +torch/include/ATen/ops/_conj_compositeexplicitautograd_dispatch.h,sha256=jZikQR9eAS7_84oP6v4-NemdI_qXnbJ9UUk-j6frXvU,763 +torch/include/ATen/ops/_conj_copy.h,sha256=qJ956ZJ5QV3llb9q-pMUmjnjI2CuGTf-tKy7Aui9wVQ,1055 +torch/include/ATen/ops/_conj_copy_compositeexplicitautograd_dispatch.h,sha256=ITqhMVVxq5_OuH8sPJRg_OSydjhNu8a25UfNSIGcPdQ,875 +torch/include/ATen/ops/_conj_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5uOogQG4enxDme07Ey3zH9HFZIHf-Y-1FUGgMDwftZE,794 +torch/include/ATen/ops/_conj_copy_native.h,sha256=EwnZwsTi3HC9fi2lakAaUk_RR4vKFK3tM_Q4CX3EbdM,573 +torch/include/ATen/ops/_conj_copy_ops.h,sha256=NLM0MdkSgQmDnH2Uud11ju9G8GSs30TZBv32eUDIEbA,1614 +torch/include/ATen/ops/_conj_native.h,sha256=B7CX_tD2EYWplkVxlVvIVAkBKFJpEosPANA09X1KRG8,486 +torch/include/ATen/ops/_conj_ops.h,sha256=K6O11K8u8lBbN2hmuW2kTHEhwe2vU5KayHBiBAZIaIc,970 +torch/include/ATen/ops/_conj_physical.h,sha256=vRKiozJWhg0rbME3iF--eJ8bxwSSwsQdJ_BA2jBzK50,1095 +torch/include/ATen/ops/_conj_physical_compositeexplicitautograd_dispatch.h,sha256=36yGLH4a7Kbv2Z2kIKESRc6qNFut53VxqPMBlJ7o75g,945 +torch/include/ATen/ops/_conj_physical_native.h,sha256=wrBhDuoZ1cwY0wRDdo6eionI3SDaiaaJOY80XCrPUp0,653 +torch/include/ATen/ops/_conj_physical_ops.h,sha256=aMesGzfsS8w0ohDy2bbVBgqPxlOm-Cy2F5FTuB6g93Y,1638 +torch/include/ATen/ops/_conv_depthwise2d.h,sha256=w4o-p38TEDY2riy7-Li9-5I_2mWXCnUZTw93wtbmEm0,7414 +torch/include/ATen/ops/_conv_depthwise2d_cuda_dispatch.h,sha256=ILqD50SxSBepwBTq2EFteek88C19aUaUx7jDakLqVgY,2299 +torch/include/ATen/ops/_conv_depthwise2d_native.h,sha256=2884fL6QNvWg2leACK4Sm3I9Pu2vgA8MWy4VxVCULro,949 +torch/include/ATen/ops/_conv_depthwise2d_ops.h,sha256=QVE_nP6qLrTcaj3v0hFzulMJxv_xeq1684PM-0oDUHs,2936 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr.h,sha256=1kVrChziYOnz8a2brFaYE0Tax-gmKKB4Q0p1_pqvwSQ,1527 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_compositeexplicitautogradnonfunctional_dispatch.h,sha256=md898hSb-4WDOxW9KufkwciemixPF_10Ve2vBN_lNDg,852 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_cpu_dispatch.h,sha256=hKgFj4X_n6sg3csuJ7jny8QZXY8jGPRi9hpKVLgj5iM,1057 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_cuda_dispatch.h,sha256=Iao57wZRMkkoGouJIRAUiUytDQPBAml9Y5VdSuIDKI8,1059 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_meta.h,sha256=GZHW4ho9HRpVedxtYgPEc-YKworYOTfpt91b4lrAUqw,642 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_meta_dispatch.h,sha256=_1Q8s0nRcH5NL4dJG_8S8P1FP75gC-4dROpiWWjG-ng,1059 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_native.h,sha256=H1uB-Nm-yIwrpzjGoIu6SrxtxMb7tww8fDAwgOshTME,961 +torch/include/ATen/ops/_convert_indices_from_coo_to_csr_ops.h,sha256=0P-3Oly002KEQJigRq44J4fA5kgrfKEFuolrMxFzBxM,1963 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo.h,sha256=YiLHa9b9Lclqzi40zmrgu38bknO7ok79cJ3hICmi-tU,1863 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_compositeexplicitautogradnonfunctional_dispatch.h,sha256=TNtGIa4b90GgtIVS5jNxC8qoBHEjjMF5SdzIMrRLyCc,900 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_cpu_dispatch.h,sha256=yq_-BrDXjpDFMuVIuGZqybAfopDI1gzebezD4i-nKts,1195 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_cuda_dispatch.h,sha256=d_AHh3CDUBX4Z6xI-rvGIH31nV1MHRLY8qXCIAEIP1I,1197 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_meta.h,sha256=hrmIbRrvZPTgmd_KG2QCTnvXN5pB5I9X0ZZmwr2OoOU,684 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_meta_dispatch.h,sha256=DakGc8cs4QhgEXH-DlHrUcnYoLtDKc2e5cQxO0oEKOA,1197 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_native.h,sha256=QZ9oAazkM5_5kzenv5-OiHfAl1VHRSCbbD9LZ_gDIBY,1045 +torch/include/ATen/ops/_convert_indices_from_csr_to_coo_ops.h,sha256=K8c2_sezzWkMEy8VnLzqERAa0wajc9YyNyxDnB7Rc1w,2245 +torch/include/ATen/ops/_convert_weight_to_int4pack.h,sha256=jyoSCzvdLDz3cRDji2mJU9hqmuOPZGLTbYTaBfd0b5Y,760 +torch/include/ATen/ops/_convert_weight_to_int4pack_cpu_dispatch.h,sha256=-NuCazKc7jk0GSdxyys87-YVXwRImNx8wNUjhnGuapU,762 +torch/include/ATen/ops/_convert_weight_to_int4pack_cuda_dispatch.h,sha256=GxONpxSGHOf9Rsl9ctw8s-HfbPjCue6den_bnKPRU2s,764 +torch/include/ATen/ops/_convert_weight_to_int4pack_native.h,sha256=8Xqg2ycCcvHKeNhxTMxMKHvV_wKXR2iAyiBQouPKwOs,634 +torch/include/ATen/ops/_convert_weight_to_int4pack_ops.h,sha256=zSZJQcAprZBun480B0k5PttmqrvGSRedWGyAsQ0b8mQ,1098 +torch/include/ATen/ops/_convolution.h,sha256=vI8DHLMWJSu3VTisV72kzmpJeMPpUT4n4b_rZXiWGO8,12974 +torch/include/ATen/ops/_convolution_compositeexplicitautograd_dispatch.h,sha256=AIqNfKwsHYTxPoWn2O9kaAu2FOo8JR8EVdNfV5FjDj8,2935 +torch/include/ATen/ops/_convolution_compositeimplicitautograd_dispatch.h,sha256=KhEu8yZ-luOe3djhd7X0OgfD4fZjeGAIHYsTF3m221Y,1381 +torch/include/ATen/ops/_convolution_double_backward.h,sha256=LSgF3pku0VwIc0gMfGtflJA52o39-Do8MRHey7wnRdM,4009 +torch/include/ATen/ops/_convolution_double_backward_compositeimplicitautograd_dispatch.h,sha256=SC4ia7hLSxLqzc9J0Bb1iuviYan82mJFxaq9TX0rkp0,1643 +torch/include/ATen/ops/_convolution_double_backward_native.h,sha256=UFw0mzJlb2a0p0Ju9jZgNYpKF-UC1pdjV2XC_wRTBw0,886 +torch/include/ATen/ops/_convolution_double_backward_ops.h,sha256=-emyeEMPB-jNVxwVxNjubaFzMxLIsgY6geO2WcVXiDM,2348 +torch/include/ATen/ops/_convolution_mode.h,sha256=APj_yKI3UQqdH-MBZ2yiYjTWmicSs8e3XXKsB3g7PEQ,2446 +torch/include/ATen/ops/_convolution_mode_compositeimplicitautograd_dispatch.h,sha256=zfgYx3UXFvcxPwL-A1pZmuRRw-nxl2qYGV5Tc_31NuA,1179 +torch/include/ATen/ops/_convolution_mode_native.h,sha256=h6FhQydwifmtd7cuX2bxgfYdLldotcOxyZvYmdZFkrU,677 +torch/include/ATen/ops/_convolution_mode_ops.h,sha256=L46rsXJ3RoALqbJTon4fHh1V2RD6QpCJkHrt-JxZ398,1566 +torch/include/ATen/ops/_convolution_native.h,sha256=e-ZOnVOXYT5cmPWhWP4s9xiQpb4U5bZPivD9TG07R0s,1490 +torch/include/ATen/ops/_convolution_ops.h,sha256=V3vNBf1eOE9gljt3ZBsQbdUB64KajFtI_4TqjQLqxCY,5131 +torch/include/ATen/ops/_copy_from.h,sha256=2qQhbSJ-QQvt-RKMtMtVQFMknrz9Pmo7ly3FPvhergw,1364 +torch/include/ATen/ops/_copy_from_and_resize.h,sha256=wiEW64yWszIidTOj24DnZRjjWhOfAF9HlMkGWji8J0U,1288 +torch/include/ATen/ops/_copy_from_and_resize_compositeexplicitautograd_dispatch.h,sha256=wdWwmc8ggmZTGrHuXMLqI3KwiChhLh1PXzr7sRHDTFo,945 +torch/include/ATen/ops/_copy_from_and_resize_native.h,sha256=dntgG6QblJUD4qGi6UXERNIqsT6oDbGB8ijClrthVWw,550 +torch/include/ATen/ops/_copy_from_and_resize_ops.h,sha256=QCaPmVcrLGQpSoVT_khxqepmD02r1TgjOYMwxFgPNNA,1840 +torch/include/ATen/ops/_copy_from_compositeexplicitautograd_dispatch.h,sha256=ThwIHqVmopNlQavWr8FdTUNYxFjxbBYElKenPsAuvBY,967 +torch/include/ATen/ops/_copy_from_native.h,sha256=Erg_kVnWLCLDykVAI7wC8SeHwHQIH0E_8VoCnVln8wc,558 +torch/include/ATen/ops/_copy_from_ops.h,sha256=Nz0nuid5S3bDX5xdJFm00Mbjr9XVoO00i4gAchqms3E,1912 +torch/include/ATen/ops/_cslt_compress.h,sha256=Mg4djlg9bHwfWia7kTsTFdYqjsWUyiP_UrmlFyGCFMk,660 +torch/include/ATen/ops/_cslt_compress_cuda_dispatch.h,sha256=do4dKVCbxCekhM_ytJgcp7iQgwV6ARtxvFeZhD7pthg,731 +torch/include/ATen/ops/_cslt_compress_native.h,sha256=SCY0xKJlLaFexNadvRMerD0m1jVOsNpP8jaA5Roq8pc,496 +torch/include/ATen/ops/_cslt_compress_ops.h,sha256=wiUSSkqr8fhjCAnxahyZOfUyLFjaoZpTFR-eslQf650,994 +torch/include/ATen/ops/_cslt_sparse_mm.h,sha256=JcBVtnIq1mEMF1Ljmkx0xoKrM_8rcGhVVLwx3C6TESI,1086 +torch/include/ATen/ops/_cslt_sparse_mm_cuda_dispatch.h,sha256=O6kaq71XMnIBH0-sQskV0kgj7XbG1j724vRgfS7xpsk,955 +torch/include/ATen/ops/_cslt_sparse_mm_native.h,sha256=Jp9ktuaoDOTrn4mPQM-vYoasvTcs9FFCzI3gu4wcNRw,720 +torch/include/ATen/ops/_cslt_sparse_mm_ops.h,sha256=qapFRZ4yNCMNiol5SklTbWAceh6PCvznyWglPv6Zbr4,1658 +torch/include/ATen/ops/_cslt_sparse_mm_search.h,sha256=3LgunCwr9HmAMIcUAPrNSPAFEYZJ462BRnJOQuYHSfg,1068 +torch/include/ATen/ops/_cslt_sparse_mm_search_cuda_dispatch.h,sha256=2p8ThDJjSudSc2A8muCtjv0hGbA4eyJU_ea-GsgFaog,941 +torch/include/ATen/ops/_cslt_sparse_mm_search_native.h,sha256=RnSAsz92imcHFasNwsrMCEAcFxB3KSrC8hoBzFeipeA,706 +torch/include/ATen/ops/_cslt_sparse_mm_search_ops.h,sha256=Ro9xce1arFNRNgLCFZgfxgXfSHLbSqADeZvroaD7HHA,1612 +torch/include/ATen/ops/_ctc_loss.h,sha256=YhMY9QY4u_VeSQlOB5zhIKV4nl7l8-OK5Q8NLaEFSNk,3915 +torch/include/ATen/ops/_ctc_loss_backward.h,sha256=_NxiThbZASi9eMj2DR1fW4vfB_baICn8TDIlR43q9lQ,3298 +torch/include/ATen/ops/_ctc_loss_backward_compositeexplicitautograd_dispatch.h,sha256=kl_9-LmsGN6WMTNelqwUDYDfGEYvrMuBWLJIw2ffnrs,1347 +torch/include/ATen/ops/_ctc_loss_backward_cpu_dispatch.h,sha256=dPm-AFGOpsPQqGUewFPxT6mjN9uxvL3jpBD3U7yXC8k,1266 +torch/include/ATen/ops/_ctc_loss_backward_cuda_dispatch.h,sha256=nNB1uGt5DbIaevZyoRznT_HvUMGtYP56EB0Sc0t_Eww,1268 +torch/include/ATen/ops/_ctc_loss_backward_native.h,sha256=nTAeiHlMqH1W0eQwN4Z9fIFelqzuj1tMxySW1GWv24k,1657 +torch/include/ATen/ops/_ctc_loss_backward_ops.h,sha256=O2TC6X4kSAgXSrxPk1nCfJ4nlEF8PPGvMqbUXqrmi8c,4485 +torch/include/ATen/ops/_ctc_loss_compositeexplicitautograd_dispatch.h,sha256=Fq1vpNflvoQktKiMH1k2iDk_YEj7Cs0idp_99aHIMKk,1776 +torch/include/ATen/ops/_ctc_loss_cpu_dispatch.h,sha256=mIzleZfbzRhJgZGmpIEzucFVxTTrS7vBl_rUWT2iXbA,1114 +torch/include/ATen/ops/_ctc_loss_cuda_dispatch.h,sha256=ck6S8jzMRKK6u_EiPPf9KqGs6SwfWuxbuiqYBdwTSRA,1116 +torch/include/ATen/ops/_ctc_loss_meta_dispatch.h,sha256=xefcrBu9JD2xrpA4NoU3iKsghd5R_LCAuOadz2QVRUI,889 +torch/include/ATen/ops/_ctc_loss_native.h,sha256=gvQ0UF2jjQZ6pOO7i1vdmTX5YpFmNLOH2XP1TJwiHKs,1870 +torch/include/ATen/ops/_ctc_loss_ops.h,sha256=99_RMcyA6SXTLgsBGdJQg-JGTgdDna9ce9uzYVnXhHs,5103 +torch/include/ATen/ops/_cudnn_ctc_loss.h,sha256=BUv9Nz54-RQSjqE1wNRjMx1mudPnfSjGLm4O5o40hcA,2923 +torch/include/ATen/ops/_cudnn_ctc_loss_compositeexplicitautograd_dispatch.h,sha256=JF0waOMeVxAyo53VBOYnZiuW8ocLlTx_0yb0VBKInbA,1281 +torch/include/ATen/ops/_cudnn_ctc_loss_cuda_dispatch.h,sha256=Gf5sklXww9HrY3XRUTw0Iv6TRQLGFC_FhFdLnNPpl84,1152 +torch/include/ATen/ops/_cudnn_ctc_loss_native.h,sha256=A9Jww5sc4aePuN7dEity-RAV0XYFZopw87GWZ8Pl1L8,1209 +torch/include/ATen/ops/_cudnn_ctc_loss_ops.h,sha256=Ewwxy2_rNqLIqQiU5joW_fZzNMO9blEdmZSrp6lfggY,4057 +torch/include/ATen/ops/_cudnn_init_dropout_state.h,sha256=A0uGGr1YCCJuvnXCrGkoL8P3xIE15ANjbhfFPXp_nmo,2229 +torch/include/ATen/ops/_cudnn_init_dropout_state_compositeexplicitautograd_dispatch.h,sha256=CWO2TOuEgM6H101FHJp_zK2AYqALVb8rZZsgfQR8TKs,955 +torch/include/ATen/ops/_cudnn_init_dropout_state_cuda_dispatch.h,sha256=mLNNd1Fi6lu7L1y4nJajmZrOfex17Nx27oPhHnMQqfA,1028 +torch/include/ATen/ops/_cudnn_init_dropout_state_native.h,sha256=xgbdFNVyIzilqetPQQFnDN4RVRJuqO-FDclvJpgGkDY,802 +torch/include/ATen/ops/_cudnn_init_dropout_state_ops.h,sha256=1-zA_lIHuLGSLuo2N_0aY4cTukPYDEWsfOw5WqrLUTI,2347 +torch/include/ATen/ops/_cudnn_rnn.h,sha256=QPBMlk9I_lq2sBY0uoZl6QcCq9LfsIpMBW7c374geno,13289 +torch/include/ATen/ops/_cudnn_rnn_backward.h,sha256=6wPp5sgY1wX_VlObAutkioWQ7G7tr_57-l8F4us7EaA,16356 +torch/include/ATen/ops/_cudnn_rnn_backward_compositeexplicitautograd_dispatch.h,sha256=0h4_9hMy2PdyleBehSFtlI1vKmWqRU7mlSNSLM7avB8,3642 +torch/include/ATen/ops/_cudnn_rnn_backward_cuda_dispatch.h,sha256=00IY4oKRJ2vt8AvgpzHbdkKm5CF7EWjuQutYNEiWMRY,2105 +torch/include/ATen/ops/_cudnn_rnn_backward_native.h,sha256=VtVNlK1lPO___d9F70ydNe4MI5q1L9WKyUu05xrWYMY,1884 +torch/include/ATen/ops/_cudnn_rnn_backward_ops.h,sha256=svXeLhhkwKfAi-jLzG41MIxRjoaBhltUsM6y3pMOxQg,5944 +torch/include/ATen/ops/_cudnn_rnn_compositeexplicitautograd_dispatch.h,sha256=3aghvtziztXrHqBf_c1p0bbSoXZLwba3dScOo9eW-14,3142 +torch/include/ATen/ops/_cudnn_rnn_cuda_dispatch.h,sha256=i2eiu2xd2bWfjk2FVVqhvw1wWEhfFhaPcOwx2aMhIV8,1665 +torch/include/ATen/ops/_cudnn_rnn_flatten_weight.h,sha256=mAMIceSydHAdREBajpwJ2lQiKupp7PORYuT2Owy0cxs,7602 +torch/include/ATen/ops/_cudnn_rnn_flatten_weight_compositeexplicitautograd_dispatch.h,sha256=BJVzLpteJFddpkcwqbtzzRXZ84oFT0UJcFtR1PVeLes,1770 +torch/include/ATen/ops/_cudnn_rnn_flatten_weight_cuda_dispatch.h,sha256=u_pJP2-G8x-7euEaNl-8FsKjjViffuFU4hfxz6INzDE,1149 +torch/include/ATen/ops/_cudnn_rnn_flatten_weight_native.h,sha256=AbSmPWA2eR9sxLU4IHC9adXucTje00PycyRVpxn67Tg,938 +torch/include/ATen/ops/_cudnn_rnn_flatten_weight_ops.h,sha256=piLnvsvAkss19dXLptgCBP-zpC79Adyi1E8bcNqRYGw,2830 +torch/include/ATen/ops/_cudnn_rnn_native.h,sha256=fPAJiig58cYIBMooVyIfpBz6f-fsNjym8RB6prxKIV8,1539 +torch/include/ATen/ops/_cudnn_rnn_ops.h,sha256=ILk3psljCcxeDyL4OLw_G7Dn4bL7RPwA31exjNtxua0,4881 +torch/include/ATen/ops/_cufft_clear_plan_cache.h,sha256=tJYswNNetPHqwhh45NYxch3ToH24C_2oQoCQ9iDszs0,709 +torch/include/ATen/ops/_cufft_clear_plan_cache_compositeimplicitautograd_dispatch.h,sha256=_zAa6vTMd_tkB4mM8NvpiJxDMeaPhLWa_uUW8YjFjdI,780 +torch/include/ATen/ops/_cufft_clear_plan_cache_native.h,sha256=-EmzFAImvwOv5NPzE98QBGX2TSYeTbqdFK6g4AxxHV8,503 +torch/include/ATen/ops/_cufft_clear_plan_cache_ops.h,sha256=YKfi8SSCV3rmq6IcDJ0Jj2fr4bgQzoyeS0qS21yncrw,1016 +torch/include/ATen/ops/_cufft_get_plan_cache_max_size.h,sha256=cQ-oHzNZyuXwQH_ttGxL1n6vMAhNbGSRNBup59E5mCo,741 +torch/include/ATen/ops/_cufft_get_plan_cache_max_size_compositeimplicitautograd_dispatch.h,sha256=lRuQnwaWw3MyqCJVobNl1rkQAGvo56gpvfXlrC2-eOc,790 +torch/include/ATen/ops/_cufft_get_plan_cache_max_size_native.h,sha256=H3Kp7TlZ8HbWR4CfW-LvNtqfA27QilxKWRNcxiDnK54,513 +torch/include/ATen/ops/_cufft_get_plan_cache_max_size_ops.h,sha256=GUp6B3O3eEa6tYxKlqsL3ZEUzXkzxBk50GQiDvHVgBQ,1047 +torch/include/ATen/ops/_cufft_get_plan_cache_size.h,sha256=IOhWVYkCbx0y2jslu9CPh7qV0ELh4diOgrUkfJU4gUg,725 +torch/include/ATen/ops/_cufft_get_plan_cache_size_compositeimplicitautograd_dispatch.h,sha256=2BTxfDzNqtSojYHHw8B7ccMCU592V4JhR_vjt4kdReQ,786 +torch/include/ATen/ops/_cufft_get_plan_cache_size_native.h,sha256=eJK-GWD2KMPft97wtAmchoYGjvtZGjrEsuWg3K3GEGk,509 +torch/include/ATen/ops/_cufft_get_plan_cache_size_ops.h,sha256=CJewpscUeht6p57VzAzf4CbJYjz6ANr6wPhjhrGcPtg,1035 +torch/include/ATen/ops/_cufft_set_plan_cache_max_size.h,sha256=zWcmpj5mTQlWUIr3DLSDJk2SQIJjV9wCShhLdvaJJX0,779 +torch/include/ATen/ops/_cufft_set_plan_cache_max_size_compositeimplicitautograd_dispatch.h,sha256=DfuJklbzjdJcVOG2ZhX0tCmFNjAy1ysloO0GlJQGO3E,805 +torch/include/ATen/ops/_cufft_set_plan_cache_max_size_native.h,sha256=KPJykSwsLCIDedmdxu_AO5myFdTFfF9x8VyntoydX50,528 +torch/include/ATen/ops/_cufft_set_plan_cache_max_size_ops.h,sha256=7PNnKjWPX2msB8tTvtWcYmKxjED-4724nul0sz84s_w,1096 +torch/include/ATen/ops/_cummax_helper.h,sha256=XhVo6u2wkFL_3qn3WOGLiAudT56vL8dUF3DGvji0YGg,773 +torch/include/ATen/ops/_cummax_helper_cpu_dispatch.h,sha256=prmNk9iXFh9bhJf5CY68Zj8DCMOamkPXTtYMwG-72-s,778 +torch/include/ATen/ops/_cummax_helper_cuda_dispatch.h,sha256=HnvH5-1VDTYq2XZxb043--mDlJhnHHq6Cc2mEdNv3x4,780 +torch/include/ATen/ops/_cummax_helper_native.h,sha256=h4vOOUiQSJxVy0XtXntrJERG37o4X1WVwMqIR0-AzN4,664 +torch/include/ATen/ops/_cummax_helper_ops.h,sha256=6D2L3WyYXhuSo4zCD2yIY6crxFC3nb71azQCZtg1jKQ,1166 +torch/include/ATen/ops/_cummin_helper.h,sha256=bgiDvYRCXuhpGwO0DqATtOf76MZGcYE5d1HCm2UHnak,773 +torch/include/ATen/ops/_cummin_helper_cpu_dispatch.h,sha256=tcfCKkNvNnUVesdZAJKnoXZJzgPG02ycOCT41lgjV_w,778 +torch/include/ATen/ops/_cummin_helper_cuda_dispatch.h,sha256=aBX8KYjRtYg-DAyII4U9UAtlNWve1xRmJADhYs5VV6U,780 +torch/include/ATen/ops/_cummin_helper_native.h,sha256=Rk_DVBUDrepya7CQricXm-NxVH89CUfBuIs09A9QkPQ,664 +torch/include/ATen/ops/_cummin_helper_ops.h,sha256=nsa3GtmHcJIthSOJ7Njf0b4c0YLW45ebGTkDa1mxI0Q,1166 +torch/include/ATen/ops/_debug_has_internal_overlap.h,sha256=GPX0j-ZOGV9-ScaJWekdGtfuaeBgrPB-DstkCEMj9aI,703 +torch/include/ATen/ops/_debug_has_internal_overlap_compositeimplicitautograd_dispatch.h,sha256=sV2dyBa-zqA9LrUeTsAbnaeNUNYiT4-EiVLehG_l-wI,782 +torch/include/ATen/ops/_debug_has_internal_overlap_native.h,sha256=ewhdXYoN0PrOoc7JQdT-UOENqHysNY2p5lVqiOBpSts,505 +torch/include/ATen/ops/_debug_has_internal_overlap_ops.h,sha256=HreuQ0EXOMjbhA0nlJkIr0HKeqFBGIpL2zzYdX_m5dE,1018 +torch/include/ATen/ops/_dimI.h,sha256=44eVO7tso_T27h2f0P1yXW8rMj2aMOKACczlVnQdE5Y,490 +torch/include/ATen/ops/_dimI_native.h,sha256=2sW3FVYRgu-JsEgrCXcoxeTmraGeAIM6ATskzZk-Gt0,495 +torch/include/ATen/ops/_dimI_ops.h,sha256=2jlhrQAoabzLHQVhpmhLfVYisEe3tElfWo0CLsj39fg,952 +torch/include/ATen/ops/_dimV.h,sha256=i9cbS1xqoxZ2lnJOYFtCtA_NvLTBjgRIfK0lNl8S2w8,490 +torch/include/ATen/ops/_dimV_native.h,sha256=GLAmGPp0Aoht5F7RDaRc3slnkInG83-newlUEyuiBgU,494 +torch/include/ATen/ops/_dimV_ops.h,sha256=jA9e_0Je5RHaHERwaGCYQbhPkrDd78e2N4crjIV0cKk,952 +torch/include/ATen/ops/_dim_arange.h,sha256=ezSdTOIDsNhFKKPAy0LXde3EFIGb-6YAGy2MvRG3EXw,672 +torch/include/ATen/ops/_dim_arange_compositeimplicitautograd_dispatch.h,sha256=1Ypjbef56celQqCM8-Zaz3dnCH7w8xwEWxd7d3E-5Xs,782 +torch/include/ATen/ops/_dim_arange_native.h,sha256=PqvWGCUlNVKG1xSCL9l7Zpm9Qc6KSlxUHhM-nc2j74A,505 +torch/include/ATen/ops/_dim_arange_ops.h,sha256=kK6Jqw-bD8MTP_g7jS-HEDR5zl_kX2FalXx2rTgKq2g,1026 +torch/include/ATen/ops/_dirichlet_grad.h,sha256=tKqu5Vak-nAlXFaDXOP53vxVF0S7YGScNTWoKTsgZaY,1360 +torch/include/ATen/ops/_dirichlet_grad_compositeexplicitautograd_dispatch.h,sha256=CJ2r5c7rwdF-oFbGBds_bkpj6ckaPTexp-q9iJcUeqg,983 +torch/include/ATen/ops/_dirichlet_grad_cpu_dispatch.h,sha256=2f4DEVNY5upltnWRxuG0UJ4qXW28myAnIerYbWhc6UY,778 +torch/include/ATen/ops/_dirichlet_grad_cuda_dispatch.h,sha256=BrBAlWqCoBf1imK-MlVkXdXVRWWDOBV9JzC8VDuKpko,780 +torch/include/ATen/ops/_dirichlet_grad_native.h,sha256=Onop_NSzEud3SwQLAQYLWSNywtWabo6ZlwlykvDg6qM,802 +torch/include/ATen/ops/_dirichlet_grad_ops.h,sha256=YJrC3s14SxTZ1ASD08xyvLZnK6kUuwfVvV1Ea6hrw7g,1970 +torch/include/ATen/ops/_efficient_attention_backward.h,sha256=DROklj8vLDVtGGgHdVGRZxgQTIMNSns_ZSb7c4igiTg,5320 +torch/include/ATen/ops/_efficient_attention_backward_cuda_dispatch.h,sha256=APYGFDzomf1H4twJ8xAlbqHD1zMY8vNgIH0Hwk7MVTI,2019 +torch/include/ATen/ops/_efficient_attention_backward_native.h,sha256=IreL-tJfy2z4eW7bXBE5PivZv0BBAsRLDSiFnv6JVvI,1101 +torch/include/ATen/ops/_efficient_attention_backward_ops.h,sha256=NPYlb80v4Yg6EHxllpXc5SzP4mb0S8T_2D91xQq4dlg,2925 +torch/include/ATen/ops/_efficient_attention_forward.h,sha256=XVD9mafg2mhhslNK4mDhbghZLmxB31TJvCtkeI9poR8,1812 +torch/include/ATen/ops/_efficient_attention_forward_cuda_dispatch.h,sha256=Dn_Gyp60GHymBuEalC71vy1Fu_AfpU3al5mpAnVfcJE,1294 +torch/include/ATen/ops/_efficient_attention_forward_native.h,sha256=NqFV_U1suZ5PCncXVD24du7oy42NVRo0-i-PwHGR4qk,1059 +torch/include/ATen/ops/_efficient_attention_forward_ops.h,sha256=G5yASCXSVY-EValgAoa7i2vvnfvNg1vzG6SdYsm_Eao,2854 +torch/include/ATen/ops/_efficientzerotensor.h,sha256=8l3Ppvy6MPKRTQ-P2LcoIH5x92uNNZpEv9YT4E1euJU,6036 +torch/include/ATen/ops/_efficientzerotensor_compositeexplicitautograd_dispatch.h,sha256=IUaSge0k6HkAyRavA8GukdP5Lewhrtum9tbYAMlImKs,1090 +torch/include/ATen/ops/_efficientzerotensor_cpu_dispatch.h,sha256=2ELzCQnBpLYafCKUChY1xtJM8jNIur8Rq3Wai40ZwcQ,1282 +torch/include/ATen/ops/_efficientzerotensor_cuda_dispatch.h,sha256=PPeu_JffM9od-LmvYLcaZZC9eTyEHOyFCRHCHbh3r_Y,1284 +torch/include/ATen/ops/_efficientzerotensor_meta_dispatch.h,sha256=qjATBRXVsTZn-Z6HaLIj0XdRdWIH3EMzf3EeO_LmPXM,1284 +torch/include/ATen/ops/_efficientzerotensor_native.h,sha256=F7ZGMiE5nK4cSJ8Zwqj1dtEL4mHc9bI8NdejalRTcL0,1185 +torch/include/ATen/ops/_efficientzerotensor_ops.h,sha256=ITG47kJyKtS7AvHARRjcsL26CK2TLOh8VMo0Nqo0SNA,2156 +torch/include/ATen/ops/_embedding_bag.h,sha256=L8CHKWH1uME273_s-CoX-k5gSi9EaxCNx0HAQJ1sjnY,3160 +torch/include/ATen/ops/_embedding_bag_backward.h,sha256=G6xXi9xF5wh40eds_Hs_XsPILzugxmPQB5xtVAz9Gfw,3540 +torch/include/ATen/ops/_embedding_bag_backward_compositeimplicitautograd_dispatch.h,sha256=eWlhXUVAoketZa5iEd3qw_7Pg6YRRhl9LKSEG1Hc3iU,1469 +torch/include/ATen/ops/_embedding_bag_backward_native.h,sha256=QewE9aWhuY7FH7q5pyBRGUVSqrY5YYirGIpXQKeRYws,818 +torch/include/ATen/ops/_embedding_bag_backward_ops.h,sha256=CM1MAxlSWI7ZEfSjyLTD1Ca033e9zkf068qhFC5ThXE,2012 +torch/include/ATen/ops/_embedding_bag_compositeexplicitautograd_dispatch.h,sha256=nxikWP_rFGcYAfBrA9xYlRiVpu2mMkM16YdXSqongrQ,1553 +torch/include/ATen/ops/_embedding_bag_cpu_dispatch.h,sha256=KUbE_jcpqH_RkF3VpldzTapA52f8962VdZD-jYdM-ng,1012 +torch/include/ATen/ops/_embedding_bag_cuda_dispatch.h,sha256=U0d00F6rAdW07d6GawU2JbzF1ikHQ91mCSDyw41umLo,1014 +torch/include/ATen/ops/_embedding_bag_dense_backward.h,sha256=z_6wWjSshmQe8i4zp26KRYuXDpiv8H8kIEQ4sMmXnD4,9286 +torch/include/ATen/ops/_embedding_bag_dense_backward_compositeexplicitautograd_dispatch.h,sha256=yQ1Wjm3PcEfbLQVqHtXSbRK0uw-IZhiXRZGb7e1ywag,2180 +torch/include/ATen/ops/_embedding_bag_dense_backward_cpu_dispatch.h,sha256=yuH2yH8KOKA7Qps-OIauTjZ93cYwqzjt64bwUt-Ls0k,1355 +torch/include/ATen/ops/_embedding_bag_dense_backward_cuda_dispatch.h,sha256=7ISeGBbEJx0qvbwp-GOdTwVlWdCyre7_Qq4Xewe8hU8,1357 +torch/include/ATen/ops/_embedding_bag_dense_backward_native.h,sha256=ca5h6VCnOBHteHJACVIk0l-PsjxxZXhsP6wit_pxhjk,1491 +torch/include/ATen/ops/_embedding_bag_dense_backward_ops.h,sha256=4wzYo2-IuVMwBZTHhgfzngMXc55v_QmHhPk-V-352Fo,3442 +torch/include/ATen/ops/_embedding_bag_forward_only.h,sha256=u2Ph_BAaA7TmwzfMnCmy9Avf2mzGW7AOR9H-dd--D08,3290 +torch/include/ATen/ops/_embedding_bag_forward_only_compositeexplicitautograd_dispatch.h,sha256=ndp_J5Vxul4csq9QHo4cpQnKzvXFfIPeWrKpStjk-MY,1579 +torch/include/ATen/ops/_embedding_bag_forward_only_cpu_dispatch.h,sha256=q0wkVuFVdWCZmAK1E7WBQnym8PPj3QHQ4kSVbsSp49k,1025 +torch/include/ATen/ops/_embedding_bag_forward_only_cuda_dispatch.h,sha256=qCKXfww2PSj3In4WDsm79tiN48lAf7CM5Vq9fQCTI0Y,1027 +torch/include/ATen/ops/_embedding_bag_forward_only_native.h,sha256=qHjYXBKAc-iYkpAN9_TdTKQ96eLauuqFwMMRC4uOhkE,1581 +torch/include/ATen/ops/_embedding_bag_forward_only_ops.h,sha256=mpbQ_37xHXzDahwb59dEH2rjFNWPFVFGz2-3-Yv2C1A,3718 +torch/include/ATen/ops/_embedding_bag_native.h,sha256=DOjL5Q40SYP-n0Ex4I_bW43B47_Cl_wMiL9RjyBZr7s,1542 +torch/include/ATen/ops/_embedding_bag_ops.h,sha256=BD2O5vr67Pggc_OW1JP7Zr64eTrR-fyu00zPv3HWyc4,3640 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward.h,sha256=uFywZU6H5IE5x97LrgWMzYKmpenISqKqAEWCGHJqINc,2287 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_compositeexplicitautograd_dispatch.h,sha256=htwTEtG3JsmKY1-yJ-RwrPYBh8WFL663lORtOfsmlHc,1240 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_cpu_dispatch.h,sha256=S_JX79qmZVij_rqqXdyOvOulHpWc-B7Pg6VFFoxmJfM,908 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_cuda_dispatch.h,sha256=3CIHmD-DAh_D-BG1xVGmdS3i37JOJ4HV_xxZoIS6yng,910 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_native.h,sha256=ZjbMX9ek4yEKaxF7V6us04VFt3eShK4oWVEZ1v25mUw,1189 +torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_ops.h,sha256=CVUJBxwey2KeARfaGuVGYQnyiVlbOs0WLtEDpUF3zLk,2790 +torch/include/ATen/ops/_embedding_bag_sparse_backward.h,sha256=0ONNxhGJ6sk-Y5vur9dPKLiB4x7MWYk1BwrEfXYoZ2E,3247 +torch/include/ATen/ops/_embedding_bag_sparse_backward_compositeimplicitautograd_dispatch.h,sha256=0ZL6-AzYaiGfrevHXBwWWXkQSrTxXRxOQLhSrjMzVZs,1385 +torch/include/ATen/ops/_embedding_bag_sparse_backward_native.h,sha256=28LzrO4ZDfH7hxiCAuMrgcYIR-NRSHo4d4Zh8tyXC7Y,776 +torch/include/ATen/ops/_embedding_bag_sparse_backward_ops.h,sha256=5hbu_ghR5ILbjyJHK5LEiWc90T5GUZtAKuFl0vTeGtM,1872 +torch/include/ATen/ops/_empty_affine_quantized.h,sha256=FDVuB1zlQ_Lu7yF4VC8l_U3eCtZ_B4vLlGWTbPiK-Ck,9143 +torch/include/ATen/ops/_empty_affine_quantized_compositeexplicitautograd_dispatch.h,sha256=zgWgA2dBpwKQ8GenEWODoG0fxTP7gfPGC0ERAOyZXVw,1484 +torch/include/ATen/ops/_empty_affine_quantized_cpu_dispatch.h,sha256=ZcNMyYvEwA4QvjlMsk0cGs1zNiA_QZB6ws16IyUm_j4,1676 +torch/include/ATen/ops/_empty_affine_quantized_native.h,sha256=uWZ1ZAq1q9yXoCSFRThdmuLL37enrJMQQuvXmdkPqGw,1289 +torch/include/ATen/ops/_empty_affine_quantized_ops.h,sha256=D-DOtzfnZ6zspeHwdC82WPcEea2RpBOKj1T_d3OeYmo,2758 +torch/include/ATen/ops/_empty_per_channel_affine_quantized.h,sha256=B9LOb4qmS95W9Urf0VA5bjUaBZlb0esaYwN0qBBA7Ks,10451 +torch/include/ATen/ops/_empty_per_channel_affine_quantized_compositeexplicitautograd_dispatch.h,sha256=bc1B6V0b-lLzq3rKl6RGq4iekT_qICXnD0QixJNg3rI,1680 +torch/include/ATen/ops/_empty_per_channel_affine_quantized_cpu_dispatch.h,sha256=BAh8wlsuNYZxBKIg9Ka-j5pK1sWXJwpv_AXjEtmvMdI,1872 +torch/include/ATen/ops/_empty_per_channel_affine_quantized_native.h,sha256=apiFJMnTtv2AxIG-I1eqGePd7bMbMt-SCrtYfcs8CxM,1434 +torch/include/ATen/ops/_empty_per_channel_affine_quantized_ops.h,sha256=qPB6VRUIEM94qZ-7wtcpfGsPOvpct8AD13EqmiuQ7bw,3074 +torch/include/ATen/ops/_euclidean_dist.h,sha256=scsCw0lsjukfNwv94nIc_Qt-dqEILlmvOd3NJow6UEs,1201 +torch/include/ATen/ops/_euclidean_dist_compositeexplicitautograd_dispatch.h,sha256=uHbSXlrLcuYEdrGJzbMZ2-aFWm3wWfMuBxhznBYuML0,1011 +torch/include/ATen/ops/_euclidean_dist_native.h,sha256=VaxZ5Na2Wnkk2zhSHvMlrFKO67ifb5FZ6_zcRgxTs7Y,625 +torch/include/ATen/ops/_euclidean_dist_ops.h,sha256=WITR106CHZym5f_xwfZm33PxgcLPLP-yi0TCb5vHnuc,1786 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine.h,sha256=wd0ILiOOsdEp5gs88ws4oVJLiH0kdVN66XtSRd-eh4A,2248 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward.h,sha256=uxF_lhcV31m_hO4EaxCkaC73zl5HE8LVQUz0tGeBD-U,1196 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_cpu_dispatch.h,sha256=Z3HjXf18jEHoIFJ_3ffWCsJKEn7UAjPv6CAD3SPXYiA,960 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_cuda_dispatch.h,sha256=twJrFK6zwJkcIxRZmi338cEPADDp4hCVc-M_SB4_TrI,962 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_native.h,sha256=44hJZordnBsAlLJucAC4ygF4Ml6is-PvW1AJ9QANPjg,727 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_ops.h,sha256=ZXaoL9WR60U8Tz1ZSrn8XgOMJBS78ddNBwaSo_5IWF4,1743 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_compositeexplicitautograd_dispatch.h,sha256=WYeo_28S6rERoId5--EQBXmtM4k3hplRm4bNPOM-V2Q,1203 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_cpu_dispatch.h,sha256=5wJlQTF9DVnZDji9DT24FEjrq2PYFn-OnPeCIRbR2zI,890 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_cuda_dispatch.h,sha256=a7OHKzFejNVNgsmcz8Xh36fTFjOVGp9pjxzKSDxoXnk,892 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_native.h,sha256=hTgUf4xzgTu0DtTXDIZgbriBIjIwUdbYGejaGvltMyU,901 +torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_ops.h,sha256=YarvXMGA_gRcz1HuuHIiUcln0FLpmjLoqPAUXNB9IyU,2670 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine.h,sha256=SE-B2bOkzf7CyaERNDr5q67WLIv_yJb91eNdH0FuTzQ,2148 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward.h,sha256=1wtpU9k_v1ZqS8YmvyKwUnlM5cqrBV2BjDkmjk7WOH8,1162 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_cpu_dispatch.h,sha256=1ztJyBf1_t1uUSpn29ubEBpTJKE2Zca02ZUKYE82C7k,945 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_cuda_dispatch.h,sha256=eZR2vo-E9FDxhwwI3KLVbh4D6d3wVg06UmhlamH8clQ,947 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_native.h,sha256=OAd7XM_evSJ_GQ1fgvPi4zGyTQ8Ad8J4fdPN1KX1Fvs,712 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_ops.h,sha256=5pf8zMuK5J9T9oBV8oKi2MTIfAYbwIVMajEBaAal-Lc,1693 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_compositeexplicitautograd_dispatch.h,sha256=psAB59dp84lyDfVPrtHMC29sZg1RAFuUyrxaKkfnBrs,1173 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_cpu_dispatch.h,sha256=gMuPyptXG0J8p46sumiDlFc0LQtauT2QrT14gy8Te-8,875 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_cuda_dispatch.h,sha256=pUwXpNO6buFyLj_9szcG_E1_jBCt4p30qjPpS0Y9CLU,877 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_native.h,sha256=pEb8MMyRVkMFlG2NpCe85376u8sCBryOPB9rnCNuRjA,871 +torch/include/ATen/ops/_fake_quantize_learnable_per_tensor_affine_ops.h,sha256=2tFFHJ6l_IB4BE0aR0nSd0Tm09zlhUYBw0uRZQSG4Gg,2570 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.h,sha256=Qip4GkeFTnG69h3wKLwteKii-ohk-DV-hLYbluXM25A,2599 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_compositeexplicitautograd_dispatch.h,sha256=G5OP8iiLIZOAtseqIUdRq7HbGIRcrF6DFuePGY4AV40,1331 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_cpu_dispatch.h,sha256=J_VRqE9ZWG3vx8oVLeGwZFnogRnt-S2zRujG6wBH-eo,930 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_cuda_dispatch.h,sha256=oLkSNaG5PCAs0XaF6gK4-Y2yAfcfYnqFYKiYWjHOgN8,932 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_native.h,sha256=WTxIMOW0SZK54M1i09mKuyElGl6k-Wizk7Ln874-nuQ,1007 +torch/include/ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_ops.h,sha256=0eWG7s-ukjipa79qKN7VBmuxkUq3yx4z-TU37x4uoFU,3032 +torch/include/ATen/ops/_fft_c2c.h,sha256=-JhBNWHrPkhBEl9Cb4KfWlgjuJ6jHsnnGOf2V1SiJcg,4471 +torch/include/ATen/ops/_fft_c2c_cpu_dispatch.h,sha256=vG9P7rhfhPiolRBiKFzwCCkPX4hgWueqCsM5Q6a9Axw,1481 +torch/include/ATen/ops/_fft_c2c_cuda_dispatch.h,sha256=4sTsoNuL94y-DfqqkHhUhdvfdpjVHRrqSo89XUxSD64,1483 +torch/include/ATen/ops/_fft_c2c_native.h,sha256=zBv54nwu_kYffCkKzDqgtNHMiGvec8pT6FgjTSnjZRU,957 +torch/include/ATen/ops/_fft_c2c_ops.h,sha256=X2Ai_0boNnis_V30cbVS1B4-xBD9cn2bas7uFBVeIj4,2016 +torch/include/ATen/ops/_fft_c2r.h,sha256=4ePTeioQoo4pmbNLM7KeWL4o0Q2oRjQ2KD4t70Km4g0,4525 +torch/include/ATen/ops/_fft_c2r_cpu_dispatch.h,sha256=0E-hSl-YBGNvGnikAJme9itp-dWOoPtWEOq4jzQpXgw,1535 +torch/include/ATen/ops/_fft_c2r_cuda_dispatch.h,sha256=hbgk4cmX0ZIPHBW3Uk5vSB-_WFCZz776XzLaA7qDMDI,1537 +torch/include/ATen/ops/_fft_c2r_native.h,sha256=lyp8RhyrrUzHRzfcrm1RsX3fnVuUXORtQ5ZXvIUolHM,993 +torch/include/ATen/ops/_fft_c2r_ops.h,sha256=nRXWNnbq51UwwrgsNjnb83U8ph3bJdQKhpok4Ayu5OY,2068 +torch/include/ATen/ops/_fft_r2c.h,sha256=gd_mqHoYkKdco12VzW2vPOI-M3mRO0S9Y_2R63L6iKE,1437 +torch/include/ATen/ops/_fft_r2c_cpu_dispatch.h,sha256=HCV6m89fdPaz42FaYguyEBeVK3uSMVbDVu37R8al-9g,1060 +torch/include/ATen/ops/_fft_r2c_cuda_dispatch.h,sha256=bUkhmkjwaLBYCqKYZilmEX_UlvprzUKiQlbUlwKeNVI,1062 +torch/include/ATen/ops/_fft_r2c_native.h,sha256=pq6pl6s3fyJTGHltfH7NmHo_OECKnRa6ddoe-gPOKbA,961 +torch/include/ATen/ops/_fft_r2c_ops.h,sha256=RSHsuE0nkGW7DpwyXhSyjXVyxHwcQVRgwjiFzLZZpKY,1992 +torch/include/ATen/ops/_fill_mem_eff_dropout_mask.h,sha256=hvSf2xZGxFQhZFmRORcBRfOWypEKsH5VJwdz_69UQBk,824 +torch/include/ATen/ops/_fill_mem_eff_dropout_mask_cuda_dispatch.h,sha256=vQYSybPCXC_d0UdKdq6dT_VPS3g3GTehIGDktXx3_QU,787 +torch/include/ATen/ops/_fill_mem_eff_dropout_mask_meta_dispatch.h,sha256=_-mUYXvW1VRaAGykMy9tiEaL4qhpENa_etemoRI8Y6s,787 +torch/include/ATen/ops/_fill_mem_eff_dropout_mask_native.h,sha256=rUmnSIlsTSOzNA15Cje1KCwIDGSqY2u5wfDraFf-Vzo,552 +torch/include/ATen/ops/_fill_mem_eff_dropout_mask_ops.h,sha256=vuE159p5NIkQsQzY2aKC1B_zsYYZUmHmsB2uZDHjkNo,1187 +torch/include/ATen/ops/_flash_attention_backward.h,sha256=UdmgmraUzQrKTkNZ6B_W9_paWx4ZKMqiuUXz4ogFBJ0,4036 +torch/include/ATen/ops/_flash_attention_backward_cuda_dispatch.h,sha256=M9mfj5poJe-Zewby3SCVFiuod6SOpLO4b8Ri_A-Mp8E,1633 +torch/include/ATen/ops/_flash_attention_backward_native.h,sha256=zQ22rkML2NXclhw2zOAmFYVJRQpP1afLucbUPLTvPAE,908 +torch/include/ATen/ops/_flash_attention_backward_ops.h,sha256=GvIyDAi9313MYfHnWTn2jI8xJhbCFxDPPMJ0o5sBfB8,2350 +torch/include/ATen/ops/_flash_attention_forward.h,sha256=oGppTPaoesKjaGt44KfhNiEvZMXfBGPo7ZV9yNX9jf4,3633 +torch/include/ATen/ops/_flash_attention_forward_cuda_dispatch.h,sha256=xSNgUB_AKz1-YDDtnAx7WMXoJ6dzWT5obCJxqpl_T00,1485 +torch/include/ATen/ops/_flash_attention_forward_native.h,sha256=WQPlulkqOCeOUdKRpx0iIycoq3GD13hKeftIETyBHw4,834 +torch/include/ATen/ops/_flash_attention_forward_ops.h,sha256=oS3Fh7liq_MK-1ixenwjSzSVKpO_wOWSnDSqm165lIw,2179 +torch/include/ATen/ops/_foobar.h,sha256=vSmKV5zEX6DBR_1IVxlKjY0G3O6bdpafcdt_pg1M1ow,1355 +torch/include/ATen/ops/_foobar_compositeexplicitautograd_dispatch.h,sha256=eTMDwoehka6Yew01hrZlosLyhVbg2eQWEMrecSrVyaM,950 +torch/include/ATen/ops/_foobar_cpu_dispatch.h,sha256=U54bsQYe5HIg0ZNZacgqQQXBZgjbJkUrZk_zFpuULNs,769 +torch/include/ATen/ops/_foobar_native.h,sha256=HSO_LPy7UGZmgucOgy3katQ_xAlvwge-X15pFLD_gLI,647 +torch/include/ATen/ops/_foobar_ops.h,sha256=cOMnPe7YinoNEctttUuPk03UF8t_On1wFUdbdEFyJYo,1863 +torch/include/ATen/ops/_foreach_abs.h,sha256=37bSPMZImTlFR04lujIupowec0PTraDYNQUnw146vzo,1210 +torch/include/ATen/ops/_foreach_abs_compositeexplicitautograd_dispatch.h,sha256=oBhjqTEOXeawmiMZ9osR4UWuKRI1fuz6otoma1vKdcI,859 +torch/include/ATen/ops/_foreach_abs_cpu_dispatch.h,sha256=6HVed--IdaaW_zypWXoPvqkr3CIQRmOpzueQb8p6oYY,788 +torch/include/ATen/ops/_foreach_abs_cuda_dispatch.h,sha256=5UlQXvudjhXWBNRzjmqqyHaJfUqA5ccfQ6hEJp2aT84,790 +torch/include/ATen/ops/_foreach_abs_native.h,sha256=tXQO49jvIJIMuqgN8fojGFgU6DKw6GjPW9kfDKgE2xM,795 +torch/include/ATen/ops/_foreach_abs_ops.h,sha256=wUmVk6JwMj2JHFTgD6Fdqls5_NDq7uKqlkkWRuzoKvY,2155 +torch/include/ATen/ops/_foreach_acos.h,sha256=SUr9IFkw8Y3Q5iKAcpco8YpOO52MoCy5L-tMTOj9Nh0,1223 +torch/include/ATen/ops/_foreach_acos_compositeexplicitautograd_dispatch.h,sha256=LFJl0g2KclZyfnd_IFlXeii2Ab1Ax3TkFFcK-Il7_A0,861 +torch/include/ATen/ops/_foreach_acos_cpu_dispatch.h,sha256=lkMYsKKn172YfS1wfxpRZxlt5xgRpCwNjPT1fXRYKPs,790 +torch/include/ATen/ops/_foreach_acos_cuda_dispatch.h,sha256=NRoWwOrZzam4MFnN4nvHRPJa3a_mLnrUh_lJukCtHx8,792 +torch/include/ATen/ops/_foreach_acos_native.h,sha256=vE06fOvH0qmirRWK0bmGLlHXU0ocMaDWMcVc1MDV2EU,800 +torch/include/ATen/ops/_foreach_acos_ops.h,sha256=DMVbKL1s0q1u0mOWMVauGoAz7XJy671n1asV8eUyZvo,2164 +torch/include/ATen/ops/_foreach_add.h,sha256=wBdainsAfeDUKwsLKyqtXLlCvlwICGwo9yHTqFG06O8,4820 +torch/include/ATen/ops/_foreach_add_compositeexplicitautograd_dispatch.h,sha256=nUmdv0OoCNSFFhd9m7Q9MQ3USyXh-Z_oG3NyblFlHMA,1632 +torch/include/ATen/ops/_foreach_add_cpu_dispatch.h,sha256=hlAP3kHNSi5j3ylDHv0UE1IBENBbNeuE3NikDIPfK0E,1484 +torch/include/ATen/ops/_foreach_add_cuda_dispatch.h,sha256=ewlwgufQtICulyoxQOLsPdvUteiugdv9EQBcaeeTnDg,1486 +torch/include/ATen/ops/_foreach_add_native.h,sha256=ksXtnIMsZtruE8J_Q25Wp7lXTzGDYCoF02CAY-422hQ,2964 +torch/include/ATen/ops/_foreach_add_ops.h,sha256=zRLxisBOhxt9t3RZZZZkhWwR0_M99NAzI7hD_EQ8mlc,9209 +torch/include/ATen/ops/_foreach_addcdiv.h,sha256=5zUnQayj9lFTa5qMFGAh1ae1057Bm8lTPmdLLIfbPnw,4868 +torch/include/ATen/ops/_foreach_addcdiv_compositeexplicitautograd_dispatch.h,sha256=4GrRul1c4ih1UpoG-lfOBUv7zy3qgDatSfXMnhgw-5Q,1647 +torch/include/ATen/ops/_foreach_addcdiv_cpu_dispatch.h,sha256=-IBm7i2esaSAITjFz151sa6T3HvQP_GX7WjtSay0gRY,1524 +torch/include/ATen/ops/_foreach_addcdiv_cuda_dispatch.h,sha256=vAAK2qZphWw5PllUGaQl7vk_Tu8hHmsVsxwXw1CxJqg,1526 +torch/include/ATen/ops/_foreach_addcdiv_native.h,sha256=qPuUiWu5vn5IGrfzn8j1Uw7J6_IMkj_yi7PMISWA92k,2872 +torch/include/ATen/ops/_foreach_addcdiv_ops.h,sha256=rgwAqRIez1hav0SyEh1aEBrzx8gHhhhFmSQnLhihJmg,8276 +torch/include/ATen/ops/_foreach_addcmul.h,sha256=4TD9-267oJ1MhTUAQGf_b9iRFI-RnpBXxn1g3YUbADM,4868 +torch/include/ATen/ops/_foreach_addcmul_compositeexplicitautograd_dispatch.h,sha256=F1uKJyygkQCz_UabhKP_CG3fY-R5gZAb1ViaxaRcI60,1647 +torch/include/ATen/ops/_foreach_addcmul_cpu_dispatch.h,sha256=BcpExG3sXTx2PWzlOewGoNQ0B3U-ceyxn70Zz2F27ro,1524 +torch/include/ATen/ops/_foreach_addcmul_cuda_dispatch.h,sha256=DpgTCL0YXc9a80E5UYbr52EmlCjpJL3Bdf4Q1-DTPVk,1526 +torch/include/ATen/ops/_foreach_addcmul_native.h,sha256=dW0lvCb_8-ToyCrgOM-WMzUE1KoFlrAMCn3E6uKWz-w,2872 +torch/include/ATen/ops/_foreach_addcmul_ops.h,sha256=-f-yO9LQ6BzdeSr5a2ASfcdegmkSvEZRQc5UHQP8Lhk,8276 +torch/include/ATen/ops/_foreach_asin.h,sha256=h6W0MOWP4-q5evBetYeDxaz56n4URuLEUQUDtUJTVSc,1223 +torch/include/ATen/ops/_foreach_asin_compositeexplicitautograd_dispatch.h,sha256=i-OkkYtgDPf-ImAQwrbm_tc-fxguWHb5kk7LIYoPFrA,861 +torch/include/ATen/ops/_foreach_asin_cpu_dispatch.h,sha256=3T9FCYDwfyvPMRlOt4-l0JCriAhtJ7k5VKLwCy3SDV4,790 +torch/include/ATen/ops/_foreach_asin_cuda_dispatch.h,sha256=38H_01JqJQ1F4EWAi94S8tbhzO92Ywy_iVJrHwQpHcE,792 +torch/include/ATen/ops/_foreach_asin_native.h,sha256=1uERx75uzZihLa-bOST5piAJythsRbe9RxT7G-I4vaE,800 +torch/include/ATen/ops/_foreach_asin_ops.h,sha256=ytj7g2vsPa9YoX5VcYe68I5bwEEYYR3GYyqZ6S8V5z8,2164 +torch/include/ATen/ops/_foreach_atan.h,sha256=ygn8-jKiah8O1B9ktbFspqjSKmXX9Z_X40qukObl38c,1223 +torch/include/ATen/ops/_foreach_atan_compositeexplicitautograd_dispatch.h,sha256=SppQsM720ZZSBkMKZCE1krHEHbJaiamjCYV-zCD6dAw,861 +torch/include/ATen/ops/_foreach_atan_cpu_dispatch.h,sha256=gBjQ3_CqE-jcuZ_tQfVtkYF7cTCRVRLsAlZtV3B92Xk,790 +torch/include/ATen/ops/_foreach_atan_cuda_dispatch.h,sha256=GWRjqm41W79GslWxuejYEbMBJLDVFxkcAlSz5oyjOVg,792 +torch/include/ATen/ops/_foreach_atan_native.h,sha256=Jfpbl8YmkM3Zbi0ZPCSQg29OekC4Xo3itS1ocyk3bio,800 +torch/include/ATen/ops/_foreach_atan_ops.h,sha256=NJDRkDVje00uogyRWXClDQbKsYK6TnXzIQ2-p3-1OhU,2164 +torch/include/ATen/ops/_foreach_ceil.h,sha256=HnzYULig_YeaKRffHvAV5Tpz5XOh7Bx2fbCHtmhLsSQ,1223 +torch/include/ATen/ops/_foreach_ceil_compositeexplicitautograd_dispatch.h,sha256=ek8WtihIyKRpdOCVNXmNvtRxJWO61I3k8ke-8rae9Q4,861 +torch/include/ATen/ops/_foreach_ceil_cpu_dispatch.h,sha256=jPLJjsjbn0lByZlr9kZy5jf4-udeKkOWbCdrHW-Yxb4,790 +torch/include/ATen/ops/_foreach_ceil_cuda_dispatch.h,sha256=ym66WI0oTa768dUfaWaR1Z_-iGx9d6HlmaPqAvR7Avg,792 +torch/include/ATen/ops/_foreach_ceil_native.h,sha256=sf9NdmLgpe9N_ZAlU-JUMWHGSfVKfekITJ6usU0WQD8,800 +torch/include/ATen/ops/_foreach_ceil_ops.h,sha256=u60EdsrWH10CKuK032N3kbgveNiXDpKteDMYSxTsUx0,2164 +torch/include/ATen/ops/_foreach_clamp_max.h,sha256=8QizLoJrx9jIYXLkFETdREu489LhqsCRAHEf4f4aUco,3668 +torch/include/ATen/ops/_foreach_clamp_max_compositeexplicitautograd_dispatch.h,sha256=cWpbZi2JKWqqpSa-cGsE_Xkmzqf3aP2OLxh0odAFFnA,1359 +torch/include/ATen/ops/_foreach_clamp_max_cpu_dispatch.h,sha256=P33gXBzLJosUMR6Xu3VLkvJ82326IbXsSDdV4pfadU4,1234 +torch/include/ATen/ops/_foreach_clamp_max_cuda_dispatch.h,sha256=kSGVSTx5UF7E3eTENGbq3cM_UYpCjXWK1Y4oZ3Sexlg,1236 +torch/include/ATen/ops/_foreach_clamp_max_native.h,sha256=1_lAAccutAT9Sf5iwYeqeu4mLDH8idERcyHoNMP_rkk,2223 +torch/include/ATen/ops/_foreach_clamp_max_ops.h,sha256=TNI8G4ClRi8wDkCDeKVF4Ua6oFmHoF9duzf4VmyjsCA,6791 +torch/include/ATen/ops/_foreach_clamp_min.h,sha256=IE42Z7K2xTxHGyJseyuwS1XF-qZLNGd2Ki3exDuO_UQ,3668 +torch/include/ATen/ops/_foreach_clamp_min_compositeexplicitautograd_dispatch.h,sha256=x1hWX1CUobOZezM0MZZ43Nl8kTx_3G49GNNgX-tz4uo,1359 +torch/include/ATen/ops/_foreach_clamp_min_cpu_dispatch.h,sha256=ZppRvrTD9ODoXCdaVLwFHBFUEUV540Pru3P3gQU-5Tk,1234 +torch/include/ATen/ops/_foreach_clamp_min_cuda_dispatch.h,sha256=zFVRm881gidg0CMY-C27EZKVdVwefNs8LhPMyqwcyCU,1236 +torch/include/ATen/ops/_foreach_clamp_min_native.h,sha256=5mw7TyR0nZDTvVrPJ_MoO5J0RQeoB_p_gUCP3T-gF-U,2223 +torch/include/ATen/ops/_foreach_clamp_min_ops.h,sha256=MVcdXyM_TQW5MgKVi3ZVN-_Bxfmgjd-_w_Vlx3Xco50,6791 +torch/include/ATen/ops/_foreach_copy.h,sha256=YxtKwvq6Cw3ZK6pjckbS2cRi8LifWgwCCSG0JRms0FY,1638 +torch/include/ATen/ops/_foreach_copy_compositeexplicitautograd_dispatch.h,sha256=EW8wmddVJNHZTClDqepesgwMAVyHxTJ3t0N0X8c8XEA,1062 +torch/include/ATen/ops/_foreach_copy_cpu_dispatch.h,sha256=XR0zUpJllePJ2UyQFkzX2O5mFqjUaoesBfnt_O8EyN0,763 +torch/include/ATen/ops/_foreach_copy_cuda_dispatch.h,sha256=5T0gDhiArLSHK0k0eaNLeMICjZlZ4EzU_XrbZ8MYyVU,765 +torch/include/ATen/ops/_foreach_copy_native.h,sha256=c-nRYI0KGkuLDSWRg41DLRNP6fzjR2vVcRtpWUnRqcI,904 +torch/include/ATen/ops/_foreach_copy_ops.h,sha256=O9nF18sIFdxgJ6uYnMqIYx9UeTvlUO52uC4tRNZf1VE,2590 +torch/include/ATen/ops/_foreach_cos.h,sha256=dp7uNmMF7yBKklJ9mFy7mGNv5GGYJJA37x_KxImTIsw,1210 +torch/include/ATen/ops/_foreach_cos_compositeexplicitautograd_dispatch.h,sha256=ZrVfalgTo2SbEOFxXnUz3P3ob5zLDMlqd6tji3zZLl8,859 +torch/include/ATen/ops/_foreach_cos_cpu_dispatch.h,sha256=f2UTobV_CvaC4q1JF9rFEUGaL308E2i-p7P8l9_F8MQ,788 +torch/include/ATen/ops/_foreach_cos_cuda_dispatch.h,sha256=GsjGjHE-sZgyew1RPiPD93Wf4Q6ZK-i9lIZCqaYn4pk,790 +torch/include/ATen/ops/_foreach_cos_native.h,sha256=xjSnpHWwCDvNzrKdohyNhBV-Vs32nYwGukkTXm-JYu4,795 +torch/include/ATen/ops/_foreach_cos_ops.h,sha256=nljb1dH7C8hy8-dHX9Dx5sl40DEqixxyl6nseVPmni4,2155 +torch/include/ATen/ops/_foreach_cosh.h,sha256=6ohBoDWHwkIwlJHX0kROJftYb0QtKhd2lKcpMK732XA,1223 +torch/include/ATen/ops/_foreach_cosh_compositeexplicitautograd_dispatch.h,sha256=4nA2BWgtTuuXA9vZoA1dImCY-lLPf1kZgT6qCpdsmVE,861 +torch/include/ATen/ops/_foreach_cosh_cpu_dispatch.h,sha256=RohWFVl8xvPB4RjLfQV86gcRl2sTd6TIjlnpkqim3ys,790 +torch/include/ATen/ops/_foreach_cosh_cuda_dispatch.h,sha256=Tjd_o4u9CbccpZCl7MsO8cl8h0phD4e73t4pRf5986A,792 +torch/include/ATen/ops/_foreach_cosh_native.h,sha256=Z5JwW_p-HvGlT1lu9VWLSVA-pIH6b1CjILQmf9Hn-L8,800 +torch/include/ATen/ops/_foreach_cosh_ops.h,sha256=tpU_qymschWpmxpTrBF2Z9AFW4yCaPQpTf_-X4mnhVw,2164 +torch/include/ATen/ops/_foreach_div.h,sha256=r8c-S_rFJJSBGlQGLrBAPtciv-YBdTjC-XaFlT-YG9k,4404 +torch/include/ATen/ops/_foreach_div_compositeexplicitautograd_dispatch.h,sha256=sT4exkvOuVYhse427sDUyCgGCaOm5rIZgK3uMyP3PNg,1524 +torch/include/ATen/ops/_foreach_div_cpu_dispatch.h,sha256=4_ZxhuNGQ99Fjd2WWniNkdV1AQMwv31DJRQrj-zKZ5I,1372 +torch/include/ATen/ops/_foreach_div_cuda_dispatch.h,sha256=blhBC-UbhxiAk7kKXdRfqEsaDydYA8bXKHPwUPpoB4k,1374 +torch/include/ATen/ops/_foreach_div_native.h,sha256=HkazIk78wdxwRIpl7lm_rGTF9z_pfPWcaAMlzpXkEVk,2688 +torch/include/ATen/ops/_foreach_div_ops.h,sha256=mCNsmIWAqRQOtuQ_agogLvdWD3pnzMjvBC74xr8oKUo,8669 +torch/include/ATen/ops/_foreach_erf.h,sha256=Uvnxu0PGqWXhCTj9D48SdIxNvT0Q---7ulKwopyog_A,1210 +torch/include/ATen/ops/_foreach_erf_compositeexplicitautograd_dispatch.h,sha256=3xOyumIjYjJM4-rMokKJOJBRnNUqY5DPW1VHaY5r8zk,859 +torch/include/ATen/ops/_foreach_erf_cpu_dispatch.h,sha256=HVoSXL23ZR9PBUUmRPg-Hr5Rb0uppwoJ4tHZ6Hvbt_4,788 +torch/include/ATen/ops/_foreach_erf_cuda_dispatch.h,sha256=WJjVQufaliIg_rLuhVlACskdOsRiofBS6g7uxf_ZUio,790 +torch/include/ATen/ops/_foreach_erf_native.h,sha256=ip2nqJXIJx38Rfs73eqjhSc03sZvQFuLwjOpKKauFEQ,795 +torch/include/ATen/ops/_foreach_erf_ops.h,sha256=2CZC1-00adqZlcMJVDNERi9otWhAr1WIWv43KmjzoiM,2155 +torch/include/ATen/ops/_foreach_erfc.h,sha256=Dm_MqUhfpdaxhUIMNoMmt4dbXGnMZ7oXFfml9nEaulI,1223 +torch/include/ATen/ops/_foreach_erfc_compositeexplicitautograd_dispatch.h,sha256=2YZk0QCuNu5clkjJrQCxzg0a3Ya6iFoUCjZwCOkSIiQ,861 +torch/include/ATen/ops/_foreach_erfc_cpu_dispatch.h,sha256=T0EQf3RIAeUf-KNkB39yIq8BXRdfPqIVq6bDCjcRdJs,790 +torch/include/ATen/ops/_foreach_erfc_cuda_dispatch.h,sha256=OGrzRWlfkYHpaVDfyvoktU8UQq6QyV7xGtCUT_m4P3E,792 +torch/include/ATen/ops/_foreach_erfc_native.h,sha256=k3_j02WZXlgeq9MdWEKYNkb7RIuId709EuTEjZCwKCQ,800 +torch/include/ATen/ops/_foreach_erfc_ops.h,sha256=S2xftv_I3BCkeVMAAFLCMt9CvNhwf16eQoo_P-9Hwts,2164 +torch/include/ATen/ops/_foreach_exp.h,sha256=UdqmZLoNRWgLpRic9CrdWz1v1eYJ-Ei6AR4fREpenr4,1210 +torch/include/ATen/ops/_foreach_exp_compositeexplicitautograd_dispatch.h,sha256=SvCCnsStgbtLTyqmRD9UK9ti-tkkFgdyoaQt43Hp46Q,859 +torch/include/ATen/ops/_foreach_exp_cpu_dispatch.h,sha256=FfdInbM0joLBp1Esj2w7rSRR2QV-7fH4oHehbx-qi4M,788 +torch/include/ATen/ops/_foreach_exp_cuda_dispatch.h,sha256=XWlwnhSYGBPeuwbKtqdimPK8GvWeKm_dYO5iKg6iQTc,790 +torch/include/ATen/ops/_foreach_exp_native.h,sha256=2j6CrTNW3_Aitd0Uim5Da6GzULVAoaFJsu8ZZhPkb1g,795 +torch/include/ATen/ops/_foreach_exp_ops.h,sha256=l91LX7en0foeZSLxF-AX6EK2EyVkTyE5gA-PLSWcx-Q,2155 +torch/include/ATen/ops/_foreach_expm1.h,sha256=jqXBgyGkNP08UmI70Q_S2l9CG2RNTeBoNw4vgqbl-lQ,1236 +torch/include/ATen/ops/_foreach_expm1_compositeexplicitautograd_dispatch.h,sha256=lrPTOAYbVX6oE7BRXLqRaSTWxN-SWLXlafA1mFX1ggg,863 +torch/include/ATen/ops/_foreach_expm1_cpu_dispatch.h,sha256=HHRnDp7kxz9Lq43IzEJ4l8mX_tSIu7jePHv5pp92dnw,792 +torch/include/ATen/ops/_foreach_expm1_cuda_dispatch.h,sha256=D5YmPyI30BE8PM7-_qlIfmWAXNESKCTBaqkopj5KbYQ,794 +torch/include/ATen/ops/_foreach_expm1_native.h,sha256=5WVNlvMh0KAC0J3u5VOChhCGHYQvCjpO6rIQFfb6YPs,805 +torch/include/ATen/ops/_foreach_expm1_ops.h,sha256=N3M7yJEbusLeYCU9gtOH-WP8Oy-Yry0FgRI_5a5pmp4,2173 +torch/include/ATen/ops/_foreach_floor.h,sha256=lP91e4mWRw43dDqjaXe1R6KL0RvDUl9tCK9K-bLf9rw,1236 +torch/include/ATen/ops/_foreach_floor_compositeexplicitautograd_dispatch.h,sha256=fLNhZ0K06v_Smdho-JO5khpPO9bO-JV5lZixQhneK4w,863 +torch/include/ATen/ops/_foreach_floor_cpu_dispatch.h,sha256=WOvuji4GvImXoDIivhwhc0uywuIji0A3xljNdWICqrY,792 +torch/include/ATen/ops/_foreach_floor_cuda_dispatch.h,sha256=55R0Y5YKLcpj_ChzYu_4yP_RrZcRkVn5C68n8VGhg94,794 +torch/include/ATen/ops/_foreach_floor_native.h,sha256=x3t-tD6BvCC6nNMXSwNa7YDQYP8VwWCKr6zzn3xlTIU,805 +torch/include/ATen/ops/_foreach_floor_ops.h,sha256=J1Dor77M1hTeXb1prePrQnVLJQQ6-kNyAM2450CiiKk,2173 +torch/include/ATen/ops/_foreach_frac.h,sha256=4HgHQtaFAcd7wCApMbfPyFK_X2DncnvC3PKta_N1AtY,1223 +torch/include/ATen/ops/_foreach_frac_compositeexplicitautograd_dispatch.h,sha256=r6cTswjYlSixiobFtGpNYMRfXJgbmBBYHMnXuglZsO8,861 +torch/include/ATen/ops/_foreach_frac_cpu_dispatch.h,sha256=Pf3g3FNf7zljCrfy0q4sqihvNkUPAmTRYvkkm2NlMOg,790 +torch/include/ATen/ops/_foreach_frac_cuda_dispatch.h,sha256=IBPJo0ySAGJvURuBXiBrF2Wn_kCZKL-uIusdCA1p6iU,792 +torch/include/ATen/ops/_foreach_frac_native.h,sha256=Zh50dPkXgEdzFsDUwdcH-xe-mWr44VB_8Lst0o1-sDM,800 +torch/include/ATen/ops/_foreach_frac_ops.h,sha256=dCMVAdQrsHTYGyyWNTXtFHqLQEAWjIagXeWKx4-f6V4,2164 +torch/include/ATen/ops/_foreach_lerp.h,sha256=9S8y8joc8sa7io422TXOq_i0cy1z0T4GLM9rMLbD-j4,2881 +torch/include/ATen/ops/_foreach_lerp_compositeexplicitautograd_dispatch.h,sha256=_5gPRiWvNozv3H7xQnCheo8qEkU5fOakIMXvRzJoTkk,1214 +torch/include/ATen/ops/_foreach_lerp_cpu_dispatch.h,sha256=f6-lJTzJoRZeCv6Db7HqdqncYTFBzH0cwNsZLi8U5x0,1116 +torch/include/ATen/ops/_foreach_lerp_cuda_dispatch.h,sha256=51JMl2TR8pMMlKU8riGR7UqL61oZbeaRuQC9dn7DVa8,1118 +torch/include/ATen/ops/_foreach_lerp_native.h,sha256=D10vwTmBnRVNVjzUvqOa5vwGuEqNfcfDkvP6taSvcq0,1750 +torch/include/ATen/ops/_foreach_lerp_ops.h,sha256=2GAKYMZvcFgVNUPw3KzpqeXFSLdQUhpzhmlyH3U9DAQ,5021 +torch/include/ATen/ops/_foreach_lgamma.h,sha256=Vhelis1pXrJD7_PfQb6-0TLa1UJBZmHbWFVzRLj3P0U,1249 +torch/include/ATen/ops/_foreach_lgamma_compositeexplicitautograd_dispatch.h,sha256=TtBRCEN893CI83TjNC_aj3InwJxBlP9FWu2_KrFw4Ac,865 +torch/include/ATen/ops/_foreach_lgamma_cpu_dispatch.h,sha256=X-ZQKqkVfPOTdaB5P1RrRHGrcPAvMemAYO-SDQTlRGE,794 +torch/include/ATen/ops/_foreach_lgamma_cuda_dispatch.h,sha256=8N9U0VyHcVjoHtuRQsaKxTTzvIef3uZ4qNjcg_Tly4w,796 +torch/include/ATen/ops/_foreach_lgamma_native.h,sha256=JHXCs_FWZ5v2mMtMwkEM4cCUOdf5ka7zLWbGLe6ndaA,810 +torch/include/ATen/ops/_foreach_lgamma_ops.h,sha256=d35TE_PNawqSDLWrF4Y0Cg5mLVsws7mnfmwQqCBdPms,2182 +torch/include/ATen/ops/_foreach_log.h,sha256=iuENvOYwycII7abHhqfdHVDNVuF-na_zWUn7EK0yzck,1210 +torch/include/ATen/ops/_foreach_log10.h,sha256=qyIgiXxl3PdzgqbmSurEU0IEEViQzyXrnAhxBNa55Ac,1236 +torch/include/ATen/ops/_foreach_log10_compositeexplicitautograd_dispatch.h,sha256=2oXuK9mYtO3nVPHwIJDohr5tfbproZUwtjLhUHw30Ww,863 +torch/include/ATen/ops/_foreach_log10_cpu_dispatch.h,sha256=V2BgvhZg7a_eQnb5j8LCu-dNX5d8PhPBGO9cHaUTWcQ,792 +torch/include/ATen/ops/_foreach_log10_cuda_dispatch.h,sha256=vuuyxCjXUYlHAM9JE3KOKRv7aLqAuINTDBf58pSfXS4,794 +torch/include/ATen/ops/_foreach_log10_native.h,sha256=l0U4XNWs6hBHeYYu3SWpuMxLBkVhNntyUaleGKIEAH0,805 +torch/include/ATen/ops/_foreach_log10_ops.h,sha256=320j3AsE3y9dHsz3Esesw-VyQrv3c_0mdevy-hHvVfw,2173 +torch/include/ATen/ops/_foreach_log1p.h,sha256=bC2d1iVmBF-A_ZLuu-340n9HNAx9KDZyQvwOiJhuISg,1236 +torch/include/ATen/ops/_foreach_log1p_compositeexplicitautograd_dispatch.h,sha256=9wbaYVbTugcXwXMYgxljVu8dqO1TCeC-KYwG9naIV7k,863 +torch/include/ATen/ops/_foreach_log1p_cpu_dispatch.h,sha256=w0jOyJg746cA7rsc_loDSkZF2bzhyLJ6dEUIssRDr5M,792 +torch/include/ATen/ops/_foreach_log1p_cuda_dispatch.h,sha256=eJGg9QKhLOU6lTcUwbFci09U7R8m2u1rIhjf_wlC9fk,794 +torch/include/ATen/ops/_foreach_log1p_native.h,sha256=LcEzgieBaXaJb9tYf7WRGvr-991TPNGMcBnv7eSaP4o,805 +torch/include/ATen/ops/_foreach_log1p_ops.h,sha256=5B0surp5W0PRpRIBzkoQBMy1JxxxSjUQn2GtKEpOSB4,2173 +torch/include/ATen/ops/_foreach_log2.h,sha256=dpnVK8bALYsL_KaqDCqhVbIXDLqAtugJnccZ0Q-z2xE,1223 +torch/include/ATen/ops/_foreach_log2_compositeexplicitautograd_dispatch.h,sha256=wsJMOlakHvYkH9i-MV004Oi6IK10O-39xyw6LIngxnI,861 +torch/include/ATen/ops/_foreach_log2_cpu_dispatch.h,sha256=z-Aq-IeQmGmygaR_VZDT59cMgJQ2t0WO9y382LAXK2A,790 +torch/include/ATen/ops/_foreach_log2_cuda_dispatch.h,sha256=oOUXvy7zsR-xVGIya-T5mYfdE_VcwwFksrPBIb1VzhY,792 +torch/include/ATen/ops/_foreach_log2_native.h,sha256=C44RmLk1pRfAdx06IudPLh2h7Xetb0vz6QUlfM1DfLQ,800 +torch/include/ATen/ops/_foreach_log2_ops.h,sha256=XbVINpE8g7MlxhwyCn6o0DlNnCdbAjYgewrGbjC32Xw,2164 +torch/include/ATen/ops/_foreach_log_compositeexplicitautograd_dispatch.h,sha256=iOiHKKnX0qf4xAgQrSwlko8eAw50O3AJ5DA6-Arzkbc,859 +torch/include/ATen/ops/_foreach_log_cpu_dispatch.h,sha256=7ZlYl0QYxcftqKLIdMzHS2ld2emCxKfpYcAJbvcYNBg,788 +torch/include/ATen/ops/_foreach_log_cuda_dispatch.h,sha256=O7Cgtxe9NkYqZRutywEMbRqxvKUpQtikji0HI-55X7g,790 +torch/include/ATen/ops/_foreach_log_native.h,sha256=yFjgI-EDjxwbosYhhoePpugeq57HrMSw-na3-dMAlfQ,795 +torch/include/ATen/ops/_foreach_log_ops.h,sha256=YbcSr87EdP1cP0yI81fIIaECsdLeZ8VNcc5AQo4sXm0,2155 +torch/include/ATen/ops/_foreach_maximum.h,sha256=74pqsMQQX2pmxlMfcA7H36CkdHAAowFNo2M6nRMUIM8,3594 +torch/include/ATen/ops/_foreach_maximum_compositeexplicitautograd_dispatch.h,sha256=I5QgF8KIIb1kH3wzl_dr0MPhZE-Zk55z_CXMBE0vTrU,1347 +torch/include/ATen/ops/_foreach_maximum_cpu_dispatch.h,sha256=iyi6QalmHxxWFoNzUgPfZROPsj0rXziuDbkiHVAf4xs,1222 +torch/include/ATen/ops/_foreach_maximum_cuda_dispatch.h,sha256=RxKOWS1pl8YpZ34yZsK8_P_qffiTKHL7AFPzIVvscNg,1224 +torch/include/ATen/ops/_foreach_maximum_native.h,sha256=7i6PtxU43xSf11xSAaU7eT4Ok9aoJAJIIXQgv1awgN8,2217 +torch/include/ATen/ops/_foreach_maximum_ops.h,sha256=Gv12vpDpy44gbOgSQI5aURcqnsA7JrLWgaEaFOE4EmI,6737 +torch/include/ATen/ops/_foreach_minimum.h,sha256=0drqf9ZipFTyR01veb-EPRSZ64M-dY_cU15t1NSf4ZY,3594 +torch/include/ATen/ops/_foreach_minimum_compositeexplicitautograd_dispatch.h,sha256=mIgXu1YCVEnEyU2afbOkXc03QZ7W2YYr85LgQAaNFes,1347 +torch/include/ATen/ops/_foreach_minimum_cpu_dispatch.h,sha256=pAOs7d-uWx-U6y8OrSwKyiKf8K0oW0sKenY8JSwptmg,1222 +torch/include/ATen/ops/_foreach_minimum_cuda_dispatch.h,sha256=qP4oz43SebofPXOZP2DXigz8hqBkRmaMquXE8hTMuKY,1224 +torch/include/ATen/ops/_foreach_minimum_native.h,sha256=YLmBYThyxMQ2_wofAUcDcXIfJfz2S-9tUaL9pwAU1PI,2217 +torch/include/ATen/ops/_foreach_minimum_ops.h,sha256=ji8xaolfTnCE6xV4SIUxlCEhwrRT08FUWcFjCMk8WZU,6737 +torch/include/ATen/ops/_foreach_mul.h,sha256=Yxe3UB3exCxKB9LgyroS6OU7lpyt852Kl2lmh2ro8gg,4404 +torch/include/ATen/ops/_foreach_mul_compositeexplicitautograd_dispatch.h,sha256=urb5ZZXgRH6xeWFAvQJC3VA05FaZLFX-zMEgAKzNbls,1524 +torch/include/ATen/ops/_foreach_mul_cpu_dispatch.h,sha256=eYfsWSzBDom5HKyOpt6xuB5Q54mOP1t0iYYCWzKZyyU,1372 +torch/include/ATen/ops/_foreach_mul_cuda_dispatch.h,sha256=Di0b-BfdiK3lI1QxWtykED3EGhm8AX6EnBFCi8EK1X8,1374 +torch/include/ATen/ops/_foreach_mul_native.h,sha256=k1_qfP15YdnsXjKR5utfzYrcXrno905-ShlMPMlBKY8,2688 +torch/include/ATen/ops/_foreach_mul_ops.h,sha256=9OU12rEs-9ufGDiz-uLj5E8WJoHYudBv-xBgw4X9ZPw,8669 +torch/include/ATen/ops/_foreach_neg.h,sha256=tjY2d4Vay2ExJh0NXI3YDhAu0WQaJDxJQJDDcmqaY3s,1210 +torch/include/ATen/ops/_foreach_neg_compositeexplicitautograd_dispatch.h,sha256=KgW8o2FqctPsXfzI1l9Umf4tc4Aq2ReSFcT7thb_gqE,859 +torch/include/ATen/ops/_foreach_neg_cpu_dispatch.h,sha256=cXDlvBfIo7t45TbIMD__f-0UzWjPT2FLouYc__Tz2Xk,788 +torch/include/ATen/ops/_foreach_neg_cuda_dispatch.h,sha256=LNirobRyRHGw6PbIqMf_mKBUAUSZJSjAGDRmRVBBRS4,790 +torch/include/ATen/ops/_foreach_neg_native.h,sha256=vVY3b0vwgtj0JJtlJolYNPUui9uQjOkGOiAJL8lR1KM,795 +torch/include/ATen/ops/_foreach_neg_ops.h,sha256=xOphbFt9L9RDfjotxpYKakZw14kytlpc_MylONV4IqE,2155 +torch/include/ATen/ops/_foreach_norm.h,sha256=vBqfnqwW3p-2hVycMvgGV_BFYucCkzlGr8h66_CHiFw,1247 +torch/include/ATen/ops/_foreach_norm_compositeexplicitautograd_dispatch.h,sha256=rmlmHUqxs7S-cm3s6nZJe9eA8JrasBFhEIP8dC8_VJE,911 +torch/include/ATen/ops/_foreach_norm_cpu_dispatch.h,sha256=JUCXOfXIAwvIq_46H3anm04HSP8ykCopnC5XQbCQ5sE,764 +torch/include/ATen/ops/_foreach_norm_cuda_dispatch.h,sha256=smysiNglNlRFYHc4ddY7tFHKVBx7WC9rJkuRGfSDUvo,766 +torch/include/ATen/ops/_foreach_norm_native.h,sha256=6nyw8ZOfeTT29onG6zzxg4dGsWSDlIgKuthsFkw0HA0,757 +torch/include/ATen/ops/_foreach_norm_ops.h,sha256=CcUnVMw97ylO1aL-tMnL5Mf0kisjynUZsbMsMhXu_Fk,1840 +torch/include/ATen/ops/_foreach_pow.h,sha256=Esr0T1wcyE3o5iKng5wCHufs1mFarMowOJoAKqpj5ak,3774 +torch/include/ATen/ops/_foreach_pow_compositeexplicitautograd_dispatch.h,sha256=M54HoGzBmJjyNy8tZ3S29HPj5z4IkA9gJZS6bcBvPvw,1335 +torch/include/ATen/ops/_foreach_pow_cpu_dispatch.h,sha256=pMV7qfkgWtZQLHtohWEET370lTImve28wI0URcbXvR0,1310 +torch/include/ATen/ops/_foreach_pow_cuda_dispatch.h,sha256=UtCRbPpjeMg-XjAVX4cTxmCUF6fZagEnaa1GkiTl53E,1312 +torch/include/ATen/ops/_foreach_pow_native.h,sha256=7-K0AwBfKfSvsDNCxYC9mWzu3bR5K9SERSG9vkvoKmQ,2409 +torch/include/ATen/ops/_foreach_pow_ops.h,sha256=II2PwkZ0TbBwhmD7H-bEAn8kZIbxz2jHu4P16RmKUSw,7413 +torch/include/ATen/ops/_foreach_reciprocal.h,sha256=aSKrdUC0VznKCBdlV2M3hPTA0oIObY0fCPQUROp0Ay4,1301 +torch/include/ATen/ops/_foreach_reciprocal_compositeexplicitautograd_dispatch.h,sha256=9qM163WBb_St_UIUVNs76Tbi9KXUHmWgZ4D245yGYvw,873 +torch/include/ATen/ops/_foreach_reciprocal_cpu_dispatch.h,sha256=qYUVjCLPsDzroPpActrvmfP9CiUopPK_hNdZACWVoIw,802 +torch/include/ATen/ops/_foreach_reciprocal_cuda_dispatch.h,sha256=wdyYLOJ0AOcxTxYEmb0AYmHZK-dwx6jc0sAibvlp43s,804 +torch/include/ATen/ops/_foreach_reciprocal_native.h,sha256=WAVJ69eHeVPbpPKUrsi10o7KfjMi8W7hBWkPtvExK2w,830 +torch/include/ATen/ops/_foreach_reciprocal_ops.h,sha256=BAjRL2cpkyL54knTp6VwAFgAyH8W29SOkMWUGayiL_8,2218 +torch/include/ATen/ops/_foreach_round.h,sha256=OliUQtdG2tdZDJYmW_wqU4eZfAE2ydZdfr5FtLwyS0o,1236 +torch/include/ATen/ops/_foreach_round_compositeexplicitautograd_dispatch.h,sha256=omMOVjFjhdYFh1iEcTYlglB8qhLTSgJsiI8Mk0KjYY0,863 +torch/include/ATen/ops/_foreach_round_cpu_dispatch.h,sha256=pl69NffB2DlY-3uenJ_7fp5wTbT-v3w_mt-V-sODaok,792 +torch/include/ATen/ops/_foreach_round_cuda_dispatch.h,sha256=fCNyh3eTaIc43aXrhMYwL4VUFRVgcHvtpc9vY84gQ5s,794 +torch/include/ATen/ops/_foreach_round_native.h,sha256=v5IO81mSMYmZDnpVsHIwbJkDn-XwJB2pNo1qPmb3dPQ,805 +torch/include/ATen/ops/_foreach_round_ops.h,sha256=Jvs1RnbYyAhHDMVu1P6LFL2wTn3BclyZeNkHk6whuh4,2173 +torch/include/ATen/ops/_foreach_sigmoid.h,sha256=j1ytFDkXtC6DQmkxjBRvuU0jHp7FcMn0mwY3U2EFOcA,1262 +torch/include/ATen/ops/_foreach_sigmoid_compositeexplicitautograd_dispatch.h,sha256=ylXUwFkvfLaRGCGj2ck-h49Raa5sEguwK6CkaTf_fSQ,867 +torch/include/ATen/ops/_foreach_sigmoid_cpu_dispatch.h,sha256=iACNYEs6w6BzddcR9Tfwcb0p23b3OQ04sK0DDUgy3sA,796 +torch/include/ATen/ops/_foreach_sigmoid_cuda_dispatch.h,sha256=dEwMO5XnsNuy8JLKQ4luueKkJS451T3oCTRZUp_NWp8,798 +torch/include/ATen/ops/_foreach_sigmoid_native.h,sha256=mxlgnIfQo_7LBvIoJLwPN9Z6ZK1IRwGSUND_JQnRYNA,815 +torch/include/ATen/ops/_foreach_sigmoid_ops.h,sha256=ScXoAjZsuG0HWr-CBj0Zj-hKGDQL358JICX3TnoYK0Q,2191 +torch/include/ATen/ops/_foreach_sign.h,sha256=-1zHcLCTmGr9KQZQu2G2ylTLZ-zTw6KQ1OU9DzE6zW8,1223 +torch/include/ATen/ops/_foreach_sign_compositeexplicitautograd_dispatch.h,sha256=uTgcgvAo3mE6lIuMUrR2_1aHBbJYV6OzNsTu7PwAMm4,861 +torch/include/ATen/ops/_foreach_sign_cpu_dispatch.h,sha256=vuZIH7F6y44rNkp78IiAJi4oDH2iRZDEUB4AV1Af3Sw,790 +torch/include/ATen/ops/_foreach_sign_cuda_dispatch.h,sha256=i7B1Z15lVhpkr2dtNit6VYZ2ltDw9aFZc0UbjBVSlMY,792 +torch/include/ATen/ops/_foreach_sign_native.h,sha256=4PhAbhbyWLXHqkGIu4S-vDmsdrnaTuCLsHtz39XvzQU,800 +torch/include/ATen/ops/_foreach_sign_ops.h,sha256=hie-WhT77cWFHSTKIsfUMDhwAMgatxyzD5LE7NI9t4g,2164 +torch/include/ATen/ops/_foreach_sin.h,sha256=42bt6aEC54GoDT9XR9oJU1l97cKoia8FS18jVDAHmwM,1210 +torch/include/ATen/ops/_foreach_sin_compositeexplicitautograd_dispatch.h,sha256=ti6Vd-SVWZcJvhY7F3Fe5SJuNfbTXsY6L6GP-2nCgmo,859 +torch/include/ATen/ops/_foreach_sin_cpu_dispatch.h,sha256=ljbEQdd9zBE4jgjl8zEx9HZlmoHiax5MdGPNdrkuT1w,788 +torch/include/ATen/ops/_foreach_sin_cuda_dispatch.h,sha256=GkuQzGOsrNLYUe1Gq9_OKJjzayi1k_wOFxJGIIjAiW8,790 +torch/include/ATen/ops/_foreach_sin_native.h,sha256=6tL8iS-2_rjejs_yL1Q4nLSq1P-XEA3TAKdZfSnCiY8,795 +torch/include/ATen/ops/_foreach_sin_ops.h,sha256=tjpT63pTDQcvFqo-hqSD0rlBZTjMSISj4sJWd3ZoCEM,2155 +torch/include/ATen/ops/_foreach_sinh.h,sha256=UA8ou_mysASxwd2ou_ayVaLvKUnEir51MY50LTSON3I,1223 +torch/include/ATen/ops/_foreach_sinh_compositeexplicitautograd_dispatch.h,sha256=3ECVmQ2JBvwSL5oNAd6HT4SCsKi5zRZo38V-ABjuDpI,861 +torch/include/ATen/ops/_foreach_sinh_cpu_dispatch.h,sha256=FFEqC4ENpeRFF_f99nT1UlH63N2-UYlOm2dmUj1osyg,790 +torch/include/ATen/ops/_foreach_sinh_cuda_dispatch.h,sha256=Ds_xzRCY9t6plr2vnX_dWl__guO_L4z_gWq_Lpj6mR0,792 +torch/include/ATen/ops/_foreach_sinh_native.h,sha256=rl6hdDkgqnURR7ejGh9b1kIBE-qKST9dyoHGBKAzCKg,800 +torch/include/ATen/ops/_foreach_sinh_ops.h,sha256=Pz_qtQ20Xc7hACEvbk2oNQDEKYwbg29at54bhcAXhh4,2164 +torch/include/ATen/ops/_foreach_sqrt.h,sha256=gMsGClUTAMJ03A-Lu2j9bCRfQMLxhMnSbcl4woUIrrQ,1223 +torch/include/ATen/ops/_foreach_sqrt_compositeexplicitautograd_dispatch.h,sha256=O_BbStZpihRMSJYD_vCnEj6dKdBAon0tjJzH0a_w5UM,861 +torch/include/ATen/ops/_foreach_sqrt_cpu_dispatch.h,sha256=Tq1kJ-DrejeHCORl0RhLx0GF7XUIlLKWzao7sdyKAz0,790 +torch/include/ATen/ops/_foreach_sqrt_cuda_dispatch.h,sha256=R2I313_FMJORMUQMYqSkhx40Z6FT8OQdnUaBvM9w25g,792 +torch/include/ATen/ops/_foreach_sqrt_native.h,sha256=HkjpsiJEI1svh2PlXPMlVfpBVJPFzFlqEfT-MJjex_c,800 +torch/include/ATen/ops/_foreach_sqrt_ops.h,sha256=fV6j3dLXgvjr3O2E30jA6TUXJEJqWrRVgeVBb5JNmRI,2164 +torch/include/ATen/ops/_foreach_sub.h,sha256=QuTdWE4ch3anzn4nujSoXfX4Z263yfUr80tClnO0QWI,3654 +torch/include/ATen/ops/_foreach_sub_compositeexplicitautograd_dispatch.h,sha256=71AxTK3vpkBqq-Houi_aMTRMy1dQNm5TU9PcjPr9YSs,1377 +torch/include/ATen/ops/_foreach_sub_cpu_dispatch.h,sha256=fpYtawLLrFbHCogat44EfhbU2A_fko1FONS59RRa33s,1254 +torch/include/ATen/ops/_foreach_sub_cuda_dispatch.h,sha256=clpGRsPk-bTft2ZLnilk2HuRI_1tsgszrVyToCH8rO0,1256 +torch/include/ATen/ops/_foreach_sub_native.h,sha256=anWgjUye3UXmy99o_BLTzPSOPwOqErAM1eHT1A_ru_U,2271 +torch/include/ATen/ops/_foreach_sub_ops.h,sha256=j5PkyohR3ImR9pJFVu-ATOgT0HTVQ8ovPzK2RMj7T5U,6899 +torch/include/ATen/ops/_foreach_tan.h,sha256=DtmZXVY-oJSPMxiNcV3vgwRSawKkbvha39W5FrD7N1s,1210 +torch/include/ATen/ops/_foreach_tan_compositeexplicitautograd_dispatch.h,sha256=nyITMdD29d6bjKMgEbjChXmnUCgGmR8wiv1k4U3w2Q4,859 +torch/include/ATen/ops/_foreach_tan_cpu_dispatch.h,sha256=M2JBO9rxKKKgcovVtHjByZ9gV3s9LO-PTX4YOyqaiho,788 +torch/include/ATen/ops/_foreach_tan_cuda_dispatch.h,sha256=r9_M7nVUJmzWLJHGPPYVbvB5p5Im-7WeMMeYhmZwZiY,790 +torch/include/ATen/ops/_foreach_tan_native.h,sha256=W8vn0Yd40cJeyC_ViUK5Qnh6n4ShztrGwAJId_EL1T0,795 +torch/include/ATen/ops/_foreach_tan_ops.h,sha256=w5yZXgalqkdtvsT2unnu0qIAZEw9vq_qwKLtNGJGjOE,2155 +torch/include/ATen/ops/_foreach_tanh.h,sha256=PHOJwz0weZ8xlvp-Ofb8ZE9-MgoqZ7YCDCyXjjIAWuc,1223 +torch/include/ATen/ops/_foreach_tanh_compositeexplicitautograd_dispatch.h,sha256=tw77eYE7DWjjZ7rSrULhc2vaFXIZ9KxTVcdaP4P1-JU,861 +torch/include/ATen/ops/_foreach_tanh_cpu_dispatch.h,sha256=IkaSyLlWRLIZgPd9zZdR16M3zzsdarRy_DO-_m_AHS8,790 +torch/include/ATen/ops/_foreach_tanh_cuda_dispatch.h,sha256=hT4YelKEv44WsMi9mDhVUJXtAO0oW3ClYnhyHh1yWi4,792 +torch/include/ATen/ops/_foreach_tanh_native.h,sha256=AI3z25b-4OJG-3w4VqrczCn9IujMU74oCNkuoq0YYuU,800 +torch/include/ATen/ops/_foreach_tanh_ops.h,sha256=4ehl2qhf40CO38-jThVp4_rFBDqvEDjjOLZ7sH-oOeM,2164 +torch/include/ATen/ops/_foreach_trunc.h,sha256=zLbEOEyvqLkgwtsTGAStZgtF-6e0RLxRRDkGtgQaCqc,1236 +torch/include/ATen/ops/_foreach_trunc_compositeexplicitautograd_dispatch.h,sha256=XxRXOO-UBGlIqIWD0_dRCMdWOoqT_HRsNxFVpoLlpSM,863 +torch/include/ATen/ops/_foreach_trunc_cpu_dispatch.h,sha256=aab8Hg34K9IcG8BmKqKHSHbHAKKE6I4s-dFfBkJdSbc,792 +torch/include/ATen/ops/_foreach_trunc_cuda_dispatch.h,sha256=9J3JZTWwXdi82irP1-EXfOK7OL_dzzEwzeFO7LUxxW4,794 +torch/include/ATen/ops/_foreach_trunc_native.h,sha256=n9ZqoMI8cr93x1d4tJ_8JSNFQz_44oOK76sbyHGFXHQ,805 +torch/include/ATen/ops/_foreach_trunc_ops.h,sha256=pbCnpnVShE7zcr0NPpgDqG0LRjhkLYsre3-P8XspMHA,2173 +torch/include/ATen/ops/_foreach_zero.h,sha256=CT7OAqZWYqEUySzFHuaCPdphLvK_Dp1VCbLV0ELbph0,1232 +torch/include/ATen/ops/_foreach_zero_compositeexplicitautograd_dispatch.h,sha256=L1ul6OmlLSWGZDs-CLd3a_CNS98p3BhB1NGlbnQcWrk,933 +torch/include/ATen/ops/_foreach_zero_cpu_dispatch.h,sha256=BBOdSbbdJGcAK3IVOKEFT_Xira4Kc-6qTM4yhDCvUzI,718 +torch/include/ATen/ops/_foreach_zero_cuda_dispatch.h,sha256=xiDyMl4EnnJkOHF8FSTS6_4XN4yiehDDCZomxVXr268,720 +torch/include/ATen/ops/_foreach_zero_native.h,sha256=2JTKQMqcef-pvqZacivTjEkk2lJw3CY7hXjc1bgNSvM,706 +torch/include/ATen/ops/_foreach_zero_ops.h,sha256=AW5AukePRmcGN1_UsEF3442aqSiMdWNquQhEdcUTINA,2173 +torch/include/ATen/ops/_functional_assert_async.h,sha256=RBpPi00ZeN9oZi5-2IewHMRL7nT0lwktnkboiwP1OEM,821 +torch/include/ATen/ops/_functional_assert_async_cpu_dispatch.h,sha256=ot74CjLgr5VdbrT_dqIt5KVRcc5VP-Tqt4HGMsAXT1A,797 +torch/include/ATen/ops/_functional_assert_async_native.h,sha256=qDB1WV27Fwv0ybzTQWHHxwI0fYJcFzPRmZB690It75Q,572 +torch/include/ATen/ops/_functional_assert_async_ops.h,sha256=F_UgI8uZazR5ogIA_6Yi-txDkD-cux-fXpQ3P8ObaIU,1222 +torch/include/ATen/ops/_functional_assert_scalar.h,sha256=eXm4_9llUeT-YiDek3gqlNLheg3VgUygp7DxkUMbp9A,817 +torch/include/ATen/ops/_functional_assert_scalar_compositeexplicitautograd_dispatch.h,sha256=5rmSQMPsUHjMEHryg_oZ6miOh7UGhYL-QuF18bLLbKg,842 +torch/include/ATen/ops/_functional_assert_scalar_native.h,sha256=3LFyE98asEGoKABp9S1ql6kjKUT_UYUAe921J-GUb_A,565 +torch/include/ATen/ops/_functional_assert_scalar_ops.h,sha256=CTTej59oqr264o6Mn6t1kFo99IRhS7BL5Q93w1mwSeI,1214 +torch/include/ATen/ops/_functional_sym_constrain_range.h,sha256=EwhVby20AQekyWSLAdWDzsfuTpzuYmNa8kw0WD24iMs,870 +torch/include/ATen/ops/_functional_sym_constrain_range_compositeexplicitautograd_dispatch.h,sha256=CwN6p_9qUOwntB_MavePjQgoDcfyklPl7iL9pMjGumM,875 +torch/include/ATen/ops/_functional_sym_constrain_range_for_size.h,sha256=2f_b3VVbxE4N2UnIqoCW5EM9hiEwQtfA5tbV75XnMJY,906 +torch/include/ATen/ops/_functional_sym_constrain_range_for_size_compositeexplicitautograd_dispatch.h,sha256=ILGuNh0UNC2i7aMAnhp0XD5tQI4DBqIJODRRwKxL9Yc,884 +torch/include/ATen/ops/_functional_sym_constrain_range_for_size_native.h,sha256=fZtJ2rEEtP1mEQCed441_7hA_5_QWtzbIiV_wvSYYts,607 +torch/include/ATen/ops/_functional_sym_constrain_range_for_size_ops.h,sha256=TPdsRbygE_4jo3cIlvS2jf2Y8DhVclDR8V-Pbsn74Bg,1347 +torch/include/ATen/ops/_functional_sym_constrain_range_native.h,sha256=IjDUo1TfCx6gXF_Nw7jzaCYvF7ZiD5RQ_K-G4p2uyQ4,598 +torch/include/ATen/ops/_functional_sym_constrain_range_ops.h,sha256=48rva8nb7Q0AS5PahRK-aZdFzcb0nDKGsGMz_rXcUeM,1320 +torch/include/ATen/ops/_fused_adam.h,sha256=XzEIRb1ij062HPXwKx2GAM_mHbfyjaIXOibavgRDXf0,8359 +torch/include/ATen/ops/_fused_adam_compositeexplicitautograd_dispatch.h,sha256=EcMqtxQCh018QZYHw_asVlkv0qNO47ooFW7WuX1a7_Y,3402 +torch/include/ATen/ops/_fused_adam_cuda_dispatch.h,sha256=aMrscdt5FWZksGZlseaxATVWHNgbQ4PgpKYkyjWo8So,1446 +torch/include/ATen/ops/_fused_adam_native.h,sha256=oNYXIBL7gEcMZbH6w7v1AUAFH9AaONLTnh9xrJ03Rv8,3111 +torch/include/ATen/ops/_fused_adam_ops.h,sha256=1t0FLRjBnNocA7uws7I-yH54W2lFqPIvLa25cYafkfo,11697 +torch/include/ATen/ops/_fused_adamw.h,sha256=c6rKceyPaXXb-_UQBOztT0X311lVWDdiZ6tE6GVSTpo,8384 +torch/include/ATen/ops/_fused_adamw_compositeexplicitautograd_dispatch.h,sha256=ijpjONzIGNCEtyHDZauVAl92HYJBkVf7e4vdEqMSHKk,3408 +torch/include/ATen/ops/_fused_adamw_cuda_dispatch.h,sha256=YnIpNhfyLywseKVEcAqKUB2WTICzbiLPfqEFKRKvGd4,1448 +torch/include/ATen/ops/_fused_adamw_native.h,sha256=p-kF6p86HKx7-SgZiL_7bpmFyd1o3U6_wCeMC8gM5GM,3117 +torch/include/ATen/ops/_fused_adamw_ops.h,sha256=8xsmqw6R1mGbHGNlU7hpT9PHNHwkM5vbo3lNabaMLbQ,11715 +torch/include/ATen/ops/_fused_dropout.h,sha256=7J4UVL0jdC5WTGkuRu5s2IpbePBa8tWrSFH3sghPZgY,1628 +torch/include/ATen/ops/_fused_dropout_compositeexplicitautograd_dispatch.h,sha256=VeT2rYvPhSB0SSRlE1_xyl9P6RkJf4vVMqMSIfkZmbE,1090 +torch/include/ATen/ops/_fused_dropout_cuda_dispatch.h,sha256=9OrJzFjZMPZ6v0bRPeU3YkM4N7djT5An-7OntWf4niE,818 +torch/include/ATen/ops/_fused_dropout_native.h,sha256=xrTJtWiE_13O6nzaIj5xK06blRIpMvb4Ut7qbzvltGE,770 +torch/include/ATen/ops/_fused_dropout_ops.h,sha256=o0SjZg7p8UCe22GitZjzFXQvre2QlbyBlcEhQsQJgdA,2238 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper.h,sha256=FwNcgEADJSyeW-yM_XUc49QZIwmne_44K2hdldNOzMU,4763 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_compositeexplicitautograd_dispatch.h,sha256=tBd5nwqRPK_YcyNF1-nW3MwbDw00wS3ggMbTyPAWjH0,2085 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_cpu_dispatch.h,sha256=72juH36Kwx_GmhJFveNm9GFakNipCNNOVaNfk1vKu7g,1071 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_cuda_dispatch.h,sha256=3I6zOASUf_AUFl_XBQpQC6syfdXhM6213Dfq2-akork,1073 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_native.h,sha256=6cQnAFTIx4hmZiFfrr0vbj0NR9Auk46vpW2-gkMSUkQ,2175 +torch/include/ATen/ops/_fused_moving_avg_obs_fq_helper_ops.h,sha256=-qHAA6TLbDHJRDV1KeXhTt47Y-NYnPrZzIQh7Blk88k,5950 +torch/include/ATen/ops/_fused_sdp_choice.h,sha256=rjoCmHSASUnX32ozuxr-wQnGM9-djGepBNvLf90tM_I,1017 +torch/include/ATen/ops/_fused_sdp_choice_cpu_dispatch.h,sha256=DThCfd5h0Ab6MjH1a_BuebvT6n0rFBdR6IwvrdUTILg,913 +torch/include/ATen/ops/_fused_sdp_choice_cuda_dispatch.h,sha256=GkQXFQEbxd4iy1axbyXIYjB73gaMwwxVmRd9sMjQwVw,915 +torch/include/ATen/ops/_fused_sdp_choice_meta_dispatch.h,sha256=WVcDMy_2D1G2-3--a8OJ_kKvAzmPN0NCl34a2eN1OUc,915 +torch/include/ATen/ops/_fused_sdp_choice_native.h,sha256=QbUFL-hc5pn-99ty487Ij_JDS5JfWIPacyRBuV-hpDc,1188 +torch/include/ATen/ops/_fused_sdp_choice_ops.h,sha256=3nFgEu9xnVC4ruowZ8C_7SZsvcBLCjuVktrz1cB_Uc4,1534 +torch/include/ATen/ops/_fused_sgd.h,sha256=Mggnm-vX2DsUwTYPJfk81ABI6QQoDVKzuFSbBfDjrnE,7182 +torch/include/ATen/ops/_fused_sgd_compositeexplicitautograd_dispatch.h,sha256=2h2In3HQeRDZ3sA-lmgU99xXptU48DGv2qvgrhIlHwc,2932 +torch/include/ATen/ops/_fused_sgd_cuda_dispatch.h,sha256=fMkrh2EgMyEfIPqp3w5EZS05nOSM6oBdLY0IUJIT2MA,1324 +torch/include/ATen/ops/_fused_sgd_native.h,sha256=Rjzi4bB5tosSV2aFKdVX3aJcpNo6pgZDwch6mVs7FS4,2641 +torch/include/ATen/ops/_fused_sgd_ops.h,sha256=ngiXKDXTONKZ1HKmAmGE_JFRLbb8k2f7jZNKAujFD4U,9981 +torch/include/ATen/ops/_fw_primal.h,sha256=wbUXfSDo6Onjb2cwvi8_gk9A5W3VVWjyuk8APQFZY3Y,495 +torch/include/ATen/ops/_fw_primal_compositeexplicitautograd_dispatch.h,sha256=NXQhFZcOOWc2XBL77CMAxQ8vOtxfeysFHmPttB2p8ig,783 +torch/include/ATen/ops/_fw_primal_copy.h,sha256=6UPe_bbGQwizliN2lCRgWJQlehls6WdQHQyNzbijMLU,1204 +torch/include/ATen/ops/_fw_primal_copy_compositeexplicitautograd_dispatch.h,sha256=lATcwWFhcyj-_zQS-09IQxQMTYUIxYv55Oyblg55m0k,915 +torch/include/ATen/ops/_fw_primal_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=E1jl5KdNilfGNuQgYiezT0ISLkd1RcPptxbL_vgFcqM,814 +torch/include/ATen/ops/_fw_primal_copy_native.h,sha256=cOOA91KP1NEyBu4itCHQeLoXjnEgL-Scr9gI-KyzdyE,613 +torch/include/ATen/ops/_fw_primal_copy_ops.h,sha256=-ahcisTRZ4snXodEtQhOPO0G-hwSBzFDgON8NOA6LOE,1744 +torch/include/ATen/ops/_fw_primal_native.h,sha256=7MiWJjXXWfY0QguelxKN5VTw_EwhRVtquGaXcYAvKOE,506 +torch/include/ATen/ops/_fw_primal_ops.h,sha256=FXyRwaJ8KTwoUMaSphA719lATPfrMtCWJLLygyXe6Kw,1035 +torch/include/ATen/ops/_gather_sparse_backward.h,sha256=7uLw-OrN0dclTBJW-vZKBAjIlRAtnmSYZjZdzX1l5tA,811 +torch/include/ATen/ops/_gather_sparse_backward_compositeimplicitautograd_dispatch.h,sha256=t54YLE3sVhaFbLKLPm5y2uR8ed1-eSvjClTF58tsjGQ,845 +torch/include/ATen/ops/_gather_sparse_backward_native.h,sha256=8MibZwZQmlX5GGwFAES7A-MdhMIhYC4rNnfwIyQgf-8,568 +torch/include/ATen/ops/_gather_sparse_backward_ops.h,sha256=dWj49Q0our4k4SGCk27OSrTkjXPmcbECGxy-4zwbJR4,1231 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback.h,sha256=99N-t4nLW4uW_ODfkZg94W-o9DlVnxjsA4xgr6IdNbM,1929 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_backward.h,sha256=YCI7-6HpXkbchjP4c51NdzOvjRogKwo4AEb_0SqU23c,1081 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_backward_compositeimplicitautograd_dispatch.h,sha256=0S7kWiPEKRmi0iS8JQ3K5TChzSpZNhAm1mjyXQgaUT8,949 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_backward_native.h,sha256=5OvV5KLZA_eUUeoT5pbpzGBImXuvCa5hXSOjuKpjZ-0,672 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_backward_ops.h,sha256=-8P0wwwuaNAjRJP-ssMm15Cm-qr3r2AzdbVE2Nt4Mh8,1564 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_compositeexplicitautograd_dispatch.h,sha256=RNJ5ldvNJNBMZ6RcgTfpPIoIjCoBVAF3X9TPiz7JjpY,1278 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_native.h,sha256=Mt5e4l94RCKbXI5mEGttZxm-VGy04n6CL9CflzWakj0,803 +torch/include/ATen/ops/_grid_sampler_2d_cpu_fallback_ops.h,sha256=KuViWyZWvkInJKCmc-4V1KzXs93c4bbrY9BDfEp7T9A,2352 +torch/include/ATen/ops/_has_compatible_shallow_copy_type.h,sha256=4f6UzockRX1C2HY5z9B24OLuMBa2uzCLr5SFnAPPU1U,769 +torch/include/ATen/ops/_has_compatible_shallow_copy_type_compositeimplicitautograd_dispatch.h,sha256=2xdv2qflbXPUttIRc55S8s2MotOCl0vLyftGJ5zbOWg,810 +torch/include/ATen/ops/_has_compatible_shallow_copy_type_native.h,sha256=WrVjbkfB5D7UIKtOJTYKG5QJ1F6z3b28dEGFu_OnMpM,533 +torch/include/ATen/ops/_has_compatible_shallow_copy_type_ops.h,sha256=AHx5f5Gw84e6bIjFaFns67u2qIjTRkSVIXnI3NmFnPs,1111 +torch/include/ATen/ops/_has_same_storage_numel.h,sha256=MiWNU-KMnSwHW5dziKKWGZ8YNjMV0BYpd2WqxPV87I8,732 +torch/include/ATen/ops/_has_same_storage_numel_compositeexplicitautograd_dispatch.h,sha256=2KsHY-jtYgiEkqUzRXGTD-UuQAasT2xh3VJnh-Y5UmM,801 +torch/include/ATen/ops/_has_same_storage_numel_native.h,sha256=TI1797wrMUYgWSBnEzOmHZSJiZ5u4FlW8ysKxKaK51g,524 +torch/include/ATen/ops/_has_same_storage_numel_ops.h,sha256=DVgjAgTHB5guhSSQR5_CFlKjHwKc_c_GFlah0r6LDes,1084 +torch/include/ATen/ops/_histogramdd_bin_edges.h,sha256=VJZ4tj5JWXWTRzNiv845wWrHcMNPfeOGKhXuT3ja4CY,1890 +torch/include/ATen/ops/_histogramdd_bin_edges_compositeexplicitautograd_dispatch.h,sha256=G2hNASgUToxabuxk387Qx9_YOIXgkuh-02uCEqMVX-g,1151 +torch/include/ATen/ops/_histogramdd_bin_edges_cpu_dispatch.h,sha256=W1THeUHy97D2I8Kj7-TPCAUegDYGoYP0oozD4SCltRg,894 +torch/include/ATen/ops/_histogramdd_bin_edges_native.h,sha256=zJd0LSacgjJGk72dNXKUyabuyQCWrOnqEeX5Ks6NkWg,869 +torch/include/ATen/ops/_histogramdd_bin_edges_ops.h,sha256=KdjhO-7A9oxZ93xZl36aSWksRuXsCBHTcGT_JAF5qQw,2534 +torch/include/ATen/ops/_histogramdd_from_bin_cts.h,sha256=x3BS71z-Mf1sElRdrKoh7_GjAsvwDSufvwG3-FNpVgo,1927 +torch/include/ATen/ops/_histogramdd_from_bin_cts_compositeexplicitautograd_dispatch.h,sha256=gTd4qjOyl9UM174oCjkVcKI7LT-jfE3Tv1PNUmhZ1pI,1169 +torch/include/ATen/ops/_histogramdd_from_bin_cts_cpu_dispatch.h,sha256=MUg6byE72784EIqE6APTbQUSXW2kgWsPlEUrbMmSJ3w,882 +torch/include/ATen/ops/_histogramdd_from_bin_cts_native.h,sha256=ExlwpGOxPN2u-W2Ua03_AgXggP4kFv2buKcvmALml1k,854 +torch/include/ATen/ops/_histogramdd_from_bin_cts_ops.h,sha256=ZMaCT5fgjZeWJLgg52IkSjt3cukkN6b7hEEUJNSbBc4,2529 +torch/include/ATen/ops/_histogramdd_from_bin_tensors.h,sha256=YboJ_IoXzpC8cEkowRUKtdvSUDoc17XaahVKCDy8ih4,1734 +torch/include/ATen/ops/_histogramdd_from_bin_tensors_compositeexplicitautograd_dispatch.h,sha256=noh8bYNKds2yL2nV_DW5EPCDugFMniG1Cb1Ft4Mp1eI,1076 +torch/include/ATen/ops/_histogramdd_from_bin_tensors_cpu_dispatch.h,sha256=uYYFEYzRMmuvKSmrZLTIN07fWA5s1NvhMjPYcKDIgCk,829 +torch/include/ATen/ops/_histogramdd_from_bin_tensors_native.h,sha256=ZFLujhYawma9JxXSlhdW5ytn6mbUvaUiCfeENuhc0CY,757 +torch/include/ATen/ops/_histogramdd_from_bin_tensors_ops.h,sha256=RczERmdEOWsdnCWTfo4w-nu44c9DZJOwYu_ZGjpwoDo,2265 +torch/include/ATen/ops/_index_put_impl.h,sha256=EQu2FHK8yRwor_kYq4nMHu3OwDbuy6T_POqguwiexN8,2206 +torch/include/ATen/ops/_index_put_impl_compositeexplicitautograd_dispatch.h,sha256=y0BFzHYggiCnoEk_nbygfDwtkN-QXzNODyj0l1utSvU,1305 +torch/include/ATen/ops/_index_put_impl_cpu_dispatch.h,sha256=8yZm7DMwQ0vCRq56c9qZslwTaulLNwGma-TR6DBzMl4,849 +torch/include/ATen/ops/_index_put_impl_cuda_dispatch.h,sha256=Gg3zjPKfQl9fe0GCkPmyji9k7fNj8JImV0wYfghuES8,851 +torch/include/ATen/ops/_index_put_impl_meta_dispatch.h,sha256=n9Tdl6DGkbEuOayiWrH8kh-VzxyFgxdahvgveVuqTMU,851 +torch/include/ATen/ops/_index_put_impl_native.h,sha256=GD_5Q0WIqFVRZ8m7BaSBfz4CZ1uiQqwyu4MjPVxodRk,1395 +torch/include/ATen/ops/_index_put_impl_ops.h,sha256=rWGJrRTCryGwsxEUG4oshVoEM7KEWNDgip_zATpig6I,3331 +torch/include/ATen/ops/_indices.h,sha256=sYoJIB4QD9Qjo4lvGtuCXt8IcxWYFnMDpOnc2tIhS9w,493 +torch/include/ATen/ops/_indices_copy.h,sha256=AUF0vAbTIEMdDiTufJduTdhXHn7PLLj12Tkytcw9VIg,1085 +torch/include/ATen/ops/_indices_copy_compositeexplicitautograd_dispatch.h,sha256=jyTTcUBtctnqGmqzumiA_We9NEUuSbtjr-GlS5olODc,881 +torch/include/ATen/ops/_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=7As9eYtRYosbx2LHlxoNmrZkYIbgrc6iUpUEutNA7Zs,797 +torch/include/ATen/ops/_indices_copy_native.h,sha256=ik7lKBRk6w48ls723MXXMB7ZiWVTCVO369YO0CTg-2s,579 +torch/include/ATen/ops/_indices_copy_ops.h,sha256=hPtMuivvSBABZHKoTrMnUNsWBaZ38NLjERgmE84u258,1632 +torch/include/ATen/ops/_indices_native.h,sha256=EJjVIITihp1oCzmdeRZo1sEtIpwvNhkN6MDlLEO7EJI,496 +torch/include/ATen/ops/_indices_ops.h,sha256=WJV-AukaEqphCkxNuEcb_lp13tJ_r_o9JAhw7tgdEio,979 +torch/include/ATen/ops/_int_mm.h,sha256=HCBWyI3QesGu7F4G54iai-eiOcqXp_N_c9S9r2xh-Vo,1157 +torch/include/ATen/ops/_int_mm_cuda_dispatch.h,sha256=iJjZqqVijsGowuCmY8zrbuKbZO8fMLJ0jxK7cX_PHvQ,957 +torch/include/ATen/ops/_int_mm_native.h,sha256=ZdE1Rq1kla2D_WGveyKndyPH4twCQp3hp4K3PvjSUI0,627 +torch/include/ATen/ops/_int_mm_ops.h,sha256=NRFABzdgr0o8-CuaTBFkZSTz6eVPix-hSfXRoxV1WC8,1762 +torch/include/ATen/ops/_is_all_true.h,sha256=-nOZILBRbOO1Qrlz8xOXZgMoU2hAOngzbSMvmK6lSW0,649 +torch/include/ATen/ops/_is_all_true_compositeexplicitautograd_dispatch.h,sha256=cF3R17YPvgyrHCreU1inqg62KpMC3PB48KGkRSHNpEY,770 +torch/include/ATen/ops/_is_all_true_native.h,sha256=aSqQV9YWRm-Sj3OtGUTLWjNauXC7kDtkDPWb-0HFFrY,493 +torch/include/ATen/ops/_is_all_true_ops.h,sha256=pHXirfaKizpEjoDE6gAn2PxR1SuKwj5XVnOg6CKzb-0,985 +torch/include/ATen/ops/_is_any_true.h,sha256=43EjOGTjO3G9Y4DDCBkfyH3MtkJfqpGozszQx91_hCE,649 +torch/include/ATen/ops/_is_any_true_compositeexplicitautograd_dispatch.h,sha256=Ffuv62XoptwkDY-X2MWzJrLWrjrm0Dm1EHbA8QwS5Nk,770 +torch/include/ATen/ops/_is_any_true_native.h,sha256=LAU124vrNyViUxyVOWgCRR0n4gY2ry_MODB3BgmL7Po,493 +torch/include/ATen/ops/_is_any_true_ops.h,sha256=ItKCLbGVLs2eU86tQ0wkcQgOynx0QnKXXnvjIj6pfJs,985 +torch/include/ATen/ops/_is_zerotensor.h,sha256=tq7DA5ZWGcXWR6jyoiIW1hdOxFXdETS2iorOIzRa-D8,660 +torch/include/ATen/ops/_is_zerotensor_compositeimplicitautograd_dispatch.h,sha256=FfbyZJnR2iPS_nbV5pJ0Tqc-uliqX5__GFKpmC6gAp8,766 +torch/include/ATen/ops/_is_zerotensor_native.h,sha256=SA5aboyRYMogFQJ1nI0KHP-uWyiCbV9N-OE-ztU1SuE,489 +torch/include/ATen/ops/_is_zerotensor_ops.h,sha256=ov6i5ur226gCwNXnavx3cw5L_DhfsGpvqIlcrnMi5ks,971 +torch/include/ATen/ops/_lazy_clone.h,sha256=wk7d5apJCVGR2lPs7hLtBfExtpMgEhUY4zYDyCoiDzI,645 +torch/include/ATen/ops/_lazy_clone_compositeexplicitautograd_dispatch.h,sha256=7k9eJxEeAoIJMjetZpYwCy3NJo9UVrZZP83XvPB6Xds,769 +torch/include/ATen/ops/_lazy_clone_native.h,sha256=Q2KGh6oMrJGvJckQpRBkOcAcRG2KMZmdxPm9lE0nU_8,492 +torch/include/ATen/ops/_lazy_clone_ops.h,sha256=MaewWa7hpocsH9Hre-sVXLsYQBwtxTiRq9eJo6qjRvo,982 +torch/include/ATen/ops/_linalg_check_errors.h,sha256=4ZMA8695NX8AqA_PpAXqhu5cXnBLJf4zy7dBLvzxTKU,768 +torch/include/ATen/ops/_linalg_check_errors_compositeexplicitautograd_dispatch.h,sha256=Ila6TAxjI4yORIeMU0AaOdS4D1NKKLwkF1KqSlFgFYA,815 +torch/include/ATen/ops/_linalg_check_errors_native.h,sha256=DcBogyUbm-aSylDdKGeSByOQOnKdiP5cWJx011Q8JKU,538 +torch/include/ATen/ops/_linalg_check_errors_ops.h,sha256=Wlld4uQmz6yltd4MY2DU-BiFqcZWcAsn4IBiLtELkqA,1130 +torch/include/ATen/ops/_linalg_det.h,sha256=Jd0pnUdYvok8fEjMI2r04WS3ji0fU71ScHgNAh9baRA,1473 +torch/include/ATen/ops/_linalg_det_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WVjrpZSPqf_pbAlfMdCe-RqVM3pKJCEATFhL8igoqGo,828 +torch/include/ATen/ops/_linalg_det_cpu_dispatch.h,sha256=z_9T-waezr7f5_RXrOIJTWJ4xe3Xkhz8n8zOtZbZINU,1081 +torch/include/ATen/ops/_linalg_det_cuda_dispatch.h,sha256=mwAEh8wiAGNxowNzc6rugiNefKqymhmQgg09VbNvLMc,1083 +torch/include/ATen/ops/_linalg_det_meta.h,sha256=xscwBLvb7_w1HKYCCfvAzoL1U5Tym1_PHFFv-yUlLyA,588 +torch/include/ATen/ops/_linalg_det_meta_dispatch.h,sha256=hihaWL2tAJfTjkOVw6Xu0gr7G1islScG7ba_sjKwJzQ,1083 +torch/include/ATen/ops/_linalg_det_native.h,sha256=sqfWHmb8N5xNuTCc200I9ji9DvK1u7et7aMZYz5A__0,672 +torch/include/ATen/ops/_linalg_det_ops.h,sha256=2tMI2quO0jJjme2jlZo9-9hDFr_UG1Xmhvy9bhe-B54,2064 +torch/include/ATen/ops/_linalg_eigh.h,sha256=OsIlQCzasDRkX41fS0Qrv4pyacgcz_-11yY9QN0WQN8,1743 +torch/include/ATen/ops/_linalg_eigh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=xjQc_Z7i5elpgIfxBJ4x_t2amOT7NB30PzRVvHn0S2o,866 +torch/include/ATen/ops/_linalg_eigh_cpu_dispatch.h,sha256=tY2qcoGuhgjrbN3haqFpMswV8v2KP6Vu-xWKOY0XykM,1170 +torch/include/ATen/ops/_linalg_eigh_cuda_dispatch.h,sha256=w9wi_MmlNh7OsHv87NeMqP_RpljQZHOR52LKS_Ebdk4,1172 +torch/include/ATen/ops/_linalg_eigh_meta.h,sha256=lWP9GdVIBqJS3lg92XAtHusmfhavS-9JQzTYHwN-FpM,628 +torch/include/ATen/ops/_linalg_eigh_meta_dispatch.h,sha256=SM0z3Y2bzH0ZK2zJ5PGsMd2eZGdFhBB6uTZc7TLGUnc,1172 +torch/include/ATen/ops/_linalg_eigh_native.h,sha256=5ES-iSmCAVZ6PzD_K16dLm7HSoIqFxdhitLtT6qNPlg,702 +torch/include/ATen/ops/_linalg_eigh_ops.h,sha256=pkYnMfRd5-Qw4_4f_qYgsS9teqctUA4EGXvvYjW9l7s,2257 +torch/include/ATen/ops/_linalg_eigvals.h,sha256=jKfRdAqvehg_-pE53I8YKT0Ls7UVrPeMvIgkytsGL_0,661 +torch/include/ATen/ops/_linalg_eigvals_cpu_dispatch.h,sha256=ahs5ImtGxpkCvrYzc7-Bkrcx6PevKHDj-ss2CbAbUYo,729 +torch/include/ATen/ops/_linalg_eigvals_cuda_dispatch.h,sha256=hxal6OnofLlMhm0HqtAAB1UZXKR33-k-YUuEEuheC6s,731 +torch/include/ATen/ops/_linalg_eigvals_native.h,sha256=vH1AKBFHlUHI_3TgsIgKNZk5qfjCET0Zs1RzMctJJ_0,496 +torch/include/ATen/ops/_linalg_eigvals_ops.h,sha256=PdtBApJhjUZrIh52plPIJ-1yFlXUDWo8hNoil8qnx30,994 +torch/include/ATen/ops/_linalg_slogdet.h,sha256=Dgr4ps5v-8U-we_OiNzIjgpck3163yiFLCszKqZ3cIA,1700 +torch/include/ATen/ops/_linalg_slogdet_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wcgAZj-HWA5gHoQ68MuZuTKVe5q7dp9hwCh49I4bIZ0,843 +torch/include/ATen/ops/_linalg_slogdet_cpu_dispatch.h,sha256=4N9OTDJhZ7h3C9z-yFcMzRp7EIjzFLS4Ts3ZSYPBoUk,1174 +torch/include/ATen/ops/_linalg_slogdet_cuda_dispatch.h,sha256=Vziuw0p8-GrayyOhYJuO32cm1K9kw9mAI_oYEsglTYc,1176 +torch/include/ATen/ops/_linalg_slogdet_meta.h,sha256=fVjnwYcm_1Nbnc8FQ1X7DAW5SnAUq0CT5Jwykzj9pbM,592 +torch/include/ATen/ops/_linalg_slogdet_meta_dispatch.h,sha256=FmgeiTaxUjXwftjSjyeE3c5K4OqVnSfBP76JSWevIlU,1176 +torch/include/ATen/ops/_linalg_slogdet_native.h,sha256=igG6aICu5NLX3AO1SSUPaJK5nS5kh9hEpFuLExvqo7I,712 +torch/include/ATen/ops/_linalg_slogdet_ops.h,sha256=0e-BklHQ0hJqPh-5Np4QYw0bGEdcu3CZKf91Tq66dQM,2268 +torch/include/ATen/ops/_linalg_solve_ex.h,sha256=zb2ecm6Y6rHQt9R46pmpxBLzQC9n8I0TRR3nPP4kSLE,2094 +torch/include/ATen/ops/_linalg_solve_ex_compositeexplicitautogradnonfunctional_dispatch.h,sha256=7aMKBqEyDg-ULzCyrUjFgil2tZkBabLavlFLluKS14Q,907 +torch/include/ATen/ops/_linalg_solve_ex_cpu_dispatch.h,sha256=H9U1RBF8PYQVjIfX9keD7WTTN2j35wNkaDmHUw7LY5k,1349 +torch/include/ATen/ops/_linalg_solve_ex_cuda_dispatch.h,sha256=TXUZXz65MCtetPkYashJ1pPS_P83PIKLrFa02jlCQQo,1351 +torch/include/ATen/ops/_linalg_solve_ex_meta.h,sha256=t7eg3P8F4qBGTR4qmBTM1pJ9AP9AoW7iP0SkZf3LAHs,645 +torch/include/ATen/ops/_linalg_solve_ex_meta_dispatch.h,sha256=oMY9eXNYuKwf9XDPLLl4Zfc1_TfIy9EARkNvlF_VNeI,1351 +torch/include/ATen/ops/_linalg_solve_ex_native.h,sha256=8W-fvX2UeN0gGukV_J5rA8ow8CS8raz7Ly3KfyTItkI,764 +torch/include/ATen/ops/_linalg_solve_ex_ops.h,sha256=WC2YIs_STko-sRoGV10LGn3a9bEljXUjg11ZtrJMG-E,2642 +torch/include/ATen/ops/_linalg_svd.h,sha256=YJzOhBbPSyJPymr8o_AeQ22PQvwx8kmULLpEvGk61DE,1948 +torch/include/ATen/ops/_linalg_svd_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WCaG-yOJsv28qTGbuWe1-D0vmPi8h456wXv3GreikBQ,929 +torch/include/ATen/ops/_linalg_svd_cpu_dispatch.h,sha256=aFSoDGdkivhY7kqLgq_lMFXnIEugUtYIumNbbtZh8QA,1340 +torch/include/ATen/ops/_linalg_svd_cuda_dispatch.h,sha256=TAgN0zlluDP39P0983qxzZDfS1jy5niWexGUdNE204g,1342 +torch/include/ATen/ops/_linalg_svd_meta.h,sha256=jdY3s3cqKeO0X5c9q7xrJLC1k8PmFRzC0nMCVM5Kq_k,665 +torch/include/ATen/ops/_linalg_svd_meta_dispatch.h,sha256=OQEWzRr5c1t21CytP1PmXmWNLKfWO_9Feljtz9kdFNk,1342 +torch/include/ATen/ops/_linalg_svd_native.h,sha256=aeQDy30IbNrSyYn0Yj2h_wjzBqRiOXHiNa2aF07FTWk,739 +torch/include/ATen/ops/_linalg_svd_ops.h,sha256=GlszUoOPGtkCrZrnZN20qGb6bfekkU1ZNUs3SJh7Ph0,2532 +torch/include/ATen/ops/_local_scalar_dense.h,sha256=DdcO0Khw6Jlu__viJvIGnTPwe7FsApsgevUdb8lo0Bg,677 +torch/include/ATen/ops/_local_scalar_dense_cpu_dispatch.h,sha256=c9MkDN0UKXdbmFUiSp4GZVB-Nyc3vhdcnyqdzMXMNQQ,733 +torch/include/ATen/ops/_local_scalar_dense_cuda_dispatch.h,sha256=cp6tgJTSD8E2i4UzEABPpSDGdkvPRsg1oZcx9vm4Jg4,735 +torch/include/ATen/ops/_local_scalar_dense_native.h,sha256=-nWt26y4yyc9YU411i3rydfN6DQf4dFWH9xQTujQOi8,576 +torch/include/ATen/ops/_local_scalar_dense_ops.h,sha256=FcgXW9a8nkC8olqEmPZiHTFfMa3WXg6vqU_-vKGkqlU,1006 +torch/include/ATen/ops/_log_softmax.h,sha256=CJ6jvgQqLzaWyor9rCDQqw9yZPPSn7ksnE7JaAGBzrs,1321 +torch/include/ATen/ops/_log_softmax_backward_data.h,sha256=FDKpvjhIOimU-xiq03p-BHFGo9PxF7F7LmaQetPJUx4,1704 +torch/include/ATen/ops/_log_softmax_backward_data_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AtFFuaP4HOc_1rtpvkM723kkaU5B1yfAqu2EOj0PkmU,885 +torch/include/ATen/ops/_log_softmax_backward_data_cpu_dispatch.h,sha256=mYIa9lFri9OvQmGnq99-HTj4im7kUI5dhJPXYwpE1_k,1162 +torch/include/ATen/ops/_log_softmax_backward_data_cuda_dispatch.h,sha256=GjAibzrSWBfnl8lSiuQL2H4R-yCcy6h0DXT4Nh5enoo,1164 +torch/include/ATen/ops/_log_softmax_backward_data_meta.h,sha256=NhUvV-kUjuxPYJei_jnyPQvgLHFUQUfLRu5fIwDMtnI,681 +torch/include/ATen/ops/_log_softmax_backward_data_meta_dispatch.h,sha256=sLpNSJ2Ybc0X-jH_quFwLcLultwvHom2FK5shNd-UKY,1164 +torch/include/ATen/ops/_log_softmax_backward_data_native.h,sha256=PVykKBY5ldqBEXYH70tN8KEw-ZAEvd-6Hkjozcr5vkE,995 +torch/include/ATen/ops/_log_softmax_backward_data_ops.h,sha256=86qKivw0cYa8pmpbeNz9BNX4insZ97nNza0SqSjCFy8,2210 +torch/include/ATen/ops/_log_softmax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=LxaA31JJPm_ixF6Tw79UyGIIPG9h_hIdErE2weJUVa8,829 +torch/include/ATen/ops/_log_softmax_cpu_dispatch.h,sha256=O-n0FakeBSZc3Y8saOWFIt8KD6Kojkuazkpi4Jud_YA,994 +torch/include/ATen/ops/_log_softmax_cuda_dispatch.h,sha256=UnBbvEEosdPCdx7aLI7F7OCUchy5zJcj4QY8drotYfU,996 +torch/include/ATen/ops/_log_softmax_meta.h,sha256=7oqrb0EZMUYJN-QxO3pWp889jDwMCgfiddeHAWTbbqk,625 +torch/include/ATen/ops/_log_softmax_meta_dispatch.h,sha256=c2gpZI3nk0ehsIuV7lXzzmjFWoy11iLxdBNpOyuhmg0,996 +torch/include/ATen/ops/_log_softmax_native.h,sha256=vsbahKlOM5zuq173UiF5izzXZisJc_IDV_jQ2oMiCWU,851 +torch/include/ATen/ops/_log_softmax_ops.h,sha256=D6Uwk9WUB4f0C-7X7weFFB2ZIq0Uf3046kDn7zoCRdk,1846 +torch/include/ATen/ops/_logcumsumexp.h,sha256=EfU_Z9EUrxkYQ4Pf8y1jdm1Dpoo4ePrG_EcR3HvqIQs,1166 +torch/include/ATen/ops/_logcumsumexp_cpu_dispatch.h,sha256=3_RT4yQXkssBg2jSX8My8v-w7W1nw8u5IlKnlRTZr4E,937 +torch/include/ATen/ops/_logcumsumexp_cuda_dispatch.h,sha256=-hPUr5qAWMLY_DdiE3GgQc9KoLXe_Y9C6zErSjkd76w,939 +torch/include/ATen/ops/_logcumsumexp_native.h,sha256=OwwkekXFgcQYcYmT2P6cUNN5R2nDwPYrxvn9q6vVaL4,795 +torch/include/ATen/ops/_logcumsumexp_ops.h,sha256=4W3vgFKwd3hDpl5zhyAnjH_6yRulZz_6cM2WTlao8Yw,1720 +torch/include/ATen/ops/_lstm_mps.h,sha256=RnPdAbGnJGxGZ-mph7CsML4Mal9C-5hL_3g-B5OOi4k,2932 +torch/include/ATen/ops/_lstm_mps_compositeexplicitautograd_dispatch.h,sha256=d3rxtRj5Uu19DNLP0ydQF_sE_4WeHWgt8uDi5NXDDRc,1515 +torch/include/ATen/ops/_lstm_mps_native.h,sha256=62ALUJlq-d1VSKRBTwHY_rq5UDhmq38stAtkgSddXDU,835 +torch/include/ATen/ops/_lstm_mps_ops.h,sha256=k81gsXLj4J1b67YeR21ZX06N3cdA4ndQZKpAFWQclD0,3492 +torch/include/ATen/ops/_lu_with_info.h,sha256=itphkYp_8ul0p17ZqvhW_d8gMao_NylVjT-nqNo46UY,825 +torch/include/ATen/ops/_lu_with_info_compositeimplicitautograd_dispatch.h,sha256=sRAzB0rszPzNHEMEv9NdUSVIxSYv4bElHoVGQBYcUlI,848 +torch/include/ATen/ops/_lu_with_info_native.h,sha256=ag9-o3oojMSKu0WK3r7AKbrj8LnOcuAf63UFqaE5BmM,571 +torch/include/ATen/ops/_lu_with_info_ops.h,sha256=zu1BH9zXaluUpzDMXzAf2hgotl9Ofyyqz_jGUxbLjYM,1244 +torch/include/ATen/ops/_make_dep_token.h,sha256=9YtiLVoD-a7WHn9TeeRm8RepMJ6j9oErA_qCPeFYViM,1517 +torch/include/ATen/ops/_make_dep_token_cpu_dispatch.h,sha256=b4zV2Q2duVsxeqWxLuarLTa0gzMfK15TdebVkedJgKM,1016 +torch/include/ATen/ops/_make_dep_token_native.h,sha256=XMOHIwDCZaRyTr8rp4AOZTwxhnacu-SpKRzuxOVhDSc,684 +torch/include/ATen/ops/_make_dep_token_ops.h,sha256=2uet9G9qONjKvrHH4krBbz8pLDbcUEcHC-8OsmEXvo0,1544 +torch/include/ATen/ops/_make_dual.h,sha256=OnoDSpNCIMLp1JXVMpxCE8cLft8LjNw0ohR042fbC8k,739 +torch/include/ATen/ops/_make_dual_compositeexplicitautograd_dispatch.h,sha256=dUzwG4r_3yFWRtDVJyJQlWdx6P5HvTvz9O85j_rL_U4,813 +torch/include/ATen/ops/_make_dual_copy.h,sha256=3BB9-Yhnt0x9wPD2c_htH4tLVlib_DP8akHV7eawcS0,1381 +torch/include/ATen/ops/_make_dual_copy_compositeexplicitautograd_dispatch.h,sha256=s2qGBFT6ci_9R47QLovAHM8R6eX2yhXn9cu5_TJxc_4,975 +torch/include/ATen/ops/_make_dual_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=IeETUThSE0D2ScOlD4cf8fmBAMM0y0FoRRNaJYbOIeE,844 +torch/include/ATen/ops/_make_dual_copy_native.h,sha256=2H9dQ8BCjd2UFengYWu4JGGLVrxny9Jp-ScXcWEz-ac,673 +torch/include/ATen/ops/_make_dual_copy_ops.h,sha256=04nfiTO1CiW0U9CcG4pJA9SERaZasw4asILvQWkd5o4,1940 +torch/include/ATen/ops/_make_dual_native.h,sha256=xxQ3PCpXs-PlCaKCIi7x2wCJoC1t1C0QZirikogxkec,536 +torch/include/ATen/ops/_make_dual_ops.h,sha256=KMyptSfhuGLlas0NPTBTG5vaNEXTkUyEl1caoTVCpdY,1133 +torch/include/ATen/ops/_make_per_channel_quantized_tensor.h,sha256=Ter5aL4v-1GNBqYYAvpbUmHCJzSxu4KiFrUJLKJZewY,1712 +torch/include/ATen/ops/_make_per_channel_quantized_tensor_compositeexplicitautograd_dispatch.h,sha256=FEGlc5nvemr85T-CaFu_DMbac_DhQT8iQ5g0Hy9ZAAo,1065 +torch/include/ATen/ops/_make_per_channel_quantized_tensor_cpu_dispatch.h,sha256=9ZBT-YbWqIEI0zydjeycTU-QoWWizgcOeFy81JXDIi8,819 +torch/include/ATen/ops/_make_per_channel_quantized_tensor_cuda_dispatch.h,sha256=H2NGxzzqFBHSFIQWI3aRzZFgN6Gs_0UPLrw5ubKD1FQ,821 +torch/include/ATen/ops/_make_per_channel_quantized_tensor_native.h,sha256=hq-iE3XQRAWU8tFsafP4X-y38aiLq8fM2mGj5OdtupM,923 +torch/include/ATen/ops/_make_per_channel_quantized_tensor_ops.h,sha256=aBKoImPtIquxOe4__xV_eteoMGYxtJ0IMqXJjazoJCU,2226 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor.h,sha256=ow2F9fNGWBG-THZqE12fSHEQoV8B-IpSzYC7F7m5tQg,1531 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor_compositeexplicitautograd_dispatch.h,sha256=9Gnh-sSsBW4Snm-r8gLBaIgG04QjaUUq5pmIr1MiIU0,989 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor_cpu_dispatch.h,sha256=r3dyXRudFPxxjUy-DpIMp4YQtG8-UgpIQqmc00_l-VE,781 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor_cuda_dispatch.h,sha256=rMFRFnBRUWdJ4cLq6caOYmQPsqAnfTFJ6XMaZh_Bsn8,783 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor_native.h,sha256=MCYrEP_Ir8jca8F9QgXzsvr2FIg_hZLUOeRYcXYYkJk,809 +torch/include/ATen/ops/_make_per_tensor_quantized_tensor_ops.h,sha256=MzIxYmEzrV9NPzVZiT9fzXVrVk-9g1ZJl603V-4oFZ8,1980 +torch/include/ATen/ops/_masked_scale.h,sha256=rTg1GvawR5Hk1sfVUMMz4O59a6FClrKhPcvnflnDtt0,1319 +torch/include/ATen/ops/_masked_scale_compositeexplicitautograd_dispatch.h,sha256=KEQnL0W77ie_hlZngDA2bjPtc_yfaoph4qvijwVrpQI,959 +torch/include/ATen/ops/_masked_scale_cuda_dispatch.h,sha256=WrK_ulgDWj0KicJyIPpMojZw3kJfFZlZ_aQF7VRvzio,768 +torch/include/ATen/ops/_masked_scale_native.h,sha256=Ah4eREl52L5Yzpp3YkZv8zVkNQ1zv3s48t4qB1dTxZo,661 +torch/include/ATen/ops/_masked_scale_ops.h,sha256=kiwo679qQTKCXis_PRQZA3ifx69Yxpf_GT_kW89rVos,1896 +torch/include/ATen/ops/_masked_softmax.h,sha256=zWc1BeW0LuAVG2sNHVlz_gUxZuzAMT0EjKKGvdW765Q,1631 +torch/include/ATen/ops/_masked_softmax_backward.h,sha256=jW4YqpC_uWL5xLhqYZzRQE6bSpSeays4vV1lJ5zsZ3g,1710 +torch/include/ATen/ops/_masked_softmax_backward_compositeexplicitautograd_dispatch.h,sha256=Hngq2fd3Vj7-IF4QXMRB_7IWhFFHD7Kc_7fvdmLSlrI,1090 +torch/include/ATen/ops/_masked_softmax_backward_cpu_dispatch.h,sha256=zi2h0OyYypnReBjUQWXr3Xwv8p_Ht2QSEw4MiSfzeHk,838 +torch/include/ATen/ops/_masked_softmax_backward_cuda_dispatch.h,sha256=UambvRMR1yd8RmVXO0hPdyXcNa4XTFK7R_EQ_jrKur8,840 +torch/include/ATen/ops/_masked_softmax_backward_native.h,sha256=vEZ13MTIvbnaEdW4jNtuWuyTi-JxLdZjqXu_RnkkZHU,967 +torch/include/ATen/ops/_masked_softmax_backward_ops.h,sha256=3pZrjTCmf3Ilh3HU80yrfsWixS5JPfVWwZHe0EjcfNU,2274 +torch/include/ATen/ops/_masked_softmax_compositeexplicitautograd_dispatch.h,sha256=bERTVBBd_S6MiI0KpNoj1jzWABoU_Mpfbxt4EwkVeBg,1085 +torch/include/ATen/ops/_masked_softmax_cpu_dispatch.h,sha256=V7OBKEdXLwwMZtkbNPmktTYOvP6nOvUzrvgfx9KeNdg,842 +torch/include/ATen/ops/_masked_softmax_cuda_dispatch.h,sha256=oQ8z98cyJIoEWtOI4DQlAkzLDzgui7rW2IXQWjn0oLs,844 +torch/include/ATen/ops/_masked_softmax_native.h,sha256=lBJhpRxkUINYv-mCihTiC3Db2-abvBChp8dg1_nLZCs,966 +torch/include/ATen/ops/_masked_softmax_ops.h,sha256=4G0BzX7d_SSEp9Otq2K5trJEHy4uv4YAviWIw0v0D-A,2226 +torch/include/ATen/ops/_mixed_dtypes_linear.h,sha256=bSIYGePTT0ljlCTAs9hSvM7TRkzgDX2O1PbMQZLkCCY,943 +torch/include/ATen/ops/_mixed_dtypes_linear_cuda_dispatch.h,sha256=47ejrs0ppXMxfLhCGPL_9J_k-m5IFqzz2tcfKrPy0t8,890 +torch/include/ATen/ops/_mixed_dtypes_linear_native.h,sha256=MvvrtQ9v8HsYRliObUkbJiVXsg8XHX50dOUTja_wrdM,655 +torch/include/ATen/ops/_mixed_dtypes_linear_ops.h,sha256=1Og-Cs-XwQz__PIgyMqAoa5zk_0dQAK0fhfBMk1WZiY,1467 +torch/include/ATen/ops/_mkldnn_reshape.h,sha256=E7DCkVCb9_7YZ1IeHG5jQwupi32E3kVG-Xf2WqGKvzM,1234 +torch/include/ATen/ops/_mkldnn_reshape_compositeexplicitautograd_dispatch.h,sha256=dQX0j3rjKvnDzOCC1NPH1K3CgBjUKOUpaN0ntQtYbt8,931 +torch/include/ATen/ops/_mkldnn_reshape_native.h,sha256=4GPrv7ZScQKt6mqCVAK2OQxP20OV9kUq8Z76k2f-wkk,628 +torch/include/ATen/ops/_mkldnn_reshape_ops.h,sha256=F3Bz_G6jLvzHEdxViSWLKnxMXOMmtxfIFJ_NhS94TrM,1796 +torch/include/ATen/ops/_mkldnn_transpose.h,sha256=Hff1VPLpDnJ_ZWyBbZUYgc3o1BqEfsa4K_H2saPL3w0,1540 +torch/include/ATen/ops/_mkldnn_transpose_compositeexplicitautograd_dispatch.h,sha256=VRU7fTRIckiRxHBpXF9VJAR_cicO-IggHcJ7AJF-8KY,945 +torch/include/ATen/ops/_mkldnn_transpose_meta_dispatch.h,sha256=5RLin9bnxhXbMZs2kIHb9u6EPyLgKDXE58wvn67EPO4,758 +torch/include/ATen/ops/_mkldnn_transpose_native.h,sha256=oiWtoiEsvQuKjbKKLd_pdi64wR-raDrcINwb5T2s-7I,731 +torch/include/ATen/ops/_mkldnn_transpose_ops.h,sha256=p86DkbsgE0NLNALqyoWXkXpl_V_bjT8tHTG1H4hFQps,2503 +torch/include/ATen/ops/_mps_convolution.h,sha256=tpezX_nAfVKBZdeh3vWf5RWX7pjPn1QSwdY4yrKG_5E,6849 +torch/include/ATen/ops/_mps_convolution_compositeexplicitautograd_dispatch.h,sha256=7idqzcf0DvPSF1mrV12DdliytNOyFZkdlTgf6L2UyVg,1742 +torch/include/ATen/ops/_mps_convolution_native.h,sha256=Wi5q_hNUDNS54DdKsstoL9UhyxROJ_6HNePxiP4XpOk,702 +torch/include/ATen/ops/_mps_convolution_ops.h,sha256=veZSL_l1o8eiwoNTAJnV2q96okz2tPiqwpeTv_LEQHk,2804 +torch/include/ATen/ops/_mps_convolution_transpose.h,sha256=Z3ShMOOlFHHLzBwvrxK8sb6dFe6bXtm_ZBfS2OLFhHQ,7429 +torch/include/ATen/ops/_mps_convolution_transpose_compositeexplicitautograd_dispatch.h,sha256=rVxcIdde4asxWUVBKPFStVeFH2z51EpsGPIQdBEkLkk,1758 +torch/include/ATen/ops/_mps_convolution_transpose_native.h,sha256=nYzwrD8qsOa1YH48h8JHs7Fsy8CRfx_SOyPdx-9LbLE,708 +torch/include/ATen/ops/_mps_convolution_transpose_ops.h,sha256=0IWuxCdcgOPIWZ5_S9QEbDJ0UFPNksbOHJZJDEYt5Ng,2842 +torch/include/ATen/ops/_native_batch_norm_legit.h,sha256=dCFfAOU8ss8fy7X6KNPCBnic2xyYzjUQtmsDl3NLpMQ,5335 +torch/include/ATen/ops/_native_batch_norm_legit_compositeexplicitautograd_dispatch.h,sha256=uxzHr_GUquAsvp5e-76aR77JvyTfIfotLgHAExUHU1U,1043 +torch/include/ATen/ops/_native_batch_norm_legit_cpu_dispatch.h,sha256=tjDVqLNl6EKteLcr4LTzphFi0opuML8uMbspAXJG4DI,2549 +torch/include/ATen/ops/_native_batch_norm_legit_cuda_dispatch.h,sha256=VUweH5j6YkA2unteUx2y7CvnEsvEl1p-3fop1jqdsLc,2551 +torch/include/ATen/ops/_native_batch_norm_legit_native.h,sha256=aRD2utO3N8kpKeQ2zpziAA8qgv7Xu14TbEQQzamE73o,3718 +torch/include/ATen/ops/_native_batch_norm_legit_no_training.h,sha256=MtWH5lebmpfh1YAy8AMNijsIGzT6_3YSE2lLRSQMHYE,2674 +torch/include/ATen/ops/_native_batch_norm_legit_no_training_compositeexplicitautograd_dispatch.h,sha256=cXcNjsMq5cUZ2tepgqLUfT5blC2tNqP8H4h5Eu2UoWc,1736 +torch/include/ATen/ops/_native_batch_norm_legit_no_training_native.h,sha256=fAYfzJ1c5TpuKTM14pK08q62syDFI7HsedSRxNfSwcM,1087 +torch/include/ATen/ops/_native_batch_norm_legit_no_training_ops.h,sha256=Q16kGvHLxyY2A5yzx6lopi90eUTdwA0EqkxixqOVvKU,3341 +torch/include/ATen/ops/_native_batch_norm_legit_ops.h,sha256=ZAhctpfkzweM4xtUMYE2i26V2hXGtI9VgHXhEYeudIw,7440 +torch/include/ATen/ops/_native_multi_head_attention.h,sha256=uinJ4bBDJ3et9fsyTvnvFghJFEmJ2328VHWUo-fRdgY,3561 +torch/include/ATen/ops/_native_multi_head_attention_compositeexplicitautograd_dispatch.h,sha256=B7OV5Kaa-JtBxfoHIvAPsqmF6im7HVmPqN_1e2h2oBs,1691 +torch/include/ATen/ops/_native_multi_head_attention_cpu_dispatch.h,sha256=9C7SnOPo69bg8TPX8EQx4ZKOJrTTaUbQ93F269sv6WQ,1123 +torch/include/ATen/ops/_native_multi_head_attention_cuda_dispatch.h,sha256=T9fzg31CmkI2flJwv1ITo--e176jhx9KJOCaBhvDe5s,1125 +torch/include/ATen/ops/_native_multi_head_attention_native.h,sha256=BsZAuyzzRp1K_7T8gBA12zsFNykwal-qVC6aNRBJMu0,1831 +torch/include/ATen/ops/_native_multi_head_attention_ops.h,sha256=9EjlOfqeZ1zKL3Q-2otFxEbeC_JA9vXJHRECMYPv87o,4164 +torch/include/ATen/ops/_neg_view.h,sha256=zPcLWN5iOOa_H0M48g4hq1kUISKbtA-AqZolL19ORpc,643 +torch/include/ATen/ops/_neg_view_compositeexplicitautograd_dispatch.h,sha256=M1LBYfnOR-NeAdjN0g-3Z1PP2J5xy8QCwzgJnh8Twm0,767 +torch/include/ATen/ops/_neg_view_copy.h,sha256=RzLbYW_65pv3f3Z_S0JxUXAKK3gCCdfLnVWAOSikel4,1095 +torch/include/ATen/ops/_neg_view_copy_compositeexplicitautograd_dispatch.h,sha256=ASqnPEJ4_R3Y7woBI7vW83fyQcJfOZjGn6mG0iVFnTU,883 +torch/include/ATen/ops/_neg_view_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=a95U0EWNIO2efX6AxunHMiwKTa6SHmgS38uM0pwG9l8,798 +torch/include/ATen/ops/_neg_view_copy_native.h,sha256=vncTdFHOrX2yAcuH3DXQ6puzWe4WzVU-pi66e3aW2PQ,581 +torch/include/ATen/ops/_neg_view_copy_ops.h,sha256=b8vs_burh7Y7y0jIQPKXH_Pf7DymrV8p4vY6GWdjju4,1638 +torch/include/ATen/ops/_neg_view_native.h,sha256=ws0s2HgWqUcIo24ru9xJJ1_S8QoEIKcVc2siqj7bFgQ,490 +torch/include/ATen/ops/_neg_view_ops.h,sha256=LxTKYLNKof5Ot0RyvvDGf267PKDzMEIro7VmBBEsjrc,982 +torch/include/ATen/ops/_nested_from_padded.h,sha256=uNFeEo1jX71vkqNYrd5u2t_bEiDM7_98Oy9PmIqDoKU,1724 +torch/include/ATen/ops/_nested_from_padded_and_nested_example.h,sha256=cLkmDql47gtTdR-hqX93xGeAPc9mitIuYDZGW7RnlJA,1539 +torch/include/ATen/ops/_nested_from_padded_and_nested_example_compositeexplicitautograd_dispatch.h,sha256=-w0gJjiXz5II1sm-XSjIYU3n0VhdNOcmkXWlUrTiYfg,997 +torch/include/ATen/ops/_nested_from_padded_and_nested_example_native.h,sha256=RYYCiQfye71kK4spwhonfCFg7CVjpCaPxmSc6Xpa-SA,700 +torch/include/ATen/ops/_nested_from_padded_and_nested_example_ops.h,sha256=Xi5kkRt-LGHt3s0xuzCqQ4-NYD08FEHjx67_L23CBKQ,1996 +torch/include/ATen/ops/_nested_from_padded_compositeexplicitautograd_dispatch.h,sha256=iyZC19WxsyK6vUVPUNFiBQ2rDZdnJgonSzSQJ0Hxzi0,1045 +torch/include/ATen/ops/_nested_from_padded_cpu_dispatch.h,sha256=OAoLdpriJVeuwnzqwpXMrE8fLxx6HpAH8vUv782fhEw,812 +torch/include/ATen/ops/_nested_from_padded_cuda_dispatch.h,sha256=9cdVyHehT1qyqarv5tZfyzmNRpSQ95czCGTgtTv-Lac,814 +torch/include/ATen/ops/_nested_from_padded_native.h,sha256=3HgZj_F9I9Vh9lVzbyD-7ejVGovl2os7Ly1pTXpwNtg,900 +torch/include/ATen/ops/_nested_from_padded_ops.h,sha256=XDZdgK3u5SZVTHGDYgO6FKIyeQKkFiCMoDSxbqdD5qo,2146 +torch/include/ATen/ops/_nested_get_jagged_dummy.h,sha256=KHf5sG2RsaTxEsaQ_WJaSwnfRnhG76rugbT1WM-RPDM,694 +torch/include/ATen/ops/_nested_get_jagged_dummy_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_get_jagged_dummy_ops.h,sha256=d6ppv9UDyoihfjYDJgey0nqcywdGwcyG3HTBWAeN-rM,1018 +torch/include/ATen/ops/_nested_get_lengths.h,sha256=hVXlldORL-JYQGntYLWVDhrKa98FBcFP7_WFUPn75Dg,677 +torch/include/ATen/ops/_nested_get_lengths_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_get_lengths_ops.h,sha256=H04XuEi51YAM_gZafPHlds38nPLJ_VJxNAlRadUmEqY,1006 +torch/include/ATen/ops/_nested_get_offsets.h,sha256=0XcVuJWATjXkPkpY92S3HPpndkVpUNcR3T7HoImfAXI,677 +torch/include/ATen/ops/_nested_get_offsets_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_get_offsets_ops.h,sha256=xyTS4TDic6UpR_urIWFePBOZD02296M5jlatzLEp0mE,1006 +torch/include/ATen/ops/_nested_get_ragged_idx.h,sha256=3_vbLBPb7U0NYXGtBTqb1EcvpPjttsnX0xkfcI88mMs,683 +torch/include/ATen/ops/_nested_get_ragged_idx_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_get_ragged_idx_ops.h,sha256=D5IjuVTGYILjwUYAMYDs4UAw03JGRAc17xwW3Q8J4oo,1003 +torch/include/ATen/ops/_nested_get_values.h,sha256=-xUeR0Zwcvdpi5SpUnz6Lt303z3HKLrIUf-KIQaiiLE,679 +torch/include/ATen/ops/_nested_get_values_copy.h,sha256=1iNi97559TStA3DD67UllJa3ktlRW_6jzGLSRYpkxYc,1185 +torch/include/ATen/ops/_nested_get_values_copy_compositeexplicitautograd_dispatch.h,sha256=-m7IQ0UzLJBaCPItHEj7dBrgWlmI3L1TzlrbBD5GpS8,901 +torch/include/ATen/ops/_nested_get_values_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=gZzOnSQPabcMIGSX-ic34UTH4orJSnpjCIZKMFnsI6A,807 +torch/include/ATen/ops/_nested_get_values_copy_native.h,sha256=B_S6uRLdcI0zIITZcakdmrbX607pNDg13-F4XiYMEws,599 +torch/include/ATen/ops/_nested_get_values_copy_ops.h,sha256=KpBKrCBbZQvrHULHPwKC76vv8cJT2JkPdowcn0PEZ7Q,1692 +torch/include/ATen/ops/_nested_get_values_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_get_values_ops.h,sha256=52O29ltjPDDWfv4AHkzdTKENRJJjs8XPNbnfQt8kMXo,1009 +torch/include/ATen/ops/_nested_select_backward.h,sha256=DiINwptiuqouBAd_yUzqnsN5HccdSrpJMSnFd-vWEqo,1790 +torch/include/ATen/ops/_nested_select_backward_native.h,sha256=pg4bkiQpX8NEZiPAHJ_XsCoeMtcX0bMlxq1R-F9-iEU,575 +torch/include/ATen/ops/_nested_select_backward_ops.h,sha256=S5FHnHcFt1uCEYVSQQo-QeQUkKGH6zCaU513tIN0qWI,1231 +torch/include/ATen/ops/_nested_sum_backward.h,sha256=YVDCJMIYJZsuGYVZWqx6YoZCABItGJtpme6bETr0K1E,821 +torch/include/ATen/ops/_nested_sum_backward_native.h,sha256=V0aF5zwQ6FIzISFJRmj8h9a1FiGFbSuOH8Obk72pWQU,579 +torch/include/ATen/ops/_nested_sum_backward_ops.h,sha256=BFhSx4Ovmf9K5dy_6AetM7Ln2umDVgORo5dtHO4mhyc,1242 +torch/include/ATen/ops/_nested_tensor_from_mask.h,sha256=BK6Jk8GeS8gk0mobdRsZfuBlSkjVtdlunCBU6LaAeGE,1463 +torch/include/ATen/ops/_nested_tensor_from_mask_compositeexplicitautograd_dispatch.h,sha256=yG2KKPVZNa9fSt_uN3Q8JAxmTJVGQS8kbasEZZzlBpQ,986 +torch/include/ATen/ops/_nested_tensor_from_mask_cpu_dispatch.h,sha256=_db9ON9nYCPA3jwClpy-5YbOfmtYTEEkRn36GqPzmt8,782 +torch/include/ATen/ops/_nested_tensor_from_mask_cuda_dispatch.h,sha256=Lo80aWfYrvo_W_UxTIsmQlilRAJhjJ4MtYUgGNrYvGg,784 +torch/include/ATen/ops/_nested_tensor_from_mask_left_aligned.h,sha256=atnGYNbO6LXA9yCyS8E0I2m7oG00cSudeds63WFW0OY,776 +torch/include/ATen/ops/_nested_tensor_from_mask_left_aligned_cpu_dispatch.h,sha256=W2lvBKb80HYKnPA1rppp6TyLBUs2PaJlfdr3lGx-8nM,767 +torch/include/ATen/ops/_nested_tensor_from_mask_left_aligned_cuda_dispatch.h,sha256=6HJcOCX2R8e251BiY7tEjWcmY0MlKF3gzG0bkLDFFUs,769 +torch/include/ATen/ops/_nested_tensor_from_mask_left_aligned_native.h,sha256=Zf7wYZcik-2vL6sWXcz1ul-mrqFq6LxNSV9ilkOvhgU,546 +torch/include/ATen/ops/_nested_tensor_from_mask_left_aligned_ops.h,sha256=fskCjiwr6ZrJbJbvYyAQJARxXDclxQ7tNeiCTWIJ8mc,1114 +torch/include/ATen/ops/_nested_tensor_from_mask_native.h,sha256=82Aid64peBjD8uaKreamut6Vr83VA9UAH5vX6_jeil8,696 +torch/include/ATen/ops/_nested_tensor_from_mask_ops.h,sha256=kGrYQ13lL4c6ycahfGqpkzXTVH8nb_NUOEzvMhzWq7I,1970 +torch/include/ATen/ops/_nested_tensor_from_tensor_list.h,sha256=WgYxYGCyfrbF0RoYzQCvqrQReRr166INhzJZsV0m3PY,2146 +torch/include/ATen/ops/_nested_tensor_from_tensor_list_compositeexplicitautograd_dispatch.h,sha256=-M8bxdGqbySe4QQgQeIV6qYMoDPDYSf4snw26fiUVLE,1499 +torch/include/ATen/ops/_nested_tensor_from_tensor_list_native.h,sha256=40slmYLXETEJUnG3vIsHdR_qNBNZU8WknXToUG1zCb0,933 +torch/include/ATen/ops/_nested_tensor_from_tensor_list_ops.h,sha256=DSYuqCVBO5Fx8p_bj8N5STHMFTR1rdGaY3r1JbMcjh0,2658 +torch/include/ATen/ops/_nested_tensor_size.h,sha256=DlW94LF4fs6HAXliz0v-HjkJoLUd_bxNUufikNcWPBg,971 +torch/include/ATen/ops/_nested_tensor_size_compositeexplicitautograd_dispatch.h,sha256=kRC_WD1a497H4IcJLxouqjtaNbuCBDtPtFPdTHzGW4s,893 +torch/include/ATen/ops/_nested_tensor_size_native.h,sha256=Nw4PyxYbdnU7gpDQGG87Q_ka01ik0XgCJAJNlKvvPFI,591 +torch/include/ATen/ops/_nested_tensor_size_ops.h,sha256=N0e7b-FuX3AVmKUQaF-eoIea6P99I3MfivX218mG02U,1668 +torch/include/ATen/ops/_nested_tensor_softmax_with_shape.h,sha256=WXdfqAOshhLlIyOLic6vN6PH4LrMooe6NX_BNhPGIlA,780 +torch/include/ATen/ops/_nested_tensor_softmax_with_shape_native.h,sha256=YGs-uSh_kwbjTLH_2G9iRXz71SIH9kzrXhb_r2SvWh8,642 +torch/include/ATen/ops/_nested_tensor_softmax_with_shape_ops.h,sha256=pgmHJWSXe6H82N_433XIqQjHdsjD46zHp5wGNRPc_-A,1134 +torch/include/ATen/ops/_nested_tensor_storage_offsets.h,sha256=wRhtK6EWdMP2nQr_TOjbsNq5jSKitNAHLZbflvbPIXs,1048 +torch/include/ATen/ops/_nested_tensor_storage_offsets_compositeexplicitautograd_dispatch.h,sha256=29pbwDFoil8GmlZjcmkDayjvoo123IQ8I5zz7AQWorU,915 +torch/include/ATen/ops/_nested_tensor_storage_offsets_native.h,sha256=tidIZ8O88e6RN2n_uYe61fW6DAi0mb6qLJcjkks_YZs,613 +torch/include/ATen/ops/_nested_tensor_storage_offsets_ops.h,sha256=UEGbDsgTcCfL6GfqKoN5AQW2k9ODDcvHnUawo58ElQ4,1734 +torch/include/ATen/ops/_nested_tensor_strides.h,sha256=hjBHua4wQa1VEKY-c5BhzdiHVPyhYl2c8iUY4vlED8k,992 +torch/include/ATen/ops/_nested_tensor_strides_compositeexplicitautograd_dispatch.h,sha256=PzjmLHBtpG65NfzI2svok35epdEUzO4yvuOd6FtBPCs,899 +torch/include/ATen/ops/_nested_tensor_strides_native.h,sha256=wRKAEVrFCRcklRByq72HsyiYrp-AYVvLENDX3zIL33I,597 +torch/include/ATen/ops/_nested_tensor_strides_ops.h,sha256=fm0XMcoz2T7XwsU_YkYhQxP9rX8OWlgiIUeJjzdxeyw,1686 +torch/include/ATen/ops/_nested_view_from_buffer.h,sha256=GoEwUANaE6r7_gxnzXhNVSAvDfjnBVKZpbiQ2W8x_so,895 +torch/include/ATen/ops/_nested_view_from_buffer_copy.h,sha256=Z7Y3vmLCKOx6WQyUeHlcbhm4EofHzL4ZQ_tFOtRUvl8,1821 +torch/include/ATen/ops/_nested_view_from_buffer_copy_compositeexplicitautograd_dispatch.h,sha256=4xsnR3nVM-AO3yBQJxO5gJu-n7NpWbvXfXhQrRUA1bQ,1103 +torch/include/ATen/ops/_nested_view_from_buffer_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=sDMSMr0Bk34tO9Euu5kbWD98NiTqd6GpQYg1pK7XslM,908 +torch/include/ATen/ops/_nested_view_from_buffer_copy_native.h,sha256=d3m1dCY6tXEQoJ8fj4xe1nkPoWdIimt4Dv5KCXsk_u0,801 +torch/include/ATen/ops/_nested_view_from_buffer_copy_ops.h,sha256=dV5tAfja_ifdiNuJ6IL4X2jFfDo24W1Vv0X2QPcqNeA,2346 +torch/include/ATen/ops/_nested_view_from_buffer_cpu_dispatch.h,sha256=ykOzV8r4xLOhbou-kyl1YCass5Dxc0xvdONF1Y1cxaQ,833 +torch/include/ATen/ops/_nested_view_from_buffer_cuda_dispatch.h,sha256=ReUTHWBjjs8oZU3EbRd9Zt8LWSjRiwdXJ0FcuUIN6Fc,835 +torch/include/ATen/ops/_nested_view_from_buffer_native.h,sha256=A88LjYSkrqOtT5d6EsX2NU0CKa-noUcPc7WSbnWtPrI,600 +torch/include/ATen/ops/_nested_view_from_buffer_ops.h,sha256=QsJRnkWw0C3PxPPslNngdMUrLmvbGaCVYWP94cghxaU,1336 +torch/include/ATen/ops/_nested_view_from_jagged.h,sha256=Fu9enrTIqYLfo6KH8d6HogXBNAm4sxceHbffiM8GprM,932 +torch/include/ATen/ops/_nested_view_from_jagged_copy.h,sha256=GExVovQpKaPDPBsTpeoWPGJhtYY95IESu7yrewNOW8k,1927 +torch/include/ATen/ops/_nested_view_from_jagged_copy_compositeexplicitautograd_dispatch.h,sha256=h7yXruYtQ5l78iMemnjdrzMzoKDHCsgG4js2Hsjjl7c,1152 +torch/include/ATen/ops/_nested_view_from_jagged_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=yRMZ2_80_E-Rqko6c-KiMUJVMRPQBPRsvmv48ORPDLQ,935 +torch/include/ATen/ops/_nested_view_from_jagged_copy_native.h,sha256=HDS36RpatJyz_Iivv5YywgUX8Ea6d4QuzluRbHoFfNQ,850 +torch/include/ATen/ops/_nested_view_from_jagged_copy_ops.h,sha256=ecoKOM6VoqyWB-x7abmPAZfnoG0hkTIxQ6c3JxJbddI,2504 +torch/include/ATen/ops/_nested_view_from_jagged_native.h,sha256=Fqex6swqpLSN4iDAv1Cm1tuUXPwETIS4_Ue3zNTFlLQ,433 +torch/include/ATen/ops/_nested_view_from_jagged_ops.h,sha256=T_zjjMoRHO-Eit_VnZ-DsW6eLZ-GvcOKakTjMlpWU3U,1415 +torch/include/ATen/ops/_new_zeros_with_same_feature_meta.h,sha256=PkqSLynwT__emuAe-FHwvXNB1o8E-FVBVA541lPkF0U,1664 +torch/include/ATen/ops/_new_zeros_with_same_feature_meta_compositeexplicitautograd_dispatch.h,sha256=9BENUHd0r_WwACCsYcRe3j9eT4RpazOGyJg7e6y4CQE,1171 +torch/include/ATen/ops/_new_zeros_with_same_feature_meta_native.h,sha256=jinVFQzGmGlS23zwMPrahFgZGd7jSsK2dwz7V5v2RG8,731 +torch/include/ATen/ops/_new_zeros_with_same_feature_meta_ops.h,sha256=QZLWHgKu7WVFhMHCeAaALHRg73MgPNcdlE8WopP434E,2115 +torch/include/ATen/ops/_nnpack_available.h,sha256=IzQEdWj7D2Dj2fmXQ9PPHfL5N0WoJz0D8CsmUdAhm5A,623 +torch/include/ATen/ops/_nnpack_available_compositeimplicitautograd_dispatch.h,sha256=2oNwH-lWZpytHSxG8tJmeiHlNX8f7_nzcktVxqFpigk,746 +torch/include/ATen/ops/_nnpack_available_native.h,sha256=BVDYTdGO4W1T_YcQrhw3DDqPdPykHcuarEnkbcWxQZc,469 +torch/include/ATen/ops/_nnpack_available_ops.h,sha256=AqNpeodVuXzOvhCL_Tys9n8jWONvxPkc8sabaL4NeYU,903 +torch/include/ATen/ops/_nnpack_spatial_convolution.h,sha256=NfaFKm3XArR7y3vZA2fFjNUzxvDrrqaUBiys8qMep1A,6184 +torch/include/ATen/ops/_nnpack_spatial_convolution_compositeexplicitautograd_dispatch.h,sha256=bg4cH5n9hBuWpQosIuFXbb4OOkdfgA5fXGh1ZlkCd9k,2039 +torch/include/ATen/ops/_nnpack_spatial_convolution_native.h,sha256=H8GL3xOUmNxpEHjoMnp-nAM1S7C2fuuWx3oszTetLzM,858 +torch/include/ATen/ops/_nnpack_spatial_convolution_ops.h,sha256=Oz4VkquCnXlJXy2r7E7-Gamg4P1OF8Vtfcku-rVBQaQ,2548 +torch/include/ATen/ops/_nnz.h,sha256=LWn480TfK72b394Qa060aPI6R_8NVSH8_3HsOqw67eg,489 +torch/include/ATen/ops/_nnz_native.h,sha256=2akqcH7EytHdq410MQEXZ3pZnzbq5T3JlZoDkgBItno,549 +torch/include/ATen/ops/_nnz_ops.h,sha256=VCACCHDc_7lTBH_RwpwRGj6WWH8_uWCER9G8NJ-xNkI,949 +torch/include/ATen/ops/_pack_padded_sequence.h,sha256=1G2tHvzvuU96Yf1cYXuiTuzlOJA2dhRoZJBrdObZ3UQ,1687 +torch/include/ATen/ops/_pack_padded_sequence_backward.h,sha256=8vkG9yFcrhqFFEGxfEKumPts_S9ITwWe_Q_3OW-X4IA,2075 +torch/include/ATen/ops/_pack_padded_sequence_backward_compositeimplicitautograd_dispatch.h,sha256=yCm5tI9c10nPNYM7zmL6r_Z3extYX9DLNCBxJd2RGCk,1033 +torch/include/ATen/ops/_pack_padded_sequence_backward_native.h,sha256=aSrawL7pTMd413p0T6aaLwshudsZNkiqMbP_9hhjxm0,600 +torch/include/ATen/ops/_pack_padded_sequence_backward_ops.h,sha256=-xoeEeHL5tk4U3lItTCSgOLvWzrMt8lLDaWiXh1nm68,1309 +torch/include/ATen/ops/_pack_padded_sequence_compositeexplicitautograd_dispatch.h,sha256=gzDQ_JNr51ONerugHWK1PYQoR8nBXA8Vw-6N6qwNkZc,1226 +torch/include/ATen/ops/_pack_padded_sequence_native.h,sha256=fU5w8JCz9blMT5tMalTGu8lx-dBTe2LUVQDs9Lx9Qyo,761 +torch/include/ATen/ops/_pack_padded_sequence_ops.h,sha256=jWi_ZqRCU_oXI8TdEcxE51hIw4gu8fbkitdz3glJ-VM,2242 +torch/include/ATen/ops/_pad_circular.h,sha256=kQMNJY942X_f7bKWCiArqXAa8imVxG6EDPUhLM57Szw,1438 +torch/include/ATen/ops/_pad_circular_compositeimplicitautograd_dispatch.h,sha256=QtTIA4I4E2HDYpcvc3WSw_4m_eBNk-ZlcRvGpsIt3Z0,885 +torch/include/ATen/ops/_pad_circular_native.h,sha256=D5ICJLx84gWSixTRlnt6Fo206aVJM5VzizuD2gM7sO0,526 +torch/include/ATen/ops/_pad_circular_ops.h,sha256=kicbZBO8hLj4RChZhnqXZG8ZG0AthdfW8Q-iRVq-AZI,1073 +torch/include/ATen/ops/_pad_enum.h,sha256=saEtgI1dgxEL71fAIeiU1lR0AExHTMXy7QgLokF7H6w,1728 +torch/include/ATen/ops/_pad_enum_compositeimplicitautograd_dispatch.h,sha256=2_n8ZZhJ70-ctVoRrRQ3J1lxyXjhLCAwWFeGPUucn30,989 +torch/include/ATen/ops/_pad_enum_native.h,sha256=HgE6DQ-50FhkcTDU-ntxXL7DcvT3YiJZB_BI7nqzWvQ,578 +torch/include/ATen/ops/_pad_enum_ops.h,sha256=6fEvR1yagJxSYMonAbb-mSVAIStlabkq7ooKyrDOFiE,1208 +torch/include/ATen/ops/_pad_packed_sequence.h,sha256=0AEIM-frg0HCeMYp1Bs6aPRqq82sgRI8ErMexACpOKo,955 +torch/include/ATen/ops/_pad_packed_sequence_compositeimplicitautograd_dispatch.h,sha256=9G5cHee8yRICx-GiKm1ArlAkMn5awQqQHH3xTIYGO1Y,909 +torch/include/ATen/ops/_pad_packed_sequence_native.h,sha256=D2drAnfTw5NiVY5gSyKAUB8H5pOzeHm_YlDYnyqkbB4,632 +torch/include/ATen/ops/_pad_packed_sequence_ops.h,sha256=pKEurR9nKg4d7M1QfVIh6GPGeeHoH9TuvOnLyDzghlQ,1439 +torch/include/ATen/ops/_pdist_backward.h,sha256=8LdUUUIgp7nwaxkq10CrCcZ6pdkD1szAFoZ54eyiEkk,1444 +torch/include/ATen/ops/_pdist_backward_compositeexplicitautograd_dispatch.h,sha256=H77KYk4noXgKrj5PWFq6QBNLGCcFXWJelo8ra8uHptk,1007 +torch/include/ATen/ops/_pdist_backward_cpu_dispatch.h,sha256=a0N0hDzke-MrHpOOshIQ0d5cDt3owOjIuhHw-GN33vw,790 +torch/include/ATen/ops/_pdist_backward_cuda_dispatch.h,sha256=X_MnIgPf0TDhjxhvF0WBUqtHBCudUXjakoj4wD_y5Cg,792 +torch/include/ATen/ops/_pdist_backward_native.h,sha256=_2QZ06KC2lQhgMvKGnXFtxcOd9CCkhcccJ-5yeLQ9e0,705 +torch/include/ATen/ops/_pdist_backward_ops.h,sha256=SXQPjx-HpAQqbw1Sr6Xln_nR2k42huYpzFBLyBvaREA,2056 +torch/include/ATen/ops/_pdist_forward.h,sha256=Xi_iccHOMjaiwUysbw4fSVM8jx-EJz6pMDvMW9DCz3Y,1171 +torch/include/ATen/ops/_pdist_forward_compositeexplicitautograd_dispatch.h,sha256=rF6HXPJB3pFFLxcZ0POzqR-3Qk0XtPoA7s2EsT8nhnY,905 +torch/include/ATen/ops/_pdist_forward_cpu_dispatch.h,sha256=u2s3-RvtmlNDg1NunA4fvlG4zmeIOUQmwDGt7ZLmWFE,740 +torch/include/ATen/ops/_pdist_forward_cuda_dispatch.h,sha256=cXE4nR7YrJpW095VS1G6BQV9PsdQs5CfvMYxIiuODws,742 +torch/include/ATen/ops/_pdist_forward_native.h,sha256=mOSqVHNlCVzTHgXPAKpeMN29hyuapKKi-fSCcws24V0,603 +torch/include/ATen/ops/_pdist_forward_ops.h,sha256=pxce3iLIcgoiuNMu7s6251eVgv3vl2z5Zq_C8rTbQ6s,1716 +torch/include/ATen/ops/_pin_memory.h,sha256=Hjt9TR6cZaagjm0pzRGSCLKJgaiuMo98E0_rkMan_rc,1280 +torch/include/ATen/ops/_pin_memory_compositeexplicitautograd_dispatch.h,sha256=4XShubxy2jc8v3MGWvkLlBy-xqA8-4q3MF0Bau317Gg,958 +torch/include/ATen/ops/_pin_memory_cuda_dispatch.h,sha256=TXJ41s1ow40ooPHlTheJOfRPQubd5yUqT7t2czO9G7E,774 +torch/include/ATen/ops/_pin_memory_native.h,sha256=BIE9XSgbwKLapOrYZS3fyPh26pJsDHBdsta9O8iwwK0,774 +torch/include/ATen/ops/_pin_memory_ops.h,sha256=7hDrrO6VdPtc76z7TIrPj-fXCXcDMVVdrduu7Rqnt4w,1852 +torch/include/ATen/ops/_prelu_kernel.h,sha256=nI592K8I1inKK2TrsJSTBcFa_mY6S7_2ZNMq1lvhlpU,703 +torch/include/ATen/ops/_prelu_kernel_backward.h,sha256=RXRQFcf5WImYL0se2GUiOHryv1b8MjkRtrlVf4LUwBg,839 +torch/include/ATen/ops/_prelu_kernel_backward_cpu_dispatch.h,sha256=BmPFx4Bemy8zHsuSquGti1mRPy_wR76KKnfI9ixHFtI,820 +torch/include/ATen/ops/_prelu_kernel_backward_cuda_dispatch.h,sha256=C0v-2Nhx_sYL7mHSbmw4Ct6IvA92oPLq_PHThlNzhsI,822 +torch/include/ATen/ops/_prelu_kernel_backward_native.h,sha256=tbUMWSGXPGxeSUqN0YRqoqU5x-iSxSaMUSbluEnnLr4,740 +torch/include/ATen/ops/_prelu_kernel_backward_ops.h,sha256=ufMctZ6ftVAsd7FCmLseylTL3Bf5ZEijlaFAwzIOpKo,1293 +torch/include/ATen/ops/_prelu_kernel_cpu_dispatch.h,sha256=qNj7fNqiaxYmsptuzl8BBDkus1kso9PrFRkXxQzW3Ec,754 +torch/include/ATen/ops/_prelu_kernel_cuda_dispatch.h,sha256=G5XP80uUHs7AlHaKFBER66SCi6zJG49wdu4v-Ki0Cdg,756 +torch/include/ATen/ops/_prelu_kernel_native.h,sha256=6JftrS3aeO22Wy9oJbFv7lM34vtODW_Dkk28-EG06Ec,710 +torch/include/ATen/ops/_prelu_kernel_ops.h,sha256=yCbGPMp2eSydUw8GfPb5b5vW8-0QFYKLHhOCgNy3j6A,1077 +torch/include/ATen/ops/_print.h,sha256=qzGwtW1yQmJLYugwPw6pevRmVtxYIOP-UiirLiLhHtg,601 +torch/include/ATen/ops/_print_compositeexplicitautograd_dispatch.h,sha256=7atO-mRnQLIHquBmE-UcnShUZsV7bnvNzSCjSMrp6GI,753 +torch/include/ATen/ops/_print_native.h,sha256=U-wCYPrIZhBwluzJmpZrBcnm8_1RjozZtiBO6rK8-Gk,476 +torch/include/ATen/ops/_print_ops.h,sha256=X-MsVZ18Zq1iOdG1u0YXDLhxWDS9IAmpZOIyhrlmk1s,927 +torch/include/ATen/ops/_propagate_xla_data.h,sha256=pFOSu9MY2ZBLGRAp0bl20neksbAGZrblLDDeapJbT1k,720 +torch/include/ATen/ops/_propagate_xla_data_compositeimplicitautograd_dispatch.h,sha256=wsy94CSqBa32NaPK8WoQg3q0WVuOMNaVcMfuKuYRY9Q,799 +torch/include/ATen/ops/_propagate_xla_data_native.h,sha256=2HbWgzCRY2jLKlEf-iGF0isMYKShNQpH3icWyXDIXkI,522 +torch/include/ATen/ops/_propagate_xla_data_ops.h,sha256=B_uvuKU3DFRCxjpkT8qnGoZBRukTJuuKy7v-eJuF2gU,1076 +torch/include/ATen/ops/_remove_batch_dim.h,sha256=2JKLyYPGNFlCwIOlUxkIamqXsC3g8kpFfWi3C1qqauQ,789 +torch/include/ATen/ops/_remove_batch_dim_compositeimplicitautograd_dispatch.h,sha256=phcRcWafxPoNscTpHVDZUj1YOsXcm1HtKDZHdvYyuVw,827 +torch/include/ATen/ops/_remove_batch_dim_native.h,sha256=IEYmq0SXZ14RZIFNvA_pZh-5TVRrUOer_LG63BRav7s,550 +torch/include/ATen/ops/_remove_batch_dim_ops.h,sha256=RX3K0HMRAGhyq93C0qHP_ql5HOmk8-z1s7gwyWlZqnI,1171 +torch/include/ATen/ops/_reshape_alias.h,sha256=DtcVUwk_4Lx-fWVFGmkp485nQN-yInjcVRPuA-IJV2o,1693 +torch/include/ATen/ops/_reshape_alias_copy.h,sha256=8cBKxrJJ1CwU8QGvEMb773ZgNo2NyH1YKzpyuY9MiX8,4578 +torch/include/ATen/ops/_reshape_alias_copy_compositeexplicitautograd_dispatch.h,sha256=cS5BkWxA2x-5DTjbVBtIdSrO1nVMxssyeFxVNZEaayg,1290 +torch/include/ATen/ops/_reshape_alias_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=_CSBaxNQzhLePnilQ9owacP8PBKrP2qlPbk9ef42CTg,977 +torch/include/ATen/ops/_reshape_alias_copy_native.h,sha256=dcmaofNPll9Zaqk6raoMZIv_WQbj0IAmPt6DCOjK3qg,713 +torch/include/ATen/ops/_reshape_alias_copy_ops.h,sha256=4bAH-cdxmTpFiJJR-Be1B09koxWg12wCwxp6bhooZ8Q,2032 +torch/include/ATen/ops/_reshape_alias_cpu_dispatch.h,sha256=DdyfDNAZC0K8R_mkZv6gxXYf_NssjGVkhuPVUVu-Kow,897 +torch/include/ATen/ops/_reshape_alias_cuda_dispatch.h,sha256=xhTPREjP6wX4Ihy0FeZZwGNFSeskRVikcUPOsVORxNY,899 +torch/include/ATen/ops/_reshape_alias_meta_dispatch.h,sha256=FASzp0vwnNXOpA0Ri3aEypREKxq7W3edJ0BO5rrsgNA,899 +torch/include/ATen/ops/_reshape_alias_native.h,sha256=3aXDqiuIOB1GjV_B9_sGkgTekPQBEJhYfjkFM3ghdTQ,541 +torch/include/ATen/ops/_reshape_alias_ops.h,sha256=CcPCVqxKPi5jd0k2-ENO4lz_kHZIIRtSpVc0sIrJ2Mo,1179 +torch/include/ATen/ops/_reshape_copy.h,sha256=ViFzzz5aFtPcae-J_Re5nZrvvReJ_GNEPYTwG4Ve-Mw,1448 +torch/include/ATen/ops/_reshape_copy_compositeexplicitautograd_dispatch.h,sha256=24ldQ0ihNYXysT-kNOVChfQn8sc24KGFnDWi92E0A4w,887 +torch/include/ATen/ops/_reshape_copy_native.h,sha256=IicW3MXPlL00Z3yfE-xlwf0-3lqSCbMjcgRS9ULht8o,527 +torch/include/ATen/ops/_reshape_copy_ops.h,sha256=_5un3lWGnPCTT2VrCGfJvitGEmv9UKjtjr39uQQG7PA,1076 +torch/include/ATen/ops/_reshape_from_tensor.h,sha256=X3rMKFm6Zd14K8whdOTD7YQ6crLysxGhFUsZQurDkOs,728 +torch/include/ATen/ops/_reshape_from_tensor_compositeimplicitautograd_dispatch.h,sha256=RL6sIJViMUBVUHxeYzsgX0UAk3FeW63g8nx9qKJL0CA,804 +torch/include/ATen/ops/_reshape_from_tensor_native.h,sha256=GZ0ny1_ohhbbIb2-48-gvHy9bptGvfGjlXD7-a2y3_Y,527 +torch/include/ATen/ops/_reshape_from_tensor_ops.h,sha256=DoR9ubRDjeBRnhLsIo1n2ettqAUZK3xK5j0nikqDo6M,1095 +torch/include/ATen/ops/_resize_output.h,sha256=BVOWr4NUtRanq3O6w1qp7Muq4gIxaM8Yy4hkuYxrvnE,5424 +torch/include/ATen/ops/_resize_output_compositeexplicitautograd_dispatch.h,sha256=pgloaeJYto62i30hAB1KicDJoHaVdx_jY5c_9VzXpgM,1507 +torch/include/ATen/ops/_resize_output_meta_dispatch.h,sha256=3vo-D6zoG0rJv3vIMlo7tbMGBATzWK6JzR0y_EI68h0,903 +torch/include/ATen/ops/_resize_output_native.h,sha256=6uaiZvHrvSozcoChz2bvXpbImcrEIXgX32qPfZ2a7KY,809 +torch/include/ATen/ops/_resize_output_ops.h,sha256=UIVJLS-6gBvsSbZarHKIN9wMz6QkcpBjdjhrAHJze-8,2725 +torch/include/ATen/ops/_rowwise_prune.h,sha256=6867I0oSG2hx7djfILe3W95vxrWE3JcoOji44Zkq-bs,846 +torch/include/ATen/ops/_rowwise_prune_compositeimplicitautograd_dispatch.h,sha256=TocpoDp_G7GtscYXJughflRSJ-y1EMt8bPcfnXSctAM,865 +torch/include/ATen/ops/_rowwise_prune_native.h,sha256=fUEvmQ_EtarUAK8EeZ_lnVK8I-D_lQAliECPxhXTwqs,588 +torch/include/ATen/ops/_rowwise_prune_ops.h,sha256=oAF6NIgt3drcgLhu6ke_wWCglBzZLoVtn6ywI3O4g_Y,1300 +torch/include/ATen/ops/_sample_dirichlet.h,sha256=b-pfIIPcKxbMJu2zf-0R-mwEXqkLqPBKO3phyPXvwuo,1385 +torch/include/ATen/ops/_sample_dirichlet_compositeexplicitautograd_dispatch.h,sha256=_jEfctglOn9h6nXl74yl80SApCGPaB3ifrGGzz53mPo,982 +torch/include/ATen/ops/_sample_dirichlet_cpu_dispatch.h,sha256=MXygKZihHA7YdjyjExBLOisZbpfBs9lFwTwqztr3UKo,784 +torch/include/ATen/ops/_sample_dirichlet_cuda_dispatch.h,sha256=ft_2KtHtoRXad_TQ0eiS0utLKci6XmnFjSoT7aJkDdI,786 +torch/include/ATen/ops/_sample_dirichlet_native.h,sha256=3rjL50WncbwHn-BEHcdtOWUEgy_m8aD6kkS-Da-ly8A,797 +torch/include/ATen/ops/_sample_dirichlet_ops.h,sha256=4SB-LI3JP1Dpm-5a1TR93GHHCg0jSJ7mLEghtK4eGIg,1930 +torch/include/ATen/ops/_saturate_weight_to_fp16.h,sha256=XEsg0PEWUiE0qynMu6WqFSAGPOFvLDmTFA2Hi5Cg0-A,703 +torch/include/ATen/ops/_saturate_weight_to_fp16_compositeimplicitautograd_dispatch.h,sha256=aftCRpQ_qbwk9mA6C4LJ68KjR2Tk5Zj4FopWMN246LA,784 +torch/include/ATen/ops/_saturate_weight_to_fp16_native.h,sha256=4xICEJqRAWfHfsU47FuMplmpFIdGxVKxlPqL0DujqNw,507 +torch/include/ATen/ops/_saturate_weight_to_fp16_ops.h,sha256=6FIvNi48DEMk98zoWUyuEDxpmq5We4DAX4CGQfMz17w,1027 +torch/include/ATen/ops/_scaled_dot_product_attention_math.h,sha256=06BDHseRxCs5AOYunMj68JiSf5XI4Th5dxjprG0yNwg,1218 +torch/include/ATen/ops/_scaled_dot_product_attention_math_compositeimplicitautograd_dispatch.h,sha256=iGGpWzgLPtkX51C4Jwm5_UcWSK88e2ZB2ed6oHwRWJE,1053 +torch/include/ATen/ops/_scaled_dot_product_attention_math_native.h,sha256=qkhHTfjjjboRTnJsjBkNuCsjT3EKGGBp7MJKboyxS3o,776 +torch/include/ATen/ops/_scaled_dot_product_attention_math_ops.h,sha256=JnJYvfood5Q6c1tWyQWa3-XQWbPWiwRCDfjfTxMTGbs,1840 +torch/include/ATen/ops/_scaled_dot_product_cudnn_attention.h,sha256=IQdZ0njSWIXrE7KCIJRqxVoE2LVHFljAH1uqfdCfWz4,1207 +torch/include/ATen/ops/_scaled_dot_product_cudnn_attention_cuda_dispatch.h,sha256=AXaSqXInwBWEUr6qmKnRKfZ9RIYjw3FMXmiuEDn7BQE,965 +torch/include/ATen/ops/_scaled_dot_product_cudnn_attention_native.h,sha256=_oYhBoNkWJIotsCdrBAUGEVAIbtHIq-Jo6wgvG57ykU,735 +torch/include/ATen/ops/_scaled_dot_product_cudnn_attention_ops.h,sha256=ntoxPmBkSGFT-3o6Uit6iJ1NQ8O4niGUNSkxW5Ha5QE,1745 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention.h,sha256=38K5Xz1M68CQk5aXKqmCNvYtpPT3Ec4Z0i8vBeeDUl8,1290 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_backward.h,sha256=9UkQMa6_LJ5OlLuRf90zo3BEemImCifALK5Mc5n2xQQ,1563 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_backward_cuda_dispatch.h,sha256=lFRw9YMwmzkIhjUG-kvDC4FYKP7qGVI0gJjHVRPcKgY,1162 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_backward_native.h,sha256=B8t4oBoO7-T7-ceiWIuwNHjgIbiiv3GbxnLT3tcRuAU,932 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_backward_ops.h,sha256=90TKwjkzj3XnAiHMysD0Xi9R3h_PttUwKpYsR6aFU48,2364 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_cuda_dispatch.h,sha256=gtKSydEja4Yuc3blJpjQN5BCPrYV55D9ZsTaQISdjkg,1009 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_native.h,sha256=Ov1btLNI47hn0YEA3Cs2jhBkXJzwzKFlsxClEb17qFA,1138 +torch/include/ATen/ops/_scaled_dot_product_efficient_attention_ops.h,sha256=cuwhsZ_TePYbw_Yibavvkbh8EwZIrcHqsHwtR11Sa5U,1899 +torch/include/ATen/ops/_scaled_dot_product_flash_attention.h,sha256=Edr8enqp7kTc05ai-zYdmsx7EISUe0yRhD0Y6b-A4WQ,1352 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_backward.h,sha256=drvCP7tD4rtatjck72EPmnPLJRyOhF3d1caFZMO6yuM,4307 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_backward_cuda_dispatch.h,sha256=18iaNuuptbpI9IhVVg-OQ2FakOm5xHINCNnDTa9VcK8,1671 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_backward_native.h,sha256=7lhu9_1-BonGV6wIn8u-t1m8uj2v7HN5ttoaBRvlT0c,1433 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_backward_ops.h,sha256=XfGgdX48g_uzaJFUqlzErr-55gSn09U3-uU1FMbgpzc,2438 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_cuda_dispatch.h,sha256=RkkyaWBC9gpCvUfn1evEfaaRQyDBUWp5Eaokoq3vqtw,1022 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu.h,sha256=BILT9-hJxNpNb4TTRbZnBfqJYPnKKYLvIfzj69JfRUQ,1179 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_backward.h,sha256=s-qvQDNU7APTN2KXEW72rClSyelSKGp-HwlN8poa8CM,1384 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_backward_cpu_dispatch.h,sha256=cM3y95d9dlu8k0035QtLjFqyFRZClfNx-QHkI4YE-t8,1060 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_backward_native.h,sha256=JBwT8_hoiZu-YrQYO8k2bzxq3livKgqseAUOOXywCn8,823 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_backward_ops.h,sha256=Pouj_-NI3yRSEDgmi2cV2FuahEZTa7RuUx-R4h1OA2g,2071 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_cpu_dispatch.h,sha256=Kebf7a9ylngmuqhrgmMNU8bI5GGX23rpf6VvOfWE3gE,967 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_native.h,sha256=HN5b2j7sKKakAcPzYngzf31dyXe62LKsJ2EmobLuNro,730 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_for_cpu_ops.h,sha256=mXSJ8-usV1Pc5jqC9E9u_KJo-KLUXO3haxG3XdF7sM8,1726 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_native.h,sha256=d9-zoo-jEMRT1PhCZN1fF64dBcY5glLr5GIuzUINfsk,1164 +torch/include/ATen/ops/_scaled_dot_product_flash_attention_ops.h,sha256=3cYy95fphMZyUf0Dm2PsqDCKC2ME09Vp16uiqEbSs30,2004 +torch/include/ATen/ops/_scaled_mm.h,sha256=rvD73-DM7COb89f9H7_BziBqGfAOEFi9n9-rjVui4RY,2815 +torch/include/ATen/ops/_scaled_mm_cuda_dispatch.h,sha256=WhNenhrgHYReDsdQIJLawblBaCYCt_F7ypHprLDhU7E,1861 +torch/include/ATen/ops/_scaled_mm_native.h,sha256=7CTkInPXb5WDpRgBjBgYiS-ZtdFCmqBxhb8mV6Sy76k,1211 +torch/include/ATen/ops/_scaled_mm_ops.h,sha256=YrnVgaYB-IPq6c8U7v7E7ag1Q6mUqsT9jm-zjCWSCgI,3632 +torch/include/ATen/ops/_segment_reduce_backward.h,sha256=YAfcnh4svT2Ha9bv2uTS6hk7vaENDSXPKP2YAkHm1cI,2419 +torch/include/ATen/ops/_segment_reduce_backward_compositeexplicitautograd_dispatch.h,sha256=PnnATc5Y6DSG1PxLQ8QubpLWvitWaya7J-ACjv4KIXM,1364 +torch/include/ATen/ops/_segment_reduce_backward_cpu_dispatch.h,sha256=hFwFklH0wWgmcn_hf_qSa-Sm3TzqZKwQ7dx8xR1tBuo,979 +torch/include/ATen/ops/_segment_reduce_backward_cuda_dispatch.h,sha256=7LfuZvEYFY-UWaHGA7pcvPtM_cZeJcQgLVEiIPbYFrk,981 +torch/include/ATen/ops/_segment_reduce_backward_native.h,sha256=lvTJjWhXpDeMwOF6aicsap_4WP5jCkDx-NujbUsEEHI,1069 +torch/include/ATen/ops/_segment_reduce_backward_ops.h,sha256=GUAWVtaqUIVJi5g3jJIKA_yksVykiVkbcfo3Fzqi1Bk,3161 +torch/include/ATen/ops/_shape_as_tensor.h,sha256=eviFT_z4AXVcqab9tegbu-aw3l5FQiokZUG3Zn6MzUU,665 +torch/include/ATen/ops/_shape_as_tensor_compositeimplicitautograd_dispatch.h,sha256=ZCQ-FBAebbCO5_RewQrirlmsICZLi6el5fA75zifXcI,774 +torch/include/ATen/ops/_shape_as_tensor_native.h,sha256=yen5tCjm_NwXmPQbi0-X8gwL9HIUvHEns2-IN_bbqn0,497 +torch/include/ATen/ops/_shape_as_tensor_ops.h,sha256=MTjt7AEYQ4xtinWUpB_wBpW6qk80bI42y6xbnrq7i78,997 +torch/include/ATen/ops/_slow_conv2d_backward.h,sha256=NaYFQy9UJxQnbATJOePh2h1rf1PQsxwlQIdLQ0w4Ia4,14568 +torch/include/ATen/ops/_slow_conv2d_backward_compositeexplicitautograd_dispatch.h,sha256=SPKoxCWOVsZtWFFMDNgntymGWajJRm4vycwcgTfdJs4,2122 +torch/include/ATen/ops/_slow_conv2d_backward_cpu_dispatch.h,sha256=AjxOTWVSuWk-ZehnE6JzFVMUWalOi1RJP6rKX1Axzn0,2585 +torch/include/ATen/ops/_slow_conv2d_backward_cuda_dispatch.h,sha256=u2bRQ_iKJPWpwOMyyxNezBlCRy4rO7Stu-GtiQU_Jyo,2587 +torch/include/ATen/ops/_slow_conv2d_backward_native.h,sha256=jEQpaoxvJbI_a9VUfrXgqsLD4j1beoHXe3SfYlPNGCU,2027 +torch/include/ATen/ops/_slow_conv2d_backward_ops.h,sha256=8TOYVtPJbXVOpEFuXid5R3AnDHnMtlaEDOrLAPRIdc4,4937 +torch/include/ATen/ops/_slow_conv2d_forward.h,sha256=vstRNLoSK-fbw5Bm8LCmHaHzlZ7g4SrQa8ZOPRd-Xxw,6775 +torch/include/ATen/ops/_slow_conv2d_forward_cpu_dispatch.h,sha256=krwJi57TnQhyDm1ElSJngU2p9ayYyrFYbl-w1RL7oRA,2111 +torch/include/ATen/ops/_slow_conv2d_forward_cuda_dispatch.h,sha256=alskK2_M2gzTC7_5qnqmr_9IecBIPY5YiB7gW9iVd_M,2113 +torch/include/ATen/ops/_slow_conv2d_forward_native.h,sha256=mdJGvmYtNzVPfQ3fHgpZkPVUWurcDlW3jjaqUphnrFo,1353 +torch/include/ATen/ops/_slow_conv2d_forward_ops.h,sha256=Z3G800PR7KkdRc3Dech830MY9xK-ZBkuEXq1PC5UQbs,2734 +torch/include/ATen/ops/_sobol_engine_draw.h,sha256=_OdPFyazAEyU3cNYndV4tw4tAEtkXmi0mgOdnBKhzxs,959 +torch/include/ATen/ops/_sobol_engine_draw_compositeimplicitautograd_dispatch.h,sha256=uzHbjRnAIojSZUKKAhpiQIH6WKS4GfZzjOe1PaNVl6g,923 +torch/include/ATen/ops/_sobol_engine_draw_native.h,sha256=vRXy3Dt92XZk6xhD_XHbkAHlGneL9VegIK7TyeFtf90,646 +torch/include/ATen/ops/_sobol_engine_draw_ops.h,sha256=8srPDoxI3fCnmj2rde4DyZDvT2A72jvjxiwtTPcFuoA,1490 +torch/include/ATen/ops/_sobol_engine_ff.h,sha256=gP-kLzC06VGS3XS4a__CPjLzz7jhuZ5gTayXlcboXAE,857 +torch/include/ATen/ops/_sobol_engine_ff_compositeimplicitautograd_dispatch.h,sha256=oN69ykgERDPFAUqxKcMz4J14glgmlVnjpQWGvxPGh_4,855 +torch/include/ATen/ops/_sobol_engine_ff_native.h,sha256=4zNg-dPfX7jDFBJDdD82_EwaF-gDVhESAr2sueiTbMA,578 +torch/include/ATen/ops/_sobol_engine_ff_ops.h,sha256=4Ui3Ic9FO7YLzt1FZl47xwuaKAs9U04LLKOqrF3Gw00,1271 +torch/include/ATen/ops/_sobol_engine_initialize_state.h,sha256=gKjzwqS7GniqzIqZ6zUDXhxyWPxf3A7IeyQrXpj39dE,773 +torch/include/ATen/ops/_sobol_engine_initialize_state_compositeimplicitautograd_dispatch.h,sha256=Xkt5-X095rrIFIOK6rbCCOYagoBCA8oLmeWBdE7V4pk,804 +torch/include/ATen/ops/_sobol_engine_initialize_state_native.h,sha256=lvJzk2xBEoysjORflAGqoloomHHnvxNGmNtXDAFvkJo,527 +torch/include/ATen/ops/_sobol_engine_initialize_state_ops.h,sha256=RYq71Hx9FTazydpyrW2RPjx84ODjCop9YmuRL24w2bY,1100 +torch/include/ATen/ops/_sobol_engine_scramble.h,sha256=5NLws6Fyo9WMSVG0wbkXvUeBVUJpONcYr1aiQdTeqG4,782 +torch/include/ATen/ops/_sobol_engine_scramble_compositeimplicitautograd_dispatch.h,sha256=rf2qEeQ3UScwdPD7bdd8jhU5hhrwTb6YCANYoqMjd-k,820 +torch/include/ATen/ops/_sobol_engine_scramble_native.h,sha256=xv4-xFTggh2pe21QTRybLwFTELlj7cW4C_s1L7nOjEI,543 +torch/include/ATen/ops/_sobol_engine_scramble_ops.h,sha256=EFxQLWKJyu27flsfj_6G8hTct9by5Xi3TD9HtI3D0yQ,1156 +torch/include/ATen/ops/_softmax.h,sha256=kjGt5EqhvjT09scUfxuKt1limG27eHbwfA6-2Iy9jK0,1281 +torch/include/ATen/ops/_softmax_backward_data.h,sha256=QyplgexXt3dAOa4T6sB8tIUKnDUGNoYTuWt6CZdrbZ4,1706 +torch/include/ATen/ops/_softmax_backward_data_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AyTIfPXb_mSBKwj7rFSev5REwPB0SZxUkUW7o3riwlk,881 +torch/include/ATen/ops/_softmax_backward_data_cpu_dispatch.h,sha256=bElt_gfrs4qXOP8a_fQJ2vrYFtcco7EU_uwwgp1AN_0,1164 +torch/include/ATen/ops/_softmax_backward_data_cuda_dispatch.h,sha256=qv7BKWg1r1FXzxI1ltZC4siFS9LyiZafQ9lnvAHrxYA,1166 +torch/include/ATen/ops/_softmax_backward_data_meta.h,sha256=z5WLMhV5AA6XMJwRLuTLzWERcBIyb7PlDHy0A34OHwg,677 +torch/include/ATen/ops/_softmax_backward_data_meta_dispatch.h,sha256=El7vZpGqS_wLRRTlcPi2juas9dtwWg-UeE3eBhCmWFY,1166 +torch/include/ATen/ops/_softmax_backward_data_native.h,sha256=sljuEeVlbm-dUj7_eHHQvF7fAkPIDoKIHeRglOupoSs,1135 +torch/include/ATen/ops/_softmax_backward_data_ops.h,sha256=g5SVE3Z0GLVsihyY_oawrCYlh7GOuef8H8lAU6ctvtc,2207 +torch/include/ATen/ops/_softmax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=svyT6QaGMAIAHozmiEuUso5WkiZPc4FTRse5XhmOqPA,825 +torch/include/ATen/ops/_softmax_cpu_dispatch.h,sha256=pmc7Nl8jx12s3tJH_yPd2ZxcCI_GDVgzFOzRVvOGw7k,982 +torch/include/ATen/ops/_softmax_cuda_dispatch.h,sha256=C-jhRtEUJPSJMeiOF0vP8O-Mx8bhnNiaN0ZEFILHwTA,984 +torch/include/ATen/ops/_softmax_meta.h,sha256=qcgKPq4WCsWIzxINhRZYDiCQQR_QZPH28SDlA-9Jy7g,621 +torch/include/ATen/ops/_softmax_meta_dispatch.h,sha256=JpHotH4q9vQmja9hgTRK7XskfqU2peQ5fD9qgtcv1qQ,984 +torch/include/ATen/ops/_softmax_native.h,sha256=311Uhvit6RGm_hs5m0D50ySLDVY7rwPZNrhwMVA2skI,1021 +torch/include/ATen/ops/_softmax_ops.h,sha256=OmOJrA5MyYVDcJZFZDYWhgWI2kOQbg-GcVyfKbKvoZI,1822 +torch/include/ATen/ops/_sparse_addmm.h,sha256=ckfgc9ZJtmt6ENs59U9yXidsgNXxxbljfYT0-FK-c34,1645 +torch/include/ATen/ops/_sparse_addmm_compositeexplicitautograd_dispatch.h,sha256=QTGVUSqtiKwq3EVtbVY1kvPMYFYVCGez-gZW9UNsSG0,1253 +torch/include/ATen/ops/_sparse_addmm_native.h,sha256=nBd2-0wbMblMg2wn9P33kN_3mNcN1YhS5sotTbWz0BI,785 +torch/include/ATen/ops/_sparse_addmm_ops.h,sha256=FGI6RwiC8BmY_a7bayKcVGivudFATVukCgmzMJzuWb8,2313 +torch/include/ATen/ops/_sparse_broadcast_to.h,sha256=Wi9nDDQBHgjGDBxBh4j8AmRTh2PhB2P-2ysE9EY4DdI,727 +torch/include/ATen/ops/_sparse_broadcast_to_copy.h,sha256=YsI0lbpG4aPhlX1KCZiuSvq2YX-IYqXKoAnNLpv2frw,1325 +torch/include/ATen/ops/_sparse_broadcast_to_copy_compositeexplicitautograd_dispatch.h,sha256=eDKmw089UZ0MxTEbTSAtd2bW_WIkcDgTiw7e_C3494E,949 +torch/include/ATen/ops/_sparse_broadcast_to_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nTpWGiCH7KauFWBEVOW2YlzqFoh_qmG9LFcrWJnAEKw,831 +torch/include/ATen/ops/_sparse_broadcast_to_copy_native.h,sha256=xRBAr5rlSzBPMcU1yFkpUjPhNbSzy-tpp3Tfy8bDrQI,647 +torch/include/ATen/ops/_sparse_broadcast_to_copy_ops.h,sha256=g41nhOFl2xN1NAdJ-Lvj-Pgusd9KwXDV04z-lMMW1fk,1850 +torch/include/ATen/ops/_sparse_broadcast_to_native.h,sha256=YbgYJlq3V9GqzobYcKRpMdNznIxvouyvUKpX4eQWyyM,522 +torch/include/ATen/ops/_sparse_broadcast_to_ops.h,sha256=dm9h_3E1RrC5Ije1Bf15fAro6-BsqvY_kL3Wp3pf584,1088 +torch/include/ATen/ops/_sparse_bsc_tensor_unsafe.h,sha256=sOg23SqFZ9eaovS5x2O-6zme7JE2VZI-5ZglBemCAhM,1760 +torch/include/ATen/ops/_sparse_bsc_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=HrE28e_LMUJjKORfkqtcdQRZa3lVmMDcA5s_WANlnlc,1201 +torch/include/ATen/ops/_sparse_bsc_tensor_unsafe_native.h,sha256=h3Z5A_kYg3R1Yj7BfamKKLoNAul-6jH3gSdphCIbQ5Y,744 +torch/include/ATen/ops/_sparse_bsc_tensor_unsafe_ops.h,sha256=x7rA9OnghSgI0UfDccH_BrdwZBmSPqiOtqF9dJoMOuA,1786 +torch/include/ATen/ops/_sparse_bsr_tensor_unsafe.h,sha256=VH4c_GDmGK8Zenm_sl4MXG5IvKd1AY-4QhQJ9CRXNQE,1760 +torch/include/ATen/ops/_sparse_bsr_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=6JmTuFY2m01iGA9O7P80xDZu05jBdNxd-Oz_zxaYVj8,1201 +torch/include/ATen/ops/_sparse_bsr_tensor_unsafe_native.h,sha256=vPVJWbDn6aTcPViqF8nu0jYewzqdbJv1d0_no01P6ns,744 +torch/include/ATen/ops/_sparse_bsr_tensor_unsafe_ops.h,sha256=lw1cBnFHeaPfxQ1ZUFYjylahqUa_5XVcbqtr6tPV8ys,1786 +torch/include/ATen/ops/_sparse_compressed_tensor_unsafe.h,sha256=CGvy59KWmV98x7SGpirkMPyZSTFIZ-AdZcz5YOAFakw,5570 +torch/include/ATen/ops/_sparse_compressed_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=2MYe3EsmHwvuDXLvDvoQU-1BjyPFEalZKKTAkwQlIu4,1774 +torch/include/ATen/ops/_sparse_compressed_tensor_unsafe_native.h,sha256=VD-55KoDTlkagzULXdOPtgzPssKQMDIzcwqdA6YzT18,770 +torch/include/ATen/ops/_sparse_compressed_tensor_unsafe_ops.h,sha256=_S3X01y37k4zQueu12WQuKNQXBOwTR0MrBUUaxWP_i0,1846 +torch/include/ATen/ops/_sparse_coo_tensor_unsafe.h,sha256=ixae2f9UOqlij5iTBsbVpXP9r5oc_nDFXSR4EJbASj0,5259 +torch/include/ATen/ops/_sparse_coo_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=VKVtxLd67-_0GEsCzHMfelagQXh302qHmVj0QHgB1Z4,1728 +torch/include/ATen/ops/_sparse_coo_tensor_unsafe_native.h,sha256=QVmrIAZtkW0kFLsxL_JTRyYMs68g2Zk86t5LauewqI8,765 +torch/include/ATen/ops/_sparse_coo_tensor_unsafe_ops.h,sha256=4RycN2hTcKpS8vEm9TmGvh9eashMMA_3L_N55-EosPM,1796 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims.h,sha256=27h0s-3zbw1GrQDu1b_cyMWjev06iHccRDGOGp1I4UM,2300 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_and_tensors.h,sha256=TydaLhtzTI5HTDul60ybur7hwV2PoASuLtdobJiuHOo,10560 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_compositeexplicitautograd_dispatch.h,sha256=JO_hNfqCx8kC66q2JSm7fozZjviKdlWvjn0Fj91Jdj0,1708 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_meta_dispatch.h,sha256=KIQ8yXPha6LGHsBQ-Ivesr2ZPXilI8jwEXurI2BHdW8,1896 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_native.h,sha256=bmjB_HjM_i0CZ5-62uKgLo1lDuDx2mjfoMeb_QDhrIE,1058 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_ops.h,sha256=wtvAFR2GKqlPycRZVzSGTJyqPL4XXECkr3fydt5k1jE,3121 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_compositeexplicitautograd_dispatch.h,sha256=3_qpd3dRzrUGpaNZVexCFanmNev_Jt5MHsTFkOIbGPc,983 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_meta_dispatch.h,sha256=tOmaxdq05SCO2uZFKgDE1sLy6VOMjKnvdgEpbSjKjYI,1056 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_native.h,sha256=qI4Qsc9A3OZRiSM7DrA8cV8_p_-_e9ais96Dt5Ix3kg,822 +torch/include/ATen/ops/_sparse_coo_tensor_with_dims_ops.h,sha256=GmunWb3GSXgBzT2b7bupKfir02JVUjzD_pjqEoab8Rs,2429 +torch/include/ATen/ops/_sparse_csc_tensor_unsafe.h,sha256=dzetvXMdfPmox3hB7JaE1o2RK8zMuLKePJ-FLpQ9T_g,1760 +torch/include/ATen/ops/_sparse_csc_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=pP7PL_oswFB3kTTCmc5X5EdjEsl28m--n7T5P6iEVZU,1201 +torch/include/ATen/ops/_sparse_csc_tensor_unsafe_native.h,sha256=SwBjJ2wcZhgaNlkcu0HyivzwH5HmEV8ftzO4wAcjU8o,744 +torch/include/ATen/ops/_sparse_csc_tensor_unsafe_ops.h,sha256=ComYqnovOazuwkWrPzu3XpLj6UCJwGV7L2w21M6tFSU,1786 +torch/include/ATen/ops/_sparse_csr_prod.h,sha256=MhCJdc2uZQADP9mV_yhkL6zc-r6yXiL4KJTT9IjQyGg,1663 +torch/include/ATen/ops/_sparse_csr_prod_compositeexplicitautograd_dispatch.h,sha256=Aqt35kr_pycSRK25NE7KpqfimbyLzgtBMCrYINmHJTo,1050 +torch/include/ATen/ops/_sparse_csr_prod_native.h,sha256=Qmk2VOUQ8DCbIQ0Wqvy6HLL41Yt_hyBOq-PhVW2_IBs,922 +torch/include/ATen/ops/_sparse_csr_prod_ops.h,sha256=5Lwz_nRc-_3BmoP_6d9sn2N0VKfWVFzxqgAovIFbRSE,2220 +torch/include/ATen/ops/_sparse_csr_sum.h,sha256=GShp0fn1Glpi9ovt2SDrOiIHggkdlF3uAdQuFEhXMf0,1653 +torch/include/ATen/ops/_sparse_csr_sum_compositeexplicitautograd_dispatch.h,sha256=78IbGs5JSLLiQSVjLhCnaL9dz9obMt56LMKf87vvBzA,1048 +torch/include/ATen/ops/_sparse_csr_sum_native.h,sha256=Zy28poTNzSllR2iGilTGmfOiICSQoRw5Ubg1BUGH5NA,919 +torch/include/ATen/ops/_sparse_csr_sum_ops.h,sha256=cieiu-w0E1eTRQNepiW2NJh61ulcXOgYghRXDsiRa-Q,2214 +torch/include/ATen/ops/_sparse_csr_tensor_unsafe.h,sha256=EGq6ew0DyEZM6Sc8GF3-N9f82ffqjGYv2DRxPto2gEI,1760 +torch/include/ATen/ops/_sparse_csr_tensor_unsafe_compositeimplicitautograd_dispatch.h,sha256=uJu8s014UNr_L7qjB2GyX07qAmGPRTfT5D8k1t0xlKE,1201 +torch/include/ATen/ops/_sparse_csr_tensor_unsafe_native.h,sha256=LEijBEkv5JbTBln6ICki8q-oB5fwYE7tWdJu-A_o-kY,744 +torch/include/ATen/ops/_sparse_csr_tensor_unsafe_ops.h,sha256=shLRCH3FKwOCDcceUcS54khGIPmpVTD0-K_-fU7jVUY,1786 +torch/include/ATen/ops/_sparse_log_softmax.h,sha256=vcD2f3b99izE2MObCLN4yqZ1eRc670nnPLtrq6p5KnE,1990 +torch/include/ATen/ops/_sparse_log_softmax_backward_data.h,sha256=d3JS7Z3zBCNGHko7qNSeE5CBKuPj8KYtau1qEj-tkks,1711 +torch/include/ATen/ops/_sparse_log_softmax_backward_data_compositeexplicitautograd_dispatch.h,sha256=MSFjlT3B14wEGoxznxPm5tgApZYCwmgXuIG-xfn0izg,1065 +torch/include/ATen/ops/_sparse_log_softmax_backward_data_native.h,sha256=hmt-A9loQShV7kixCiNM0fnWaDJSDVrU8wh7sfS5PPg,913 +torch/include/ATen/ops/_sparse_log_softmax_backward_data_ops.h,sha256=z8mxUsfkJMNHy1MSwX90iShhqMalbwO5K6mTIrab8Rw,2226 +torch/include/ATen/ops/_sparse_log_softmax_compositeexplicitautograd_dispatch.h,sha256=hPFxbead6hMjkXtDX9CahezrpBKolM8DcwDA6VRh-tU,959 +torch/include/ATen/ops/_sparse_log_softmax_compositeimplicitautograd_dispatch.h,sha256=1EcEyhepbvqipKUpgerflkAfdTrpc2CpWMv1VgPQ2WU,974 +torch/include/ATen/ops/_sparse_log_softmax_native.h,sha256=ABNPWGjGg6Lbn9wrp4xvrqklXjCsHiFIM-6anx0LLvs,1028 +torch/include/ATen/ops/_sparse_log_softmax_ops.h,sha256=HhHb16cMTBFIqaYH1NC0f_Lx3E4RhwSlaCDtf6_0tGI,3431 +torch/include/ATen/ops/_sparse_mask_projection.h,sha256=GtdMfMf96yPSG4ulamXp6bG13EFY5g6Zsqep629h8iE,1245 +torch/include/ATen/ops/_sparse_mask_projection_compositeexplicitautograd_dispatch.h,sha256=2WJL30FoTJjCjZgIv9ZCRVirrPSeGmHg5GhHokJh0Cs,1007 +torch/include/ATen/ops/_sparse_mask_projection_native.h,sha256=iik_FMZEKXkcDkZO3FYsBVbhDCzFxkOokaNwNVBBmbo,704 +torch/include/ATen/ops/_sparse_mask_projection_ops.h,sha256=Wt1cekVcrRiEJ3x6xmD0vq8DWEBJpIlTM11JcdSsKzI,2032 +torch/include/ATen/ops/_sparse_mm.h,sha256=hkIsNuCbSO-pBjKkQ3qJKN6JELl1GSJK0znH4d57lW8,953 +torch/include/ATen/ops/_sparse_mm_compositeimplicitautograd_dispatch.h,sha256=5j2KIVy9W-sE7_AlMZaUqu9_bCfhRe5cAU_yq82DNoY,907 +torch/include/ATen/ops/_sparse_mm_native.h,sha256=Le-N3Fs0OWK5egK0PYXh6e4tvTXJHG4IJH9Aft8k3cc,630 +torch/include/ATen/ops/_sparse_mm_ops.h,sha256=7XHCZ007htw2sSXPXYnIdJeTFQdyKxuKdhV11GPfuLQ,1808 +torch/include/ATen/ops/_sparse_mm_reduce_impl.h,sha256=EBUJ8dltz0Gel7gdkie176BUwWrWSPHsKhoPasjwKw8,816 +torch/include/ATen/ops/_sparse_mm_reduce_impl_backward.h,sha256=Zusdrz4ksruqbU2uAOryVcv-GgCPhjMERnam4O9Yq2A,1032 +torch/include/ATen/ops/_sparse_mm_reduce_impl_backward_native.h,sha256=m6jr48P8g6QHTQaU4TpWFWy90f1gYvh6YLmGWFyok58,695 +torch/include/ATen/ops/_sparse_mm_reduce_impl_backward_ops.h,sha256=jMSBdYibUSiHAopqczdhZwKbb5wjqMDvVQRavmTIInw,1594 +torch/include/ATen/ops/_sparse_mm_reduce_impl_native.h,sha256=H3eB3_QGZdJ12KvCR_WLlT1lMIO6Z1ygHkh5z6wbmaA,594 +torch/include/ATen/ops/_sparse_mm_reduce_impl_ops.h,sha256=mxBmr3msR5W7REa6M1gaznLeDuO9l5kFhAut1VmL2no,1266 +torch/include/ATen/ops/_sparse_semi_structured_linear.h,sha256=_bKf80XeR4-C_nPHCgGgle7GSrLqRFAURT2Dz6838h0,1073 +torch/include/ATen/ops/_sparse_semi_structured_linear_cuda_dispatch.h,sha256=EgPim8SjHWuK_-QXAX1I_5eZE-5SIp5uIAPZsZWUMWg,953 +torch/include/ATen/ops/_sparse_semi_structured_linear_native.h,sha256=5pwC7xX5KBW2_uR1Vx8pkSDfQ-DMCVt7nt3BmoTU6QA,718 +torch/include/ATen/ops/_sparse_semi_structured_linear_ops.h,sha256=JXe4q6D-orTL54OwxhkyZSjm9nfgzFrYSXMXVa6A1p4,1635 +torch/include/ATen/ops/_sparse_softmax.h,sha256=ujuPRMqYw5rreiEZWCeS9XGH2dpoqU3OmXyAWd3Yl7U,1926 +torch/include/ATen/ops/_sparse_softmax_backward_data.h,sha256=znnLyk4fxI9_9SOtHYJc94rsYjKpIeYRHIVsS-JKhwU,1671 +torch/include/ATen/ops/_sparse_softmax_backward_data_compositeexplicitautograd_dispatch.h,sha256=pK9L-SCFibpejshNAes-ep8Gg7lEFD4YuO9vY66Fcc4,1057 +torch/include/ATen/ops/_sparse_softmax_backward_data_native.h,sha256=LmM6QLrP6Q9ydid-5DtA7q1KkAKLv40DzujfyFBsHO4,901 +torch/include/ATen/ops/_sparse_softmax_backward_data_ops.h,sha256=ooW8oxQ9WJyM82iUYcW5t-Hc02WRcldvONRbGVBNUgo,2202 +torch/include/ATen/ops/_sparse_softmax_compositeexplicitautograd_dispatch.h,sha256=CAI5KiocSavdh38pDa8PD37YZwBRx5NnL_jj3RZ8hg0,951 +torch/include/ATen/ops/_sparse_softmax_compositeimplicitautograd_dispatch.h,sha256=Gy6iLXpXI43qz0CZBodTruQ9ZzBcGGQgXi_6bS4b03c,966 +torch/include/ATen/ops/_sparse_softmax_native.h,sha256=qPKyyGiEP4pVL7aTn054GqepKAJPV4AaA5y0Df6YZFE,1008 +torch/include/ATen/ops/_sparse_softmax_ops.h,sha256=RjjjIOOj5iQigt_IyGzw897TSQS5j0lg1ucpR6NUs7Q,3383 +torch/include/ATen/ops/_sparse_sparse_matmul.h,sha256=nPuQbiXnbLsNc7iz3O7NQ3KhlxLBQ5qHU63Nd2FRiOo,1306 +torch/include/ATen/ops/_sparse_sparse_matmul_compositeexplicitautograd_dispatch.h,sha256=BG_mISTQJ1_3dGvtKunqxjIm0PY17tRazzT67aBNEgg,949 +torch/include/ATen/ops/_sparse_sparse_matmul_native.h,sha256=AdCF244oguuPnFfI7JGE-ccjo5GjiJllxh9ov2ZbGcA,749 +torch/include/ATen/ops/_sparse_sparse_matmul_ops.h,sha256=4G-UkMZG7kC2vh4H-onhsBBf2zUfIdo3XCkUxlXhFfU,1852 +torch/include/ATen/ops/_sparse_sum.h,sha256=7l_ciEGQN1OqOexNpFXmVVdgOURVzv4-YFUYO1uE3ac,1823 +torch/include/ATen/ops/_sparse_sum_backward.h,sha256=xAl-UC8p7p4rqBILtMqMBGbM2aOYoN_U5ZaX5Zs3dLE,1398 +torch/include/ATen/ops/_sparse_sum_backward_compositeexplicitautograd_dispatch.h,sha256=-ZHZZGrACRdFt9RXETr9wPG7c2nGthaffhhpiQ8oQlk,987 +torch/include/ATen/ops/_sparse_sum_backward_native.h,sha256=cQ7kfqVW-2ynZ5nMczSdhCWFfp5lk8B5nkTjpvJblhE,808 +torch/include/ATen/ops/_sparse_sum_backward_ops.h,sha256=XV0rqNvzgrEVeiWi6CH-RecDNw0bCO6FLflwxLKfixM,1980 +torch/include/ATen/ops/_sparse_sum_compositeexplicitautograd_dispatch.h,sha256=-uMzTNOdApGGoqSAxhIpPcbPY0jm2I0eBG4w6JtzQf0,999 +torch/include/ATen/ops/_sparse_sum_compositeimplicitautograd_dispatch.h,sha256=hxbc6Mn0RoBi7lPxx-DicjlKRXz7dALEIkH9oeWzYEo,952 +torch/include/ATen/ops/_sparse_sum_native.h,sha256=QUKE02A4Q90okBYZZ0kiB88IuedUABMM4M6VVRnbxzg,863 +torch/include/ATen/ops/_sparse_sum_ops.h,sha256=Alj_thgbdIe6zDbyr4weiEafJf5oGeX2YWet4sAn7s4,3708 +torch/include/ATen/ops/_spdiags.h,sha256=ekCGg2Ddzi4pTfpUiadNM5bgZjp8-i8txEa1tqFJdSk,1583 +torch/include/ATen/ops/_spdiags_compositeexplicitautograd_dispatch.h,sha256=Z_y65JTPaKS6sy49q5BtW_o33YffYoU51lEIE26D0fs,1064 +torch/include/ATen/ops/_spdiags_cpu_dispatch.h,sha256=1yWO66JAuu9j9pGwbFFhMgwe5EizsXU4np-SUPLdiIA,825 +torch/include/ATen/ops/_spdiags_native.h,sha256=gRvAoFs26UQ__KnlLpg6Al8jlz1HttwNl7V--RpKKxo,761 +torch/include/ATen/ops/_spdiags_ops.h,sha256=FHMqSt8eYCCkKEy2ZlIoSsirW8vwmfb6hCUyWOylIto,2200 +torch/include/ATen/ops/_stack.h,sha256=u9dl5jTknBM9KWcUedV5jYeILDKTHKL5innm1Pm9bbA,1127 +torch/include/ATen/ops/_stack_compositeexplicitautograd_dispatch.h,sha256=XPmvbCkXjicSsxv5hT7byCXYEVLWLbP-GpbR8sd483o,961 +torch/include/ATen/ops/_stack_cpu_dispatch.h,sha256=gyMVPfnMJFNwIesKmE9NCvaWnGf0G671tK4rfjbUgQ0,917 +torch/include/ATen/ops/_stack_native.h,sha256=s4qf3O61I8WP3lQVls6n-T-GxrkfhAqDFUQ0Xld-ea8,757 +torch/include/ATen/ops/_stack_ops.h,sha256=tVNv5tNiHcPlt5j_0ywItOEljBkIU28_XtrT_mSYm08,1680 +torch/include/ATen/ops/_standard_gamma.h,sha256=gtiCRacqdLQhb75aVZMpUrbHz0CPsLOy_hiUM5LuUto,1365 +torch/include/ATen/ops/_standard_gamma_compositeexplicitautograd_dispatch.h,sha256=q31PKb66sfuggy-a4NIcli9CgiyogvWiWdEtB1zCP0s,978 +torch/include/ATen/ops/_standard_gamma_cpu_dispatch.h,sha256=kJb2hvqzIVppDELxIq_u6qI1gDbAjqWnQfRDSjzBQWA,782 +torch/include/ATen/ops/_standard_gamma_cuda_dispatch.h,sha256=Yyo-DUw5pSBiz9fiMcuY3000etlf6Tkgpj9pwr1Onc0,784 +torch/include/ATen/ops/_standard_gamma_grad.h,sha256=NXmKkZojuQvucrgCreomfAl_6nIL3tnZGRMNEVAeQto,1305 +torch/include/ATen/ops/_standard_gamma_grad_compositeexplicitautograd_dispatch.h,sha256=2xR6UnXRYLzFRExycBln4i7-yD52j-TPLmLrCmAjy9Y,949 +torch/include/ATen/ops/_standard_gamma_grad_cpu_dispatch.h,sha256=xsLiDQmTUeVhfMZKQaEHdUcSo_cZ1frj5GG2nJOOfmc,761 +torch/include/ATen/ops/_standard_gamma_grad_cuda_dispatch.h,sha256=c39AgyrLB-xOC2-4VsfkvmKeVupoapqZ0sB5ydlR8fo,763 +torch/include/ATen/ops/_standard_gamma_grad_native.h,sha256=1F-lLUE9YlP1xQY6zIQryamFHKQFzurXxu4aSvwYY7k,751 +torch/include/ATen/ops/_standard_gamma_grad_ops.h,sha256=DD4iXAJ66_BlOo47_xPLNL0JaL8fCE1fUGrzR8hEDlU,1852 +torch/include/ATen/ops/_standard_gamma_native.h,sha256=IcsqOwxGKZxyCMNbbMx7EJxY67z8gPphpkApqqU-xZ8,787 +torch/include/ATen/ops/_standard_gamma_ops.h,sha256=1yQOKMvUYMkJt8bAxO1engbUc8G_-BW0RbATOuCQL6o,1918 +torch/include/ATen/ops/_test_ambiguous_defaults.h,sha256=PtIudE8l0d_ZtHXv2vuVSk8piIRZX4i_anfo1_7XEAw,1007 +torch/include/ATen/ops/_test_ambiguous_defaults_compositeimplicitautograd_dispatch.h,sha256=47byKGQMPtyd3SUg4xtKqkffe-SqIc6D4dvhSJpYRcg,913 +torch/include/ATen/ops/_test_ambiguous_defaults_native.h,sha256=f4wq8GCaub-FJ7N_NDWfvQKtC1IwyvXsZTaC9xGm_Ss,642 +torch/include/ATen/ops/_test_ambiguous_defaults_ops.h,sha256=vCUCEcpB7LV228_Lc-dj_pm1quDzt78IfEpxdq3Xows,1815 +torch/include/ATen/ops/_test_autograd_multiple_dispatch.h,sha256=9XDsZesxXRKfuurvzAFL4IsUHu3ANCrc2QO_0qyRa38,1599 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_compositeexplicitautograd_dispatch.h,sha256=_4SgReFkok3NlUaXE70PKKcCMwOBlAdOgs9Ok9qjmvY,999 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_compositeimplicitautograd_dispatch.h,sha256=u1fU6MDlxVnjGEaMWEud_5l8DC86P_8IfkqetI0loQM,798 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_native.h,sha256=EtDOJyKALOhjt46exz6OZFiK-Nm0SNd1Js0Iix4Y5kY,738 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_ops.h,sha256=Pg9niWFkQvTctSH1tvIueMNxGhxCN0aLgKFe_cWEKMY,2484 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view.h,sha256=mpMc5Jas9StnViPrO1IiTaNMq7WeX6t4hrGSHq7QnvE,755 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_compositeexplicitautograd_dispatch.h,sha256=ShG32Y8O22F1mikUvW-HKUu4BQ2fvcltU6jT-TJl-K4,795 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy.h,sha256=ngnQ4FzADUJEbv6eoISncpkNI73kKpc8IEb03J48QDo,1375 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy_compositeexplicitautograd_dispatch.h,sha256=0B3WYKdaoOO9F0gmsprXOafJu58zDJDtSlhQGZbPM-w,939 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=9_LCvXLK5y8zBux6-buoGdOjW4SkXVTI0_j4CPZQLXE,826 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy_native.h,sha256=d881ViDbY4tJw3Kq1EnX72VoWOuxSgl8j3xqX02hWpg,637 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_copy_ops.h,sha256=Ym_NgGDQ70xd3q6u0Ex6Kgw0GuhyvBmzrR-Xj-kuUvQ,1806 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_native.h,sha256=Le6HUJRk3JSek3kTUHQ2TX8FVYyRWHM7sB8Hu2o86VA,518 +torch/include/ATen/ops/_test_autograd_multiple_dispatch_view_ops.h,sha256=9WwjKbjWzT7Hf7FoN26MPDSvH_xgWTC5kkcxzF5j-GU,1066 +torch/include/ATen/ops/_test_check_tensor.h,sha256=jom7DbYYCbr50juP21cEfU8Eb7HhIlpMEnvG4bU8sBs,673 +torch/include/ATen/ops/_test_check_tensor_compositeimplicitautograd_dispatch.h,sha256=E8I0_VWxQ1AAjGOdFIvKJx1V_NNhSOo1ur_jfI3J2_A,776 +torch/include/ATen/ops/_test_check_tensor_native.h,sha256=d8m70t5GNcoLHAtVg3V2hfYjF3JTFIg9X0u9POsXgYY,499 +torch/include/ATen/ops/_test_check_tensor_ops.h,sha256=q4EystZZPVsoP3OcHnDjVbAg2IWAG_Qyso153XgAYW8,1003 +torch/include/ATen/ops/_test_functorch_fallback.h,sha256=vltQN08MF9t1xyQqdJKkGbQxuP3ZzkHnaIAw1VSf5cw,1336 +torch/include/ATen/ops/_test_functorch_fallback_compositeexplicitautograd_dispatch.h,sha256=92mowvVjVXdV8L3vPlGYdJFOqcBgqNfVEeYWzjzlo-8,955 +torch/include/ATen/ops/_test_functorch_fallback_cpu_dispatch.h,sha256=KtazLBaKD5akwda0xUfVXVTjrraI7P0jqykNg1ySnG8,764 +torch/include/ATen/ops/_test_functorch_fallback_native.h,sha256=vHi7KFXZmmfuXbkduBSh7eOgHVIJreNlWCNgc9K-JjM,653 +torch/include/ATen/ops/_test_functorch_fallback_ops.h,sha256=-47Trb3dIEmwG4yoOVN50NhHWgY7uDZtICfrr3o691U,1870 +torch/include/ATen/ops/_test_optional_filled_intlist.h,sha256=Dg_HvIHtTCKN7p7be1k487qRweY4WpQ7byNB6kz0LAs,1440 +torch/include/ATen/ops/_test_optional_filled_intlist_compositeexplicitautograd_dispatch.h,sha256=qr8tdDam2XUh6D4Mz-H7zK-qhweREUt5EnnfhJbTh1E,983 +torch/include/ATen/ops/_test_optional_filled_intlist_cpu_dispatch.h,sha256=273YyCcDdwyN39oHF22kHPOrhb5Z_M3hoex2VkXtBRA,778 +torch/include/ATen/ops/_test_optional_filled_intlist_native.h,sha256=KkG6yHKTZJwgQXAGK1yP5V2xe_ZSIsF507UvzOtj4hA,674 +torch/include/ATen/ops/_test_optional_filled_intlist_ops.h,sha256=u-Ox2f1OqH707QxYai1N4s6vbzglpnoyjampO-Kw8HE,1956 +torch/include/ATen/ops/_test_optional_floatlist.h,sha256=74HutCVHgKl-Cu0kdF-UHvnQGzAqIQvANGaPs8VfvNo,1429 +torch/include/ATen/ops/_test_optional_floatlist_compositeexplicitautograd_dispatch.h,sha256=ZnmJqrVjwZ_YFyqNDnwIewXLlAKmpqUbD4bDN3Gw0Qw,997 +torch/include/ATen/ops/_test_optional_floatlist_cpu_dispatch.h,sha256=KGGKElIxpMsQxgTdaqZujj9ClAflNHzZ7dn6V5_eAEo,785 +torch/include/ATen/ops/_test_optional_floatlist_native.h,sha256=qjU60cYtTROYx-VQgyOC3xFwGxHJLfcYK11MM4EVVUY,695 +torch/include/ATen/ops/_test_optional_floatlist_ops.h,sha256=KlYnVVEPE9i9Yq2x7MBd-IJzHOWBnryT4xZdiKLPimA,2000 +torch/include/ATen/ops/_test_optional_intlist.h,sha256=TG5ms66YOUYi7ShZUYpHe3oxwH_4IAELsGCwgI7RU3k,1367 +torch/include/ATen/ops/_test_optional_intlist_compositeexplicitautograd_dispatch.h,sha256=eVJi6ab4DkHA1hpRYMU20_i-t6JWl5x4Gwd_3Qlem5c,969 +torch/include/ATen/ops/_test_optional_intlist_cpu_dispatch.h,sha256=4fatPAnfN2rAQBlteXcNtAfobxwhvOhbAGKYnLA6mTk,771 +torch/include/ATen/ops/_test_optional_intlist_native.h,sha256=o-rrOGgEmeJ1KVZqjhr2OsjeHLB2Xx7LfMvFgaEmb-g,667 +torch/include/ATen/ops/_test_optional_intlist_ops.h,sha256=ytTamYcqCS0sl-_j9NAVXp2-hMO7OBirf7XOwI4y7vM,1912 +torch/include/ATen/ops/_test_parallel_materialize.h,sha256=nvRj1J45W-KRBvt8yFh5M6hiM5FB970O6rPEFO7Jso4,817 +torch/include/ATen/ops/_test_parallel_materialize_compositeexplicitautograd_dispatch.h,sha256=XE4Hk9a9vPYma_3WtJeaiWF7KjPC5_ZSYAl8ap08b3c,829 +torch/include/ATen/ops/_test_parallel_materialize_native.h,sha256=UFKIzNR-uVVEKVnuS4yxwkTMu19rJFxmqME9D5IAiso,552 +torch/include/ATen/ops/_test_parallel_materialize_ops.h,sha256=Qkaxo6WLc2395IzmU0jN8jkhdij6AwugJ0bYMqt3gOQ,1161 +torch/include/ATen/ops/_test_serialization_subcmul.h,sha256=Eac_o6-a5DU2ilFK45vyCnlHNY5B1l-YETNinFLjv5g,807 +torch/include/ATen/ops/_test_serialization_subcmul_compositeimplicitautograd_dispatch.h,sha256=Wp0aj5ZRbbyZWS8wtq5talYpwhixe-oonjXzH1etaos,839 +torch/include/ATen/ops/_test_serialization_subcmul_native.h,sha256=huTEXRqkkMLjtrj63jqsVAViZaPZ3NWP07TlNSr26GM,562 +torch/include/ATen/ops/_test_serialization_subcmul_ops.h,sha256=EA4cQCu311LuRKCER1skRoUEq4uhU_PCNKz8Zw32cM8,1204 +torch/include/ATen/ops/_test_string_default.h,sha256=v7wo-FSxWauvWjfQZM8Pg7fs8aE27oahBTk9zXrHCZM,776 +torch/include/ATen/ops/_test_string_default_compositeimplicitautograd_dispatch.h,sha256=ykuGwGkSaYvf8c3IFy7ShiYsFUpHg-0gU39GV9vurFc,835 +torch/include/ATen/ops/_test_string_default_native.h,sha256=JLIT6QAKD854E5M9YSGx6cAl4rG68QDbtdHtnmKMVmQ,558 +torch/include/ATen/ops/_test_string_default_ops.h,sha256=-lyYiqQHGcce7KwkWznsxecxICjuGElprfrLbCZ96ow,1168 +torch/include/ATen/ops/_test_warn_in_autograd.h,sha256=T8Y3LE8esqrY3ec8MnOtFns2MDJHmErzWs77TqM3dbs,1175 +torch/include/ATen/ops/_test_warn_in_autograd_compositeexplicitautograd_dispatch.h,sha256=tTOb7ZwkeT68ED7U4iQ36i5JV8nc5oae7fZyjgpSvMY,969 +torch/include/ATen/ops/_test_warn_in_autograd_native.h,sha256=Ari9ta3cXUC2RYr-KtOVlLgF6qtYDV70FikHuZLISpM,597 +torch/include/ATen/ops/_test_warn_in_autograd_ops.h,sha256=LXQsxBTpmqq49IOEQDP2LiId-2Vl-8R5AzCwcbSsDMs,1686 +torch/include/ATen/ops/_thnn_differentiable_gru_cell_backward.h,sha256=5WXcis1MHzAtVDnoLcbVkqgtZ0egnZ8ysLfes6zzmBg,1184 +torch/include/ATen/ops/_thnn_differentiable_gru_cell_backward_compositeimplicitautograd_dispatch.h,sha256=jPCQ6TsoDWZIKguy7fM7QWtq6D4O1F5To_WxwlFEzIg,1038 +torch/include/ATen/ops/_thnn_differentiable_gru_cell_backward_native.h,sha256=kxgyYPHAoPD3mmqHbqhx8GDaYpKVSjCiTJ1wTbUC7qk,761 +torch/include/ATen/ops/_thnn_differentiable_gru_cell_backward_ops.h,sha256=sl8DBjbP0BSwRmjjp-mrscCCi91oQAUJCsbyR2fZnp4,1865 +torch/include/ATen/ops/_thnn_differentiable_lstm_cell_backward.h,sha256=EnyZ8fl6QV1trzS-wJO3qoHzog5Ei4YG4yh94FPhb8I,1311 +torch/include/ATen/ops/_thnn_differentiable_lstm_cell_backward_compositeimplicitautograd_dispatch.h,sha256=lml6j-3WwsgsO1VwMGhaOVtRwUN7xtvEyJa4asdtT7k,1120 +torch/include/ATen/ops/_thnn_differentiable_lstm_cell_backward_native.h,sha256=6DQUQqIab2VMv5rkXRwVhrY_7HdrHwlPxtw4KPlvo6Q,843 +torch/include/ATen/ops/_thnn_differentiable_lstm_cell_backward_ops.h,sha256=Ll_gUpUihFgf3lKblt3MyrcyyMvHzDcJOmIS24UaRsE,2129 +torch/include/ATen/ops/_thnn_fused_gru_cell.h,sha256=MofPWmdIrbAPK0rtUNMK-BIXMeGLYhZxzUH_JjUNGY0,2262 +torch/include/ATen/ops/_thnn_fused_gru_cell_backward.h,sha256=zZ6OEaDzvb9yN-hwg66q8lTKgoccXLFGLe3woR3KHTY,2235 +torch/include/ATen/ops/_thnn_fused_gru_cell_backward_compositeexplicitautograd_dispatch.h,sha256=pliN6RJ8qCKuNQFrlK3ihS6popLP7Qas9Ir9Hxs7lsE,1295 +torch/include/ATen/ops/_thnn_fused_gru_cell_backward_cuda_dispatch.h,sha256=8HjHcxn6nL6fJrElSvtigF-RRAilTePjybsy8ll9k0U,851 +torch/include/ATen/ops/_thnn_fused_gru_cell_backward_native.h,sha256=UVHG00S7CKoJMFcUe08bXb5b4UsvAQE_II6j9a3PtkY,913 +torch/include/ATen/ops/_thnn_fused_gru_cell_backward_ops.h,sha256=khhs5hOygQqbaOKp5mkVGtjS3yaL_3O_nNWFM5luKS0,2779 +torch/include/ATen/ops/_thnn_fused_gru_cell_compositeexplicitautograd_dispatch.h,sha256=3TYe4i-leqF0i1IjFnZJBRoT2lq6ttQd2wO4kDBUQ60,1307 +torch/include/ATen/ops/_thnn_fused_gru_cell_cuda_dispatch.h,sha256=KIn_dKQJ-GKgjYPlC01-Dh75JroWMbOPbjLhI8y97TI,923 +torch/include/ATen/ops/_thnn_fused_gru_cell_native.h,sha256=zef0aSc-42CWTrFDJWeeacyTXn3Y27Bq-_31on066fI,988 +torch/include/ATen/ops/_thnn_fused_gru_cell_ops.h,sha256=A7KLzu62Aa85T6LavcX2Jt1pCbFs0rRmF3cwuXHdtBQ,2950 +torch/include/ATen/ops/_thnn_fused_lstm_cell.h,sha256=iptRuxAQSi8N3SVTQQLN3aW-6f0bbbgghuvOvmVFHbg,2425 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward.h,sha256=o0G7y_Ge4tyQ1UQ1Tn3rTu0xtckj-Lmrv2dT1lT4zSM,1082 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_compositeimplicitautograd_dispatch.h,sha256=oV-W1AoAfCrmmW5YW4RPByDCx7wjfhr2WYYghkX0MIM,998 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_impl.h,sha256=LUZljDEE5cwIZmnT5u82E3VDY-J69NlbaKIb1Vm5AXs,2472 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_impl_compositeexplicitautograd_dispatch.h,sha256=rFjxYawNgQWpj_l7IPDcORk5-bkAMbCmQUFBhTpELAs,1387 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_impl_cuda_dispatch.h,sha256=gv5KLyuJ04Q0X7kdgHSvT_qsfkEdpIYenCGycdiwPSc,939 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_impl_native.h,sha256=TYVW_IOVmq_yb2CVSroKIUBTOH5WChdB-f3y8Pk_8QU,1047 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_impl_ops.h,sha256=I1meSdUaclWkdawi5HfUW-MikkWWfjSGV5X_G2fLiVQ,3169 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_native.h,sha256=QFZqpSMczYXGI7AhFqgsJ3Cy0Q-Hf19Y8hkYn6rA2_I,721 +torch/include/ATen/ops/_thnn_fused_lstm_cell_backward_ops.h,sha256=1kmHv03aQwlIb0xy702mGKjdauOmLUxRFz2l8VrjPTk,1743 +torch/include/ATen/ops/_thnn_fused_lstm_cell_compositeexplicitautograd_dispatch.h,sha256=oGwHLfgc95d7cxiGL6szjb8tV33EbCj1Tr7ZTi_cFUI,1373 +torch/include/ATen/ops/_thnn_fused_lstm_cell_cuda_dispatch.h,sha256=tlBSg8uoCj3Fjkvx8MGHVF-zh1dake_T-i9xr4M693E,935 +torch/include/ATen/ops/_thnn_fused_lstm_cell_native.h,sha256=kD0tok2EBIiobHgA7mnZbNP6RwIEDF44renVxeLvkD8,1033 +torch/include/ATen/ops/_thnn_fused_lstm_cell_ops.h,sha256=5u9n1zLBSszJJtsGlSSESfpWFJPZ3c68o-tnI8Jhpxk,3117 +torch/include/ATen/ops/_to_copy.h,sha256=5iRk9L5tv_4d7uXNgYqjYuhrOocBy1kwhe5GeAQyv9o,2407 +torch/include/ATen/ops/_to_copy_compositeexplicitautograd_dispatch.h,sha256=0_54B_U60U5yPY6rGvLGtIcIsf6DqRc01kDg3VIXNN0,1452 +torch/include/ATen/ops/_to_copy_native.h,sha256=84tWIZ_hjTfYA2QXv2aFIhFABvlqwh5iu0qAksvormw,1166 +torch/include/ATen/ops/_to_copy_ops.h,sha256=_96wQHpRsbtbZ2U2LCWvTEVyxM_TK8ahD-ThhDy5vR8,2534 +torch/include/ATen/ops/_to_cpu.h,sha256=XhNN56gg2eaYmrPIMz4SeIQRMYLX6CC7GwVEATwD9dw,653 +torch/include/ATen/ops/_to_cpu_compositeimplicitautograd_dispatch.h,sha256=-EBNmOaU_6yFQfctFFWNuJN4cjKyq6MleA4NIZe5QCg,779 +torch/include/ATen/ops/_to_cpu_native.h,sha256=y0owTHOkosTOU8qc3ndRyVMFznn4A2Byu1hXXcGmsn0,502 +torch/include/ATen/ops/_to_cpu_ops.h,sha256=D1D-mmaWnyxhouCFEO_-ltW1FYZ3xourlm2LS7Rl7bU,1016 +torch/include/ATen/ops/_to_dense.h,sha256=qhtfBB9M4YltNj0Vx5vNSXitA5AIrk7V86aQH-b4ubM,1203 +torch/include/ATen/ops/_to_dense_compositeexplicitautograd_dispatch.h,sha256=DP7QO3u6Ls8m9zLaBDBzVpz_I76IiKSEJCmTgo9tsFw,1039 +torch/include/ATen/ops/_to_dense_native.h,sha256=mLhb0h07bBxi5aLR8gIRgxO-ssen__83m178mcA5OA0,1072 +torch/include/ATen/ops/_to_dense_ops.h,sha256=DG_8GhsgnuxSMoGG4BES0PcqbijaFXeoReSmJaMw2YI,2088 +torch/include/ATen/ops/_to_sparse.h,sha256=vUSQkfIaO2as5ubupPWOnXF5lZCzTk-0A6LZMhXL0_g,1899 +torch/include/ATen/ops/_to_sparse_bsc.h,sha256=BSgfpExoy_T5ZYIoLDtEcpDD9ShIc4ZlEan0X8HvkBU,1193 +torch/include/ATen/ops/_to_sparse_bsc_compositeexplicitautograd_dispatch.h,sha256=LjEDFM8Q8P_NdOXWRtZ0Vwihh1_ikLmZQW963WnogCg,1018 +torch/include/ATen/ops/_to_sparse_bsc_cpu_dispatch.h,sha256=U0KLYmrApwwtYUC6D4fNgjIdK1iobdnc9rH9EqnisNY,802 +torch/include/ATen/ops/_to_sparse_bsc_cuda_dispatch.h,sha256=VTdHQyCjQ3SKrQ0JOYHxCyEBQwCGuFd-mX3_OmeS6vw,804 +torch/include/ATen/ops/_to_sparse_bsc_native.h,sha256=Kb7g09hYWMRvj3jLhpZVg0_-AG3HgHhhDs1i5cEWBQg,1013 +torch/include/ATen/ops/_to_sparse_bsc_ops.h,sha256=umQhcdZCtFutbILguZpfN2d4bJ783FUf1x61zuLzwj8,2042 +torch/include/ATen/ops/_to_sparse_bsr.h,sha256=HRgL_0BebIsSgPnXtKJTIb7tDUQ1tZj9iXlVSqZybhs,1193 +torch/include/ATen/ops/_to_sparse_bsr_compositeexplicitautograd_dispatch.h,sha256=XdEsy5DJBdCe6c_M73krufm9w_jAGBqjbxw8vgfuJYQ,1018 +torch/include/ATen/ops/_to_sparse_bsr_cpu_dispatch.h,sha256=hSi-ESRaEPSOVgkYFdDAGzfl25hXop4tV29i9Ct0o_g,802 +torch/include/ATen/ops/_to_sparse_bsr_cuda_dispatch.h,sha256=zELOKl93DeCJi7Mrv2h0o7-X1gH816JhNJJt7y6YvA8,804 +torch/include/ATen/ops/_to_sparse_bsr_native.h,sha256=mbuDKbnkxg-sOFX-ilwqQ-ZKanfoI7SwoCxXEgHG6Ok,1013 +torch/include/ATen/ops/_to_sparse_bsr_ops.h,sha256=1NGPWN7woIVJbKpD_fSNLKNwc7HJEdK0L6AE3SLtM_M,2042 +torch/include/ATen/ops/_to_sparse_compositeexplicitautograd_dispatch.h,sha256=aQhKiF-MQcvuMcpSd8oat25m4uvM17J_Rc2YR1wpBMQ,1325 +torch/include/ATen/ops/_to_sparse_cpu_dispatch.h,sha256=UTpojFeg9Qcjz6gcgDnYxf8CjRXoLAg9fZWx522bbsI,944 +torch/include/ATen/ops/_to_sparse_csc.h,sha256=1Z2mri6I1z7iAWuVPKthI1BmNmRTSiOeHtO5bMigwl8,1081 +torch/include/ATen/ops/_to_sparse_csc_compositeexplicitautograd_dispatch.h,sha256=VyyRCRSU4qCF4uGnwFNPPzBx3MXZo0gb-q3igcEv4Cg,964 +torch/include/ATen/ops/_to_sparse_csc_cpu_dispatch.h,sha256=bam7hRwJSUHlrKarTFgt729YIjWIk-POP2zhr2z8pf4,775 +torch/include/ATen/ops/_to_sparse_csc_cuda_dispatch.h,sha256=CIefSkpN0ddpE7vqblnbN-dD-SNslPZluFG0Aw5CYgw,777 +torch/include/ATen/ops/_to_sparse_csc_native.h,sha256=2y9FXqobVc0QN4kh-xNl23zLufLEmp1UqFn2qotGwhM,905 +torch/include/ATen/ops/_to_sparse_csc_ops.h,sha256=IgJNggnoNcm6iCqKJGDt-voFYDWCz32wrC-p686yEhs,1864 +torch/include/ATen/ops/_to_sparse_csr.h,sha256=ZEJUoV0cAAYHrslAA-8JdrqrIW2HzE7AcQm8rFfz9CM,1081 +torch/include/ATen/ops/_to_sparse_csr_compositeexplicitautograd_dispatch.h,sha256=Kcmw63CibIb49OaxdsRuGBIzA6PSBCH6g9IwCFPaQp8,964 +torch/include/ATen/ops/_to_sparse_csr_cpu_dispatch.h,sha256=ZNLhm0Q0KaEpbBqdRb_vLtd_W-NKZKW7VdXOI5SSpH4,775 +torch/include/ATen/ops/_to_sparse_csr_cuda_dispatch.h,sha256=mWqs7g_TOnvllyuLboZ2B6sysPbdFL__MrIZ-AoNG_M,777 +torch/include/ATen/ops/_to_sparse_csr_native.h,sha256=Q0eOPjwZgihLZMCiohe3NYDdOOmzMr6aiI4g66wYxRY,905 +torch/include/ATen/ops/_to_sparse_csr_ops.h,sha256=jUZbxi4gJHY8xxj-GfwiQV6s05gEbUfwtc_OrETczPU,1864 +torch/include/ATen/ops/_to_sparse_cuda_dispatch.h,sha256=L7GcZjjIXbDwqf6Ip4ejtjow2iKTkvi3KFAS1x6GZ6Y,946 +torch/include/ATen/ops/_to_sparse_native.h,sha256=nuKZrEur-l_WPDlF0oXgVyQddxiXxDCxtJ84gvoZm00,1629 +torch/include/ATen/ops/_to_sparse_ops.h,sha256=Z3UiDJHAQ3Hegv5pgQKP4L9OcCfFTYb-LbM3-YD0BIc,3688 +torch/include/ATen/ops/_to_sparse_semi_structured.h,sha256=jcxT6-E217n510-12jdOOb9fu6qZ2zymC_INWxH3SDg,743 +torch/include/ATen/ops/_to_sparse_semi_structured_cuda_dispatch.h,sha256=fuBR9LuFkYTnI9RMXfM_oZXyAnYtbbZ0K1F8030-BA0,768 +torch/include/ATen/ops/_to_sparse_semi_structured_native.h,sha256=QYS5RGmzpXj-z3-6DuUv2Gk35L1AqdH3GVGR11xEZO4,533 +torch/include/ATen/ops/_to_sparse_semi_structured_ops.h,sha256=cXZ7KKgUEnHo9Pxu6XY97AlnkOczyfJYMigcgP-gZZU,1115 +torch/include/ATen/ops/_transform_bias_rescale_qkv.h,sha256=qQf64guOue3FuRxHr0jDPyhY2cpr_GeyvOggM8W-Vi8,1879 +torch/include/ATen/ops/_transform_bias_rescale_qkv_compositeexplicitautograd_dispatch.h,sha256=xST10llBXdLyPiW3bmxHbESKM2zndrNbf3uOM65BOHY,1161 +torch/include/ATen/ops/_transform_bias_rescale_qkv_cpu_dispatch.h,sha256=BcWO5Q2hcIw00yN3xIuT0gkkX-j-2q_k9l-eqTgJ5U0,824 +torch/include/ATen/ops/_transform_bias_rescale_qkv_cuda_dispatch.h,sha256=HlM9SZU5PEIeSefcEVD-QZATP5m5NxkpgC4lssLFbqQ,826 +torch/include/ATen/ops/_transform_bias_rescale_qkv_native.h,sha256=O1vR4-gqZScceTenrxsbSObq_FoPQ9x6pz6tvbVy0vo,981 +torch/include/ATen/ops/_transform_bias_rescale_qkv_ops.h,sha256=rSokP-aJdCh5OAbxBi7ngfdYEVeVHAXv-wygcOQHXv4,2437 +torch/include/ATen/ops/_transformer_encoder_layer_fwd.h,sha256=wAx8lFQfDflowwom4j2mZ6m39NWNHP5fbQTKztKlW9M,4605 +torch/include/ATen/ops/_transformer_encoder_layer_fwd_compositeexplicitautograd_dispatch.h,sha256=fx3Q3OgM-RdWiQeGy0g80k3UKVxba_98Ucgtciiu5VU,2005 +torch/include/ATen/ops/_transformer_encoder_layer_fwd_cpu_dispatch.h,sha256=ywhVPEp72a28Qc2B0apf2gzWlfx8VyNr-DWafFroAM0,1297 +torch/include/ATen/ops/_transformer_encoder_layer_fwd_cuda_dispatch.h,sha256=QQcZRRoQqxG6NUUnS-1D5i6NQUFUVVKbHYFAu1D1Gno,1299 +torch/include/ATen/ops/_transformer_encoder_layer_fwd_native.h,sha256=SaxC7J14rkkwr6OzkMr-Ym3k_eNRMSjKT9PyM4IBwRQ,1706 +torch/include/ATen/ops/_transformer_encoder_layer_fwd_ops.h,sha256=c5YdUU9IxnHM_yppp5ASKhT8W2TZtoavgAQXhzxYen8,5256 +torch/include/ATen/ops/_trilinear.h,sha256=1ViGQqple6qCBGs7UPotcfSDXpiMTSWDuSOYRdR3ljs,1998 +torch/include/ATen/ops/_trilinear_compositeexplicitautograd_dispatch.h,sha256=h4OFRkJpe-f2PPOHOBxmhEstKlJLY06dhn-fT7ij8Po,1203 +torch/include/ATen/ops/_trilinear_compositeexplicitautogradnonfunctional_dispatch.h,sha256=MofkLAAcO-AxDBQLVW4wrhHwI8xsnREFX1HpFHNcfRo,959 +torch/include/ATen/ops/_trilinear_native.h,sha256=nZlpb8hzlV-ghtI9XALLUSHQx8IuwLbC8hv71pwbSwg,901 +torch/include/ATen/ops/_trilinear_ops.h,sha256=8o23MDDPtpbQvZMLbnqaryJUDSjh7iwxWCx3-mEsql4,2694 +torch/include/ATen/ops/_triton_multi_head_attention.h,sha256=RoTqUU2q23oRVtdB0wv-F1zpmlzc_oIeVkWaLOd1VEA,2696 +torch/include/ATen/ops/_triton_multi_head_attention_compositeexplicitautograd_dispatch.h,sha256=LR1pJyApaYvVV-osNbb616ljzc0KUTdrp8lIfB8GqnY,1414 +torch/include/ATen/ops/_triton_multi_head_attention_cuda_dispatch.h,sha256=NeBbeuvNhJ4_CRnnaxzzwDvab7Lv4egebBlLBNoJwJk,997 +torch/include/ATen/ops/_triton_multi_head_attention_native.h,sha256=BlErIutIExG5tkSljoELuyOd2hhU2BVIjAZ3SN2FLds,1111 +torch/include/ATen/ops/_triton_multi_head_attention_ops.h,sha256=jpHNJteqZxPdBvcql5dTmSxcRIhYHSIpwJzumZlAwE8,3366 +torch/include/ATen/ops/_triton_scaled_dot_attention.h,sha256=oE4MPKNPbalyJLzsakoK5-miOYFIeEvWzG6r1z8H9TU,1576 +torch/include/ATen/ops/_triton_scaled_dot_attention_compositeexplicitautograd_dispatch.h,sha256=vz8X1LBijz7MhuCMP1lqfWfP9LSDjC8HpJFjhh6N75g,1033 +torch/include/ATen/ops/_triton_scaled_dot_attention_cuda_dispatch.h,sha256=bDy9UkXTBmbkpbGFjHO1J9vUjhfvFQ2RyEK06rj7PoM,807 +torch/include/ATen/ops/_triton_scaled_dot_attention_native.h,sha256=EpXTRwfdSxUKI7q9JbTDCzipst8nfQokJABeh4u0HsY,730 +torch/include/ATen/ops/_triton_scaled_dot_attention_ops.h,sha256=oO6bObXAXfERTE_do0_gvNO7KKQdk8ESGCLalx5zlAQ,2130 +torch/include/ATen/ops/_unique.h,sha256=WcHpQKv9SprGyEWIVW1_VONEb26irPBoYtYXWU_n5zo,1563 +torch/include/ATen/ops/_unique2.h,sha256=aauszExLVvFNe5Ic_KuOUqq-5AaG_0E2eopSM0xA9i4,1921 +torch/include/ATen/ops/_unique2_compositeexplicitautograd_dispatch.h,sha256=RFxgYNv-dkWh-NMPvBuc9zOZ_Y2pkzqj3_7a1NdL638,1154 +torch/include/ATen/ops/_unique2_cpu_dispatch.h,sha256=SBLWdFoYgOvUSkjW-f9d-4MP5yfZJImBiL-3dJ5cIjs,829 +torch/include/ATen/ops/_unique2_cuda_dispatch.h,sha256=JPmSRM4Dy00a2hdVIPLjkhtMopQqZNePESg8t2dlW1c,831 +torch/include/ATen/ops/_unique2_native.h,sha256=uKFkfC9aY-C_rs0OJ_7Hjx_d35ojmuJ4QJ0raPW7HQY,981 +torch/include/ATen/ops/_unique2_ops.h,sha256=cpOGx2tY1qhyiOWsj4DChsk_aoI-sWpy8pMEOLgRIr0,2409 +torch/include/ATen/ops/_unique_compositeexplicitautograd_dispatch.h,sha256=WHmU251GvT2zvtZbiWnp3rSjh4X-KuOivcGoUw8JFgA,1042 +torch/include/ATen/ops/_unique_cpu_dispatch.h,sha256=hp3VmTSL8ofYTOcxEeO58D6QPP7_e_qYYhjW19vrrRg,791 +torch/include/ATen/ops/_unique_cuda_dispatch.h,sha256=Lj3bVAgjF7sNcWF8Daz2Q28ETSXVajJO8nGC81mSCoA,793 +torch/include/ATen/ops/_unique_native.h,sha256=BIiffEAd6aLUN7uRGHznwZRPTdJlq1RWWGlm3YAcRTs,852 +torch/include/ATen/ops/_unique_ops.h,sha256=Srpb1gf5HRuHZJEtE9Q9E41n8g39WOwkD4ZEZGDdums,2098 +torch/include/ATen/ops/_unpack_dual.h,sha256=uaaG0A81af0wJ0XUDAFaJQTXYrlDvm22aRUo3f3131A,738 +torch/include/ATen/ops/_unpack_dual_compositeimplicitautograd_dispatch.h,sha256=sIKK7Hdi3-F01RcfasGV7xgAC6vbkdoWehxWmbuMeB4,810 +torch/include/ATen/ops/_unpack_dual_native.h,sha256=SxtHi3xNmqfoWRYORk-EHI1k2yQ5GFR9R6xZVsgaHA4,533 +torch/include/ATen/ops/_unpack_dual_ops.h,sha256=euObiPIQLXb-haqujwP4Aok7iTjgfXj0M6g-3yaR8Y0,1141 +torch/include/ATen/ops/_unsafe_index.h,sha256=sNuwy4twcu0PET7BNbYHTAHyGcaPhCnKQQfpN1yJK6s,749 +torch/include/ATen/ops/_unsafe_index_compositeexplicitautograd_dispatch.h,sha256=aFzQG9yxHfanLutGJvX-8JsqDO_gtxVbbB6p5ouTlh8,825 +torch/include/ATen/ops/_unsafe_index_native.h,sha256=uTZW0EdSYrMW0ktqyj_YPkcIkwx9CBtdz3XRyfvFK8A,548 +torch/include/ATen/ops/_unsafe_index_ops.h,sha256=nwuMsCvnb79IzW4HRFpZKEpk_i4N90A5ALRzW2frXsY,1181 +torch/include/ATen/ops/_unsafe_index_put.h,sha256=5PqJVLnxYfPA0KWjPy2pus-INBprukIc6WQyU3526_o,859 +torch/include/ATen/ops/_unsafe_index_put_compositeexplicitautograd_dispatch.h,sha256=3EbHd1y8Wxu7F-ZERxWek_piJ0OHIujC1gnheelREM4,879 +torch/include/ATen/ops/_unsafe_index_put_native.h,sha256=YaaLo0Xr7Q9fU_tLycts3qWVhBRVsWfm93XOMb_wTVM,602 +torch/include/ATen/ops/_unsafe_index_put_ops.h,sha256=rkdONeghL6n0l4ILlDLTl5_0mUR73dIdEdieQrhNYIM,1325 +torch/include/ATen/ops/_unsafe_view.h,sha256=QLShaJVE7EnWtdfvgKpYS7bj8XOkEWQleUXvlWDaxWQ,3695 +torch/include/ATen/ops/_unsafe_view_compositeexplicitautograd_dispatch.h,sha256=__cRFBu4oiCt8v1aOz1Pu38u8ejj2H5DRi3vr3YWmJA,1333 +torch/include/ATen/ops/_unsafe_view_native.h,sha256=66Kpo16ump2TG_D_Cm91f9kzQHTUNVSCnx6zzIsufVQ,632 +torch/include/ATen/ops/_unsafe_view_ops.h,sha256=103Oj-96TFdcGVQ267hDG5rY-bJ6jko32SHMBfubUiI,1802 +torch/include/ATen/ops/_upsample_bicubic2d_aa.h,sha256=K9j7yE_Ay937WWqs731aY3cobQWQgKZnkx279FlfGwo,8034 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward.h,sha256=36X2lMJP3IAaugjWOf37dn3pK-ORAvt3viy7Nr5xl1E,7746 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Ba0Tb-YZLIz5CiAA2tui42GUGudiX_ikUbpjcb1TvRQ,1257 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_cpu_dispatch.h,sha256=X4Obc0G34yd_7xb2TWXz13cGIokiSR317U7Op6FbxjA,2303 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_cuda_dispatch.h,sha256=piT-x16GoXgcKtmcTJIUhErOiyJEBw0E_auZPHqt5Rg,2305 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_meta.h,sha256=Cqm1WMu9RdxTkaTeWMXeFWmX-L5VHrknMMm1nRi9FbA,771 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_meta_dispatch.h,sha256=rKrOvVlwtpGf53nefxTRtZFhEes4T-RxwvgDg_llixQ,2305 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_native.h,sha256=SLUMp-oBCkuNBzoN2a6_EfSCJaQHNDsZLq4_ewF6X_o,1216 +torch/include/ATen/ops/_upsample_bicubic2d_aa_backward_ops.h,sha256=bOrqBO9-WrReFiRM2fw3mSttHw96XD1ay93ly32ho3A,2826 +torch/include/ATen/ops/_upsample_bicubic2d_aa_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jx4COIvM7dD2uEJWdb2_Y1yvENkqMDGIfcAy_VsfZOw,1165 +torch/include/ATen/ops/_upsample_bicubic2d_aa_compositeimplicitautograd_dispatch.h,sha256=WIQ8FwI0c3HWCEnyGPEVoTQDpcuAO24amNP-Dxg9shs,1078 +torch/include/ATen/ops/_upsample_bicubic2d_aa_cpu_dispatch.h,sha256=47MN8CHm2XcpfDMsc9V6S594xW60pGvoj5TmWbn94TY,1999 +torch/include/ATen/ops/_upsample_bicubic2d_aa_cuda_dispatch.h,sha256=RTOQ7Lase0MDieEzpCGBrKIE_F0HNrJE3yy8GPSzv1A,2001 +torch/include/ATen/ops/_upsample_bicubic2d_aa_meta.h,sha256=RMGRFhT_awOI9iNbHZXx_8Snj9ErIV-OCZzQfcfyV-I,721 +torch/include/ATen/ops/_upsample_bicubic2d_aa_meta_dispatch.h,sha256=AvRp30DtaJK9N5UszOMn04Pbp7u9Z7HPrqaiYWxNoPo,2001 +torch/include/ATen/ops/_upsample_bicubic2d_aa_native.h,sha256=t_-OEFj9BdrqqPNyVPCx_zQLrYXVmYSPbH4u39noiSg,1254 +torch/include/ATen/ops/_upsample_bicubic2d_aa_ops.h,sha256=l0sDe_M9E69aHM-5BXj4TbRL71AKm999HMtValy8eDU,3429 +torch/include/ATen/ops/_upsample_bilinear2d_aa.h,sha256=GVIEJp6AB_dw5TwRzV371ChTjqvDAZxkYFwUy-MJfQ4,8075 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward.h,sha256=yEen51oKAc06AXodaZQinSqaOkvLLLKxk-gF7gyr59I,7777 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=FqwBShGKoApYKASGGc9ApEwwMbp2JSdOpysR1cw_RuY,1259 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_cpu_dispatch.h,sha256=AsYUWUQ6fuFAI6MPKIepbphlgGu1egs5-xrTcCSNIVs,2309 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_cuda_dispatch.h,sha256=VtUzlMCZC58h9ASWNSKzHyhY4-p6s4FkykKy9u_mKlU,2311 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_meta.h,sha256=Jy1ZsEty4iDv67YwWFltgUZ_YQLEbi9t_iaYGxDJ7_0,772 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_meta_dispatch.h,sha256=eEiwYpDQPCtabl58xHJYJRo7O8NhAY60qWM6FRdhUPA,2311 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_native.h,sha256=79U1DVcvpJCy3TY_8jN-8M-wBfT1ZRLEoRhwU1shKrw,1221 +torch/include/ATen/ops/_upsample_bilinear2d_aa_backward_ops.h,sha256=35A6TB6oM9wpZNBk5gG9789oibmRY2qXaEpaQ47ks8E,2832 +torch/include/ATen/ops/_upsample_bilinear2d_aa_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3ZfOqfyI--A2QEJFImj_VhMOkWG_1AjJWmP3h9GgyD0,1167 +torch/include/ATen/ops/_upsample_bilinear2d_aa_compositeimplicitautograd_dispatch.h,sha256=m2dC8dIUJakwmXc1wByDgJavhRlIoRj0kjut5Md36ec,1080 +torch/include/ATen/ops/_upsample_bilinear2d_aa_cpu_dispatch.h,sha256=dpHIRjSIKQX8IWvYYnHvaRZATZr6jAFUR116-grkgEo,2005 +torch/include/ATen/ops/_upsample_bilinear2d_aa_cuda_dispatch.h,sha256=uNz-VzGwFTSi6-NXuBDA3_upBrTTwAcbkoouZnkSY_c,2007 +torch/include/ATen/ops/_upsample_bilinear2d_aa_meta.h,sha256=Vdqm5p7QYvOR-RPGG2iENFBXO8-i0_dIKEVMU6aqHEk,722 +torch/include/ATen/ops/_upsample_bilinear2d_aa_meta_dispatch.h,sha256=Y1L5hCtoHbuDWsmy3AYOqh6IKPUwSq4GqHb21YY9l20,2007 +torch/include/ATen/ops/_upsample_bilinear2d_aa_native.h,sha256=gSelaCRfNrspZhCgvNVnbi8QQ74O7ZFtSh1lnsrzxUg,1260 +torch/include/ATen/ops/_upsample_bilinear2d_aa_ops.h,sha256=xzS5iw1hiLbTyU9RCqgk3c2ETgd8BYSPwrHxMByw4rM,3438 +torch/include/ATen/ops/_upsample_nearest_exact1d.h,sha256=rIxdD-s0dDuGBOQTrsN14oNTD3Vukqj1d9PfqDu_xeE,6637 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward.h,sha256=izY80J3EKWW0Nb5E0houoczF2cypcV_IgVJWdGdfv-k,6499 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=soSEz-RkOn_zFZHABp0zU8nUkDST7tz542i4n0UXYIs,1129 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_cpu_dispatch.h,sha256=2lgfVTrtrMFx3kAHvoJBestJijBm7r6P3yJPWLnIhxQ,1945 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_cuda_dispatch.h,sha256=KGIUhcxexi5_URhfl0czxerELMmNT-kwaDGmPYj7g8Y,1947 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_meta.h,sha256=mh6lKpJvC2XayToRp0-iSrr9r1FGCD6GBbbzBj-j6JU,720 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_meta_dispatch.h,sha256=JcBvj9L8Nm-jwC8AU3gEmY54XFNi7K7bZwPHZnn2hZM,1947 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_native.h,sha256=U7WaTkUoQ5_oOw_c2zQjK3naQAixkEuJOBt3bQoQ_Ro,1123 +torch/include/ATen/ops/_upsample_nearest_exact1d_backward_ops.h,sha256=gg9BG6kvynm4gHbrygWWNFjEVqE8aD8gUvsqRfm0ns0,2482 +torch/include/ATen/ops/_upsample_nearest_exact1d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=IBTU1WFJU79nMlzCLq49U5oWkpdMpNbEGZ0bYmFZG7U,1037 +torch/include/ATen/ops/_upsample_nearest_exact1d_compositeimplicitautograd_dispatch.h,sha256=z8KU1W3Fr0-d2rEO7ZxiLSysWZBnku7o29nY5IFpFgU,1044 +torch/include/ATen/ops/_upsample_nearest_exact1d_cpu_dispatch.h,sha256=whkKRJpbzSP_VF9tkZQWV6Kba1nGzJaqAlKbTNTHTGI,1641 +torch/include/ATen/ops/_upsample_nearest_exact1d_cuda_dispatch.h,sha256=NgFUnAILGz_zP2LXOQqE3axiH7IgNFCqgVDz-SwVU5c,1643 +torch/include/ATen/ops/_upsample_nearest_exact1d_meta.h,sha256=1M4B3ZfxUU7ohrcyIDQWnpZ7x40-JsUNuxxTmgT6tYo,670 +torch/include/ATen/ops/_upsample_nearest_exact1d_meta_dispatch.h,sha256=OeWTXSqpKy-0LstLlexAuUawFhY65JaLJ03leVLP-zA,1643 +torch/include/ATen/ops/_upsample_nearest_exact1d_native.h,sha256=DTvUOx4EGkbbyVuSZB86W5rA1NUJypQbEEcSPZWqkMs,1144 +torch/include/ATen/ops/_upsample_nearest_exact1d_ops.h,sha256=BgjQ78qxqzcKf-VqSqbwP9xhTW5YQttAoj-gHtC16pM,3028 +torch/include/ATen/ops/_upsample_nearest_exact2d.h,sha256=FDi8eKFY0lQCWDYYsCns0dKYH9YItaAAzM5VroipApk,7437 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward.h,sha256=G54JFHzXA3jBJlCvwCghvQ3a7TX1EVmsRjZFskesR80,7299 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KmAzy1f1Vu_p3lJmOH8a0MRD59RjPHVARaGetFzYiRA,1223 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_cpu_dispatch.h,sha256=a9w0rfYdxMN_OHMIHr_nKiDYTbz4TBoQcN9ppqdeas0,2201 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_cuda_dispatch.h,sha256=YWkNLD94Z_STr3Qufk6Ezp8MGpOnBnfiXcnt15jEgTk,2203 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_meta.h,sha256=hWJSPXLoWoNnS6WJWj72ScrCPKffes6VOvFBLIJcGuM,754 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_meta_dispatch.h,sha256=WHYwnXc3nJW3Sz2Z9doFFhppigbvHrePXhl2wh_rV7U,2203 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_native.h,sha256=95jdyvVwDxnZKoHvec95IlaYpCxqYHb-D_iKIUvPRxI,1191 +torch/include/ATen/ops/_upsample_nearest_exact2d_backward_ops.h,sha256=EPkD7easYoy9TC77mwQpFSDH44nesw8eNTkHRrp7NdQ,2712 +torch/include/ATen/ops/_upsample_nearest_exact2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=akfr9LxUyDGz1c4_m2PUrE74bDri_LJKQRJzu4g-Rtw,1131 +torch/include/ATen/ops/_upsample_nearest_exact2d_compositeimplicitautograd_dispatch.h,sha256=M-chEv4btnStET-6xDTG9LPRZNl91XpMqpWtboiCj9M,1044 +torch/include/ATen/ops/_upsample_nearest_exact2d_cpu_dispatch.h,sha256=hmsXP0ilxeP2R-ilL9OS9vzySRV-6WBIpuDE_prTSTM,1897 +torch/include/ATen/ops/_upsample_nearest_exact2d_cuda_dispatch.h,sha256=Z7QtZ6AJ7I6s-sbrEp1zSDokiU9FL17bxobvEmoAha8,1899 +torch/include/ATen/ops/_upsample_nearest_exact2d_meta.h,sha256=Cju0-z-SqT3zQ0b8tPkPHY4Irlx5cx6f5klhZtxKcnM,704 +torch/include/ATen/ops/_upsample_nearest_exact2d_meta_dispatch.h,sha256=trzZ2obViqrADxoOn4x63OY_p2yC0v2No_FYeTNIxBQ,1899 +torch/include/ATen/ops/_upsample_nearest_exact2d_native.h,sha256=9YCsJHjCx3NW0gJOl8we24QX7dwMIpgvrq_xjsSyLeo,1418 +torch/include/ATen/ops/_upsample_nearest_exact2d_ops.h,sha256=018yZgpIO8NuO20VWQmqYypUdO531WmPtcBjB0idSPE,3258 +torch/include/ATen/ops/_upsample_nearest_exact3d.h,sha256=_ZgC01eLS0fSFnZ8W5bn3S_H_hw69PjRiFXQIBpI62c,8177 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward.h,sha256=nCT51mMDB_JT1X3os_4QHENdNH-LHHVuah9Koi9qjLc,8039 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KGtDD6TCObCLLuDEsPJS2mM0GRaWAhFkPDaTP0EENYM,1313 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_cpu_dispatch.h,sha256=oT0M8hBiar1rZxBCGgLJ3OErMSd73m2bjSGPj2E4nD8,2445 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_cuda_dispatch.h,sha256=AhfpYmmzXs-FbgOetoOdl1lhj1q1OY30Ogz865pe5aw,2447 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_meta.h,sha256=u2zhXjoL_FqF4LitXX_jSm6Bx6GfUVA3JdxH22RHLFU,786 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_meta_dispatch.h,sha256=MO8a7VpR3kxVpNxZypMT9XCy5B6-Js-5m-iwnX7qbqE,2447 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_native.h,sha256=h5UOp3BONdTtfU6EnDsLmJVWysYnHMnTBzlZkv3FBhg,1255 +torch/include/ATen/ops/_upsample_nearest_exact3d_backward_ops.h,sha256=yKhHregwue4mcbytOAAMez-4IWAasKTmMb9Qk_k3CSg,2930 +torch/include/ATen/ops/_upsample_nearest_exact3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=-DsWv1qmyHNvSoki1Unl7hXtXDMW-SvUIO5K92963Bo,1221 +torch/include/ATen/ops/_upsample_nearest_exact3d_compositeimplicitautograd_dispatch.h,sha256=NetG3SoHa5e7LoiJLOalnBlCRoIBpXbkcng7RVTYlcc,1044 +torch/include/ATen/ops/_upsample_nearest_exact3d_cpu_dispatch.h,sha256=4BYMdYAd4YmCuJC_AaGxjpzKl-B-Wa3ZS2oIxy2KXGs,2141 +torch/include/ATen/ops/_upsample_nearest_exact3d_cuda_dispatch.h,sha256=TN1hUXtyrzWp5URI42yKygC-HmbM6bBAwFV1tH-uo8c,2143 +torch/include/ATen/ops/_upsample_nearest_exact3d_meta.h,sha256=-_g0KbMVqbB4y-Vv5cioOiDpopRmFjkbAtXJSzS5-Lw,736 +torch/include/ATen/ops/_upsample_nearest_exact3d_meta_dispatch.h,sha256=GwE-6KNC5IUdDHtxQua0p_lFTFVrcfmlqzE6lFjMOSg,2143 +torch/include/ATen/ops/_upsample_nearest_exact3d_native.h,sha256=Ujdda_Ov2wh1vJUI11lfrrXyEVnWRURvwTxpapxH-zg,1527 +torch/include/ATen/ops/_upsample_nearest_exact3d_ops.h,sha256=h5kTx6IQTy9FOIO6nAlpXut9b6TRu303OrVW8LidZzY,3476 +torch/include/ATen/ops/_use_cudnn_ctc_loss.h,sha256=xW5UG9ZPMK6S6lYSpz3oxpQbnEeSBzVca887qgd-tIM,1333 +torch/include/ATen/ops/_use_cudnn_ctc_loss_cuda_dispatch.h,sha256=_JdPWp-bKk5rX5Kl_Rcyfc_raJGUKB1uoELuKQt6LTw,1018 +torch/include/ATen/ops/_use_cudnn_ctc_loss_native.h,sha256=bwJNczL-4GBDMK3ehPdg9L9nE4aV2IJ3o35SXRFEHAw,790 +torch/include/ATen/ops/_use_cudnn_ctc_loss_ops.h,sha256=h9EsRG2eToyiRF_v91bG36w1H01ARfWOCa2mlIWWkF8,2298 +torch/include/ATen/ops/_use_cudnn_rnn_flatten_weight.h,sha256=CKIs1ohuoa5iq3Lb0A-FEMwqkuuOEiw6TIoEwM_6_BA,671 +torch/include/ATen/ops/_use_cudnn_rnn_flatten_weight_compositeimplicitautograd_dispatch.h,sha256=i6BU07fqmo_ZVFMdOr5cuvGL-g5jXTnHCC4xqyoCG6A,758 +torch/include/ATen/ops/_use_cudnn_rnn_flatten_weight_native.h,sha256=2BWNYHuwkOXE0oR7FXJg36gdw3bkc8V3FOTVul0bU9o,481 +torch/include/ATen/ops/_use_cudnn_rnn_flatten_weight_ops.h,sha256=8vsONtUEyv1-OyR_bSEalS_2YLlANwbobrcUn_JXuFk,939 +torch/include/ATen/ops/_validate_compressed_sparse_indices.h,sha256=SHv8ZcMQu6FggSDAt-vi8KtnnThBM1Rz5hj6ydGye_k,941 +torch/include/ATen/ops/_validate_compressed_sparse_indices_cpu_dispatch.h,sha256=JlPzyXxgay2-czVFdBPfVlK1Y6MhjCdKlDjFaF4hmew,837 +torch/include/ATen/ops/_validate_compressed_sparse_indices_cuda_dispatch.h,sha256=XzfESsww_gubv4HgOO0Wbv7bb8D79GjWDfn8VMUdI1w,839 +torch/include/ATen/ops/_validate_compressed_sparse_indices_native.h,sha256=dunnUL4sx2C50CbkZV7PozXzSoaLoPn7TR8Yy35kmmI,784 +torch/include/ATen/ops/_validate_compressed_sparse_indices_ops.h,sha256=X2xiIy-OlWJL0JCTFoBnqdk36YFWCw38Yd-Ylz6qpNk,1343 +torch/include/ATen/ops/_validate_sparse_bsc_tensor_args.h,sha256=8_2xDTz-X-0K2sNqBAWLhDk5ma9O8S4JV3n8ZjP3CSM,898 +torch/include/ATen/ops/_validate_sparse_bsc_tensor_args_compositeimplicitautograd_dispatch.h,sha256=rl7t3mamj1oDgb1XdfwfKqimPIEY3i12sF8x2xNkCqY,873 +torch/include/ATen/ops/_validate_sparse_bsc_tensor_args_native.h,sha256=pp9CFi6_0GXUivlnjcYWKgk7w4Zh-RCPgx_o0mOdOCI,596 +torch/include/ATen/ops/_validate_sparse_bsc_tensor_args_ops.h,sha256=RRjSc5zatqnMG74atyzUG9wIlcewIO7lU2b0gfSpXSQ,1313 +torch/include/ATen/ops/_validate_sparse_bsr_tensor_args.h,sha256=-3iBa3-hNvrDWayHf8dz_uJL0ONTBradcwP7i7MJP-U,898 +torch/include/ATen/ops/_validate_sparse_bsr_tensor_args_compositeimplicitautograd_dispatch.h,sha256=4DPwWFqCNHh2d4QhbvkI0uRTb2vnT0vG6qWS5Bn0O3U,873 +torch/include/ATen/ops/_validate_sparse_bsr_tensor_args_native.h,sha256=uOf7Hay9FpSnmyRn_6DHUCTjOD46q45-wo2jE-QVOsI,596 +torch/include/ATen/ops/_validate_sparse_bsr_tensor_args_ops.h,sha256=iaCqOb-Gs3FYtgzsch8lblm7CgNM58s1tfyjo95E8Q4,1313 +torch/include/ATen/ops/_validate_sparse_compressed_tensor_args.h,sha256=QKXn0zCuO8GA3WbQQMQ4OEKdrxp5W5YSj_zEpQiYqKk,992 +torch/include/ATen/ops/_validate_sparse_compressed_tensor_args_compositeimplicitautograd_dispatch.h,sha256=SFeuUQe70FZIJWGkTW-YXMu24dsH8sBn7pNEjQbJ-CU,907 +torch/include/ATen/ops/_validate_sparse_compressed_tensor_args_native.h,sha256=rElxztHWKO9FlopsVFeXeA5wjmWvKsvVMUPTDAuYoyc,630 +torch/include/ATen/ops/_validate_sparse_compressed_tensor_args_ops.h,sha256=JyirtCwe5nT-P3ZTKIMD9Ggg1D58IR8OEUjchsNpaa8,1423 +torch/include/ATen/ops/_validate_sparse_coo_tensor_args.h,sha256=zf77rCi_l1uWkUysdX_Gn6tTzJXuG7WIIJIitGfb9aU,904 +torch/include/ATen/ops/_validate_sparse_coo_tensor_args_compositeimplicitautograd_dispatch.h,sha256=KMzU3REMpR4wp2vCyYlGuG3SWrYvBnz6Y-P1fMoIgVI,883 +torch/include/ATen/ops/_validate_sparse_coo_tensor_args_native.h,sha256=l6SyarDMcbJ7u_C901_fNsJ8ropHdYg2ymN6k7TTYvs,606 +torch/include/ATen/ops/_validate_sparse_coo_tensor_args_ops.h,sha256=tUcoLEz1_evP0CFnsWcgthSqoEgPBhcT56u_O1_jZQg,1308 +torch/include/ATen/ops/_validate_sparse_csc_tensor_args.h,sha256=F-ksdoyR7BExZD3EtXPk3rf6a3Km0UDuikyHOvJhdas,898 +torch/include/ATen/ops/_validate_sparse_csc_tensor_args_compositeimplicitautograd_dispatch.h,sha256=jEPx5Wzd0rft4gt_rXby_TaUWQrr4xXeQSEDSi8R4-8,873 +torch/include/ATen/ops/_validate_sparse_csc_tensor_args_native.h,sha256=gyljAuqB3qpgqgcV3aahexHe6xr_7mb2XYZ08SQYrCU,596 +torch/include/ATen/ops/_validate_sparse_csc_tensor_args_ops.h,sha256=Dr47CC7ja4z3PQvmQNaD-yjC5rNmx9nSwAVLxifa4ds,1313 +torch/include/ATen/ops/_validate_sparse_csr_tensor_args.h,sha256=DKiwuGzZ3t4WV5WxZQv8EC_E73hFzNPVoC1SlKWs7Ao,898 +torch/include/ATen/ops/_validate_sparse_csr_tensor_args_compositeimplicitautograd_dispatch.h,sha256=97tjm0S9CMuHTyZOxoWvxIWSts1fGu-oZxXsZIaAqXE,873 +torch/include/ATen/ops/_validate_sparse_csr_tensor_args_native.h,sha256=MVsn0ISY5gczXuYfDuVYe24XUy1JHZapHmXzxKlPYXs,596 +torch/include/ATen/ops/_validate_sparse_csr_tensor_args_ops.h,sha256=3tfxgKKVkKM6rwnVwhOoLf31a9dk0DRPuOI3vuuqYhg,1313 +torch/include/ATen/ops/_values.h,sha256=cVXGMY-7bnms3e-zGf0U-Lw_WiS5ogzEw0XcJvLmEVo,492 +torch/include/ATen/ops/_values_copy.h,sha256=lVpjIZ2vs9m4upW-hOjFoeIHZMzannKNreAdxfPdj3U,1075 +torch/include/ATen/ops/_values_copy_compositeexplicitautograd_dispatch.h,sha256=GUoRJIEBtqQUJUch6ZeSi4AL4qcdBTcunlETGm79B7Y,879 +torch/include/ATen/ops/_values_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Kl9X6GR53jLoaeVz6TmqnybLLozZ6eoMceGsJy5ECfs,796 +torch/include/ATen/ops/_values_copy_native.h,sha256=1GSknBiSqZYuufc42FDv63zLyD_jG1HmFIj-xTuIxHA,577 +torch/include/ATen/ops/_values_copy_ops.h,sha256=dTG-JF5s82k-LrtQLMx1WNZef3VrZGa_sBbvTSAnk48,1626 +torch/include/ATen/ops/_values_native.h,sha256=5bhPaA31zidAxZbpeEG3kktMrUffoZzhu8Yp-7Wm8mo,495 +torch/include/ATen/ops/_values_ops.h,sha256=G61xxYj8kWYYyC5vYoXstjvXxD412RQJZoed40hoh50,976 +torch/include/ATen/ops/_version.h,sha256=uqXg9zjk-3J946AN1Q7ZFSd3gsX_gwFB-5OyFOLoomc,493 +torch/include/ATen/ops/_version_compositeimplicitautograd_dispatch.h,sha256=VQe1SgTRZUcc1Q89pAXI0sPrXrCmizxErnitfKmkEiw,763 +torch/include/ATen/ops/_version_native.h,sha256=AfAlL0xhB_R0euFe5VDKu_xjvjWZkUVhQkrRvOajEvw,486 +torch/include/ATen/ops/_version_ops.h,sha256=eHq5xXvANEty1z3dnXxzF6FQgZoy32mJcc5XipXsjuQ,961 +torch/include/ATen/ops/_weight_int4pack_mm.h,sha256=BcUm2dwrNr9NnY5i2XoIumH4zViUfPTo8YS4qxB0a8o,843 +torch/include/ATen/ops/_weight_int4pack_mm_cpu_dispatch.h,sha256=f-RtE70jrbwLPSAzoH4jUtlCB2XIpJDDb7GwbTml23o,813 +torch/include/ATen/ops/_weight_int4pack_mm_cuda_dispatch.h,sha256=K9-5RIQv8I6f8j5D2IiPa1ppKIyJw6nbESXREfI4HDg,815 +torch/include/ATen/ops/_weight_int4pack_mm_native.h,sha256=rFqt8brlj0Gph2Kw7Yl2MeKm_Lv1x8Q4UMk6Zn_JJ8M,736 +torch/include/ATen/ops/_weight_int4pack_mm_ops.h,sha256=je8h_EGRAW7fExjjYH1FYpaLWlAP09fC6M_EizWzryk,1267 +torch/include/ATen/ops/_weight_int8pack_mm.h,sha256=O6U5DFB4GgK_J2u-Ic94-XYMZQDzr44Y6AzgirA7o9A,771 +torch/include/ATen/ops/_weight_int8pack_mm_cpu_dispatch.h,sha256=IIlfdUaGwPaqLLqivBiaP3DMLwu-zb-XbnKuVls06qk,785 +torch/include/ATen/ops/_weight_int8pack_mm_native.h,sha256=YnIDRn5dHe_uHz_QAqlRRN-hnxABzeM14Hqsvayd2mg,556 +torch/include/ATen/ops/_weight_int8pack_mm_ops.h,sha256=prGNJYMQjvxbMn9reOljwDvnBpG0xJRICt4xQdJ_CUA,1178 +torch/include/ATen/ops/_weight_norm.h,sha256=QiYg4TjMe7ktZ-GHAwgJOxNSHXBtxZnG1O6q8we_fAU,706 +torch/include/ATen/ops/_weight_norm_compositeimplicitautograd_dispatch.h,sha256=72xdbSxcp0pSanEpxTjc7JParWoyAh7wxoJDIhhDgA0,804 +torch/include/ATen/ops/_weight_norm_differentiable_backward.h,sha256=exvxwcPIQCOrSUhLVqnr9NFStqo4VQAnKCOEC2qMbxI,984 +torch/include/ATen/ops/_weight_norm_differentiable_backward_compositeimplicitautograd_dispatch.h,sha256=6FfonTNV7IpjA113GFW1ZGh3359dnWKChhuQSCHiOo0,922 +torch/include/ATen/ops/_weight_norm_differentiable_backward_native.h,sha256=lZk9Jrcmq4_LDuO0Gxi2RRWvv3HNdivH0gUSC313yJo,645 +torch/include/ATen/ops/_weight_norm_differentiable_backward_ops.h,sha256=ZuQANowhjFiymWs-Q07monxclLzImMgWVppJBShbsyY,1480 +torch/include/ATen/ops/_weight_norm_interface.h,sha256=L5RJC63oAd9Qo6V81YbiWJF2LyeHDfnlz_zR3xdonlk,1551 +torch/include/ATen/ops/_weight_norm_interface_backward.h,sha256=wBcNWcDKsucyqSQGUYj5rKZRgZ7MVjlivyc8YPjA8Po,2084 +torch/include/ATen/ops/_weight_norm_interface_backward_compositeexplicitautograd_dispatch.h,sha256=KeuaJ5RYGGtOqiKBbBgAbdBRDmglt9vvzA-z4LOEIy0,1217 +torch/include/ATen/ops/_weight_norm_interface_backward_cpu_dispatch.h,sha256=Zt3kPCHxlkUOEBxVnVrB763dq-1XfgHOK298LrdueyE,873 +torch/include/ATen/ops/_weight_norm_interface_backward_cuda_dispatch.h,sha256=PAJU5hlv45Hf54SNcN2Z1RZem_7u0gczcNYAWs4tBsc,875 +torch/include/ATen/ops/_weight_norm_interface_backward_native.h,sha256=YrYidpKCOVrTzQXFNKDcdrVAZOU5XFG9oeB9yNY7FPg,1087 +torch/include/ATen/ops/_weight_norm_interface_backward_ops.h,sha256=0eP0Tob3IVclSXDry6-G7uowjmnnVOoPspxuOPt5G08,2668 +torch/include/ATen/ops/_weight_norm_interface_compositeexplicitautograd_dispatch.h,sha256=9MFh2LBtWygir10PGloql-X_3tFJJCd727a62LCMG5o,1059 +torch/include/ATen/ops/_weight_norm_interface_cpu_dispatch.h,sha256=IjGW79hTAoGDV6hN7OUo1RYQSgdjeBYDSzhdeuccVa0,795 +torch/include/ATen/ops/_weight_norm_interface_cuda_dispatch.h,sha256=eyK0rAmzHhKbBk020hL59btp6wAppzXkZpKTQgcrKwE,797 +torch/include/ATen/ops/_weight_norm_interface_native.h,sha256=PGVWDd6iwA0ew8JTnytOa_GazDJjlCfKm8pCP8sy1Sc,851 +torch/include/ATen/ops/_weight_norm_interface_ops.h,sha256=4HPJhcMjEmddnNzd6m4jfxvfiQGSNGGbkvAF-wUZFw8,2160 +torch/include/ATen/ops/_weight_norm_native.h,sha256=jy3Vx5uMEQdzLjfhTpcrUqxpCE6P9mwfafWsMD68RbU,527 +torch/include/ATen/ops/_weight_norm_ops.h,sha256=lvFNc55xUUnEx2AhFpS9z4ehlSvtshmXPLZHgDJjf7U,1096 +torch/include/ATen/ops/abs.h,sha256=7NWcK4tY0s4r74wMHXzWAENzF2jhgLZ1ej16OSiwuOQ,1118 +torch/include/ATen/ops/abs_compositeexplicitautograd_dispatch.h,sha256=Sd14UZRfkTCXhNMw0kzSi9_XNtp_kwSBd-kAPnpUWrY,809 +torch/include/ATen/ops/abs_cpu_dispatch.h,sha256=guyZY2PA6mb3ZW8ApEw8_dWj_yPTUfHqFD_ZjjHBv6k,817 +torch/include/ATen/ops/abs_cuda_dispatch.h,sha256=BH8wfKMo0aJ9_ZeRiRbjXCGIaqjc0dxQLHjJZtpvY_k,819 +torch/include/ATen/ops/abs_native.h,sha256=ZGlX4O6rjAFHWF0DFvi-X7Z0mIhUSgbgFKrjP5scMQ0,1134 +torch/include/ATen/ops/abs_ops.h,sha256=5_loAyBNGiXWAcrBV324Z2ivRkd_QxRQqIJxxxPAraY,2095 +torch/include/ATen/ops/absolute.h,sha256=9igye32XRpyD0ZhF1qfBh5IIjUg_Q74-PBh19M5hD_E,1035 +torch/include/ATen/ops/absolute_compositeimplicitautograd_dispatch.h,sha256=aCllNnGdo-W3Mi8_NeGVbjB8PQch7PJaQDUuuWTz_mg,980 +torch/include/ATen/ops/absolute_native.h,sha256=sOFR-xGOS57M_y0xVSpXvdeqLeQRlQZIEIwU-GhGzKE,622 +torch/include/ATen/ops/absolute_ops.h,sha256=mSag_6aFmyUM125g8NNbN0EkhXFLTs5GbGvQbKJdvDg,2140 +torch/include/ATen/ops/acos.h,sha256=7IYjU9SBNNuOJasPhTNvB_iRXsRN34MIWBDpdGfj3h0,1131 +torch/include/ATen/ops/acos_compositeexplicitautogradnonfunctional_dispatch.h,sha256=7m2UUrN6V0OifYWhq8Y4JdyeU27SaP4jsE7yeFNDkno,837 +torch/include/ATen/ops/acos_cpu_dispatch.h,sha256=_mWbzBse4usazcAkWTyaYcigoywudsk0Of_dlUUMyLs,920 +torch/include/ATen/ops/acos_cuda_dispatch.h,sha256=nHWrZz-0VZnbDGWKYT1YoO0l8UJXhjLl_bd_QxTFC6o,922 +torch/include/ATen/ops/acos_meta.h,sha256=W9df7qjF-RT7P4HJ84Vmudb8pehMVFMu4TtXD63DWBI,584 +torch/include/ATen/ops/acos_meta_dispatch.h,sha256=emksaFT8ie8u9RZaUXkWI1PmR1bLCQhFbM1xnO49M48,922 +torch/include/ATen/ops/acos_native.h,sha256=LtN06lwzNz9oYz9AReQSizpy9b7c18TKpSqAOcZMibA,601 +torch/include/ATen/ops/acos_ops.h,sha256=GZKP3FqYRG0qyWkaYZMLYNI4MEtNr4hi9BJNH82CyOs,2104 +torch/include/ATen/ops/acosh.h,sha256=EvOtCV4lH-zcYUiB0rXiF4ARWWVyY35HyRHT8vLFH_M,1144 +torch/include/ATen/ops/acosh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=lvTlS6z_YYckApSKjIHMwcGS_4rHdhYtbyohz0Wlw6o,839 +torch/include/ATen/ops/acosh_cpu_dispatch.h,sha256=tSsT1qwMLbVIY3CHXWHQ4mi3yULlk6jglSXeOdIMzME,924 +torch/include/ATen/ops/acosh_cuda_dispatch.h,sha256=-xX9J6cRkppVrvGeEfSGMNPMQDEisgTvt4-eht5YVfM,926 +torch/include/ATen/ops/acosh_meta.h,sha256=gXIBzeKwO9qIEIaXObFE6ps_YfC5yZRyHmttW59j65M,585 +torch/include/ATen/ops/acosh_meta_dispatch.h,sha256=xHl13gBpTEhvg3VCexx1NtNv9vfED9X07Tk57EBaYQI,926 +torch/include/ATen/ops/acosh_native.h,sha256=FueJ0mR5W3Nf-J32yDQgnTNRKSuhR2sjIwrI4LMsCqY,604 +torch/include/ATen/ops/acosh_ops.h,sha256=kjjNzLZhzN04HhYVAYQVMmkkWKTgvZr3-TFIbVLaIRY,2113 +torch/include/ATen/ops/adaptive_avg_pool1d.h,sha256=14szbTomPravAVCZfAnQ7pRj5U23pGiAf3cASv3NE6k,739 +torch/include/ATen/ops/adaptive_avg_pool1d_compositeimplicitautograd_dispatch.h,sha256=doSzMvk_5-_s1cYEsx_hdPOIlJnNA7bM-7ilOjVir4M,806 +torch/include/ATen/ops/adaptive_avg_pool1d_native.h,sha256=kqsfuujzMOw4-e8bzFrK1FXQA10d5KTWoJ95Ur2i_Bg,529 +torch/include/ATen/ops/adaptive_avg_pool1d_ops.h,sha256=z-ZTpOpDzKrPuk3cQqZhVNtuddywbhCsFC3exq1YLiY,1101 +torch/include/ATen/ops/adaptive_avg_pool2d.h,sha256=MGmtt80bN_NtSgntQYuDtw8IfChNL3y8I21ciwOs2TE,4128 +torch/include/ATen/ops/adaptive_avg_pool2d_compositeimplicitautograd_dispatch.h,sha256=t58FI59zAhX2cTuIzvks0DctrAqrGLo1xp3oPn2oHAo,913 +torch/include/ATen/ops/adaptive_avg_pool2d_cpu_dispatch.h,sha256=TgCv13yCD1tH1Vq7ThKkaZdUxNJu5Rwe2byz8WiwuQg,1170 +torch/include/ATen/ops/adaptive_avg_pool2d_cuda_dispatch.h,sha256=wmhJw_rDfYi6KQPTe9931Gl83GKVUl30uRpAYbvyikM,1172 +torch/include/ATen/ops/adaptive_avg_pool2d_native.h,sha256=v4379_eMbe5y_eoZIrvp2zyCjEuyqDsY_Kjsh2ag1wk,921 +torch/include/ATen/ops/adaptive_avg_pool2d_ops.h,sha256=pcGba5OIrKKbh3kI1H2-lEvVwLI_UUuGGRbR1eOjoog,1888 +torch/include/ATen/ops/adaptive_avg_pool3d.h,sha256=ANPU3ikblAdS-Pf8TQ3AlZI30s8xTtPw-PTlXmcaWhY,4128 +torch/include/ATen/ops/adaptive_avg_pool3d_backward.h,sha256=VInlvkUkUU-oTI1nWHHDF_4kbPZQ_fVyNEnhhxP49F0,1234 +torch/include/ATen/ops/adaptive_avg_pool3d_backward_cpu_dispatch.h,sha256=v6wC2GCnAzBHhY85cfPPRnbOCOto6mPhp_VFvACFfwE,945 +torch/include/ATen/ops/adaptive_avg_pool3d_backward_cuda_dispatch.h,sha256=bFu-IufA6K9L-EadptOXvHGFDEbn7IevfhsZbXs-HQU,947 +torch/include/ATen/ops/adaptive_avg_pool3d_backward_native.h,sha256=6vUOgJZdTvWNgLO4szAcO54GRz4cM5mtJulyyeW-sjY,720 +torch/include/ATen/ops/adaptive_avg_pool3d_backward_ops.h,sha256=b02yK8wkja6Xn81kPD8_uzwL0AuiWIxFdKaontjOU9c,1269 +torch/include/ATen/ops/adaptive_avg_pool3d_compositeimplicitautograd_dispatch.h,sha256=aK7I9UhQVql8xucJeUbx0XkuiwbGgAkAJtTPpT20xc4,913 +torch/include/ATen/ops/adaptive_avg_pool3d_cpu_dispatch.h,sha256=Oyft_GQQdDU8Sqq-4DhG7Gw8LiRQdcJ1IhY5jpDS38k,1170 +torch/include/ATen/ops/adaptive_avg_pool3d_cuda_dispatch.h,sha256=Jgk69BHO0qGFGxciujaApOHckujk_uuf5w5_VFjGzGk,1172 +torch/include/ATen/ops/adaptive_avg_pool3d_native.h,sha256=FjB1zU-1vMczm2LFAGqLzYVb2DmvaAQhbdCx7MFzRqw,923 +torch/include/ATen/ops/adaptive_avg_pool3d_ops.h,sha256=M3psuKatc3eK6G7KVfPhe7NfIK4JW_bWdcHTifr9A9Q,1888 +torch/include/ATen/ops/adaptive_max_pool1d.h,sha256=RUgIyRPFGtVQxBPRizkQ55Php45kiPaIv8KSO9MmvZg,774 +torch/include/ATen/ops/adaptive_max_pool1d_compositeimplicitautograd_dispatch.h,sha256=te6hl7u04jOMEM6Bv0pOyQ6fnJh6Nyh8iOIH_BpU5Rg,831 +torch/include/ATen/ops/adaptive_max_pool1d_native.h,sha256=WVrghxSm1o5Xbw9l1uS5C-9dwMxr3OtlYnTAfuRSmwk,554 +torch/include/ATen/ops/adaptive_max_pool1d_ops.h,sha256=5Uto2fSXm9Uo6VxapRHSEYrFIftA48Oaz3nsnrhXR8E,1186 +torch/include/ATen/ops/adaptive_max_pool2d.h,sha256=_jVUAw5gE9RK2crSjPwNQ_az6eEC2XGciIIAYhugyP8,1550 +torch/include/ATen/ops/adaptive_max_pool2d_backward.h,sha256=eQ8aDYGDQgKHNUg3oyq1mK9seN8JtIS4_uDHZJ48yQM,1659 +torch/include/ATen/ops/adaptive_max_pool2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Vcb_6ELEGK2EcZofQpiLp4hyAwqio5Pz2wUS6zOfofE,872 +torch/include/ATen/ops/adaptive_max_pool2d_backward_cpu_dispatch.h,sha256=Y92LqbI_PYF_A_GHOSML0rm7ZhoXlOBk9ozXUT_qg88,1137 +torch/include/ATen/ops/adaptive_max_pool2d_backward_cuda_dispatch.h,sha256=QSGHqMXSuCoFT4nX8HvDpOpkkrCIdazlvatyzS5gcog,1139 +torch/include/ATen/ops/adaptive_max_pool2d_backward_meta.h,sha256=52J_MYQ7dtdbvMINEtSUiVPXXk0yhsY9h7idOvaFGok,668 +torch/include/ATen/ops/adaptive_max_pool2d_backward_meta_dispatch.h,sha256=16jjySoVenD0G_MpOlRxESreNPcV25gUZpzEXeU566U,1139 +torch/include/ATen/ops/adaptive_max_pool2d_backward_native.h,sha256=CU4Jbux5Qa_EhPPt9QjjX4MKTxRMfiSGSAsmP6tOO6g,1001 +torch/include/ATen/ops/adaptive_max_pool2d_backward_ops.h,sha256=2PWrGxGVOiurUBSdZF0aA3uGOyeVE7YdyLSlXAqeARQ,2156 +torch/include/ATen/ops/adaptive_max_pool2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=aTrCt6bg9EtQzFEIUGk94x14eDa7xcdTcRci9zhBGcs,857 +torch/include/ATen/ops/adaptive_max_pool2d_cpu_dispatch.h,sha256=3rjzlZNn-GDG5yPtmg3ukZuhuh-4mQ0lD9lGKK7F9Ao,1126 +torch/include/ATen/ops/adaptive_max_pool2d_cuda_dispatch.h,sha256=Pe3PvthDJrktjTKO6Xn0pfbQk7IfHyLP7qsUYgJv8kY,1128 +torch/include/ATen/ops/adaptive_max_pool2d_meta.h,sha256=JsjkALO9ec9yweoLCp5TA2xUMqm0HAJvQHLXcJ8elOU,628 +torch/include/ATen/ops/adaptive_max_pool2d_meta_dispatch.h,sha256=ojHCji9QFmLNqeB4XyiNUTv6h2IB54lyusJ2LxdjOJI,1128 +torch/include/ATen/ops/adaptive_max_pool2d_native.h,sha256=V-Qwrfm1JzrLQJULPt2XwXIprFdOKPTYpiH4yfdlNXE,936 +torch/include/ATen/ops/adaptive_max_pool2d_ops.h,sha256=5okGZgclefyRYK06uuYgVVQM3pDQngSUhtKxppWhE3M,2116 +torch/include/ATen/ops/adaptive_max_pool3d.h,sha256=VgHZzMMCEXN659hTQQJP9QFrJ01uG5Gozz2N354a15w,1550 +torch/include/ATen/ops/adaptive_max_pool3d_backward.h,sha256=rxVhiImjT3jafO7Wds9RS9VyReh8-UbzI4iDSCkJI_M,1659 +torch/include/ATen/ops/adaptive_max_pool3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=eNU_1o8hj1AWYfKIUIFDFYSwZ7sv6zXgVTnUsAdjMbY,872 +torch/include/ATen/ops/adaptive_max_pool3d_backward_cpu_dispatch.h,sha256=EmjSFgOSv3ieAJv_OjabIyVNFqdwHKxjAUzf0doAWWo,1137 +torch/include/ATen/ops/adaptive_max_pool3d_backward_cuda_dispatch.h,sha256=S3-VDdYDIrjMImEjeWftxuEVppzYwoFX85UPPNj1cf8,1139 +torch/include/ATen/ops/adaptive_max_pool3d_backward_meta.h,sha256=lZdQBtpV9p6kNKl39pqrln7Ydg6XEFR6Xm2bRQk2ZYA,668 +torch/include/ATen/ops/adaptive_max_pool3d_backward_meta_dispatch.h,sha256=c2UMye4JyuLsqMW4LU-tlaqJ6edEcXKOnsKUUWMCPyM,1139 +torch/include/ATen/ops/adaptive_max_pool3d_backward_native.h,sha256=Ymwki7EgX7UCnY6vaP_CqdtIS790E-v_kuBeQZnL85Y,1001 +torch/include/ATen/ops/adaptive_max_pool3d_backward_ops.h,sha256=bg9mjTPj_4bDTDL6b1o2qnhq5o3GbjroOaiJwH5bq00,2156 +torch/include/ATen/ops/adaptive_max_pool3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=lfPoQeG9XlF2KFsoXnSts9bueIh1KRiml78ivhBVVHY,857 +torch/include/ATen/ops/adaptive_max_pool3d_cpu_dispatch.h,sha256=Z6Z2a6x6qbbDFeMJOOAWiEG7yW11lu92JM7Kj2hv8uw,1126 +torch/include/ATen/ops/adaptive_max_pool3d_cuda_dispatch.h,sha256=9uMJCaI-YgJByAnN-lPBe5ZifV3rVgCN41QsLv1ILCE,1128 +torch/include/ATen/ops/adaptive_max_pool3d_meta.h,sha256=CxhoFD85MY6RUB6HesfcPGa4NwGVkXaATTAZQrKYc5k,628 +torch/include/ATen/ops/adaptive_max_pool3d_meta_dispatch.h,sha256=aWkrLvG6luVX0kuPCRDyNaT-LGV3LZdCMtRE6xG_jlU,1128 +torch/include/ATen/ops/adaptive_max_pool3d_native.h,sha256=Zmuy2IeKoL9eZXqPXuEtHmc1bD030q2oQoCo4Z-yOO4,936 +torch/include/ATen/ops/adaptive_max_pool3d_ops.h,sha256=eDrdZn2oBuHFtY1fHcBSJGq1aEMzE-eYe3f80keSXZ4,2116 +torch/include/ATen/ops/add.h,sha256=b2BuBnhqZ87XuRDOfHlTUrc0Ex03Wk_LupQzrnOuoiU,2126 +torch/include/ATen/ops/add_compositeexplicitautograd_dispatch.h,sha256=j0HNl6Gh438d0W_bXbYoOQRHdwqomzXlfil9BYvvW3w,1174 +torch/include/ATen/ops/add_compositeexplicitautogradnonfunctional_dispatch.h,sha256=xTZVQnxCa_zJUKytiGdSGOUDu7csGECwJVY26eQTkP8,943 +torch/include/ATen/ops/add_cpu_dispatch.h,sha256=1WX_RIqo8xb2cnpUm-ShjUWP7y6QOlVmU5OAfQBLQCo,1130 +torch/include/ATen/ops/add_cuda_dispatch.h,sha256=CCTkCi5g8XV-DJTx8SXCaiER0lDZfZjmcq-sfaCaJ-w,1132 +torch/include/ATen/ops/add_meta.h,sha256=Y28Way2v6PYG34hzj9QzxetiV7fwte1hDU6SeCQHZB4,642 +torch/include/ATen/ops/add_meta_dispatch.h,sha256=niarZ4Y-q3sdm4bTnG7umOl9AACTzkOZ5qp9JcRXkiI,1132 +torch/include/ATen/ops/add_native.h,sha256=M7kxPdnvzR1lxWSzowZzYevgPel7NyfF6L278GKxFsk,2949 +torch/include/ATen/ops/add_ops.h,sha256=41jOg6s039Cb8hH1mXAb6bxbWqPNl8Imk8ZaaGlu7MI,4907 +torch/include/ATen/ops/addbmm.h,sha256=Wp1FkvOCxj5s1--2Vst_kBXy0quYeQrddc7-j-_r5eE,1611 +torch/include/ATen/ops/addbmm_cpu_dispatch.h,sha256=9K63lzHWiGQKkohJm6rdZV-s56Ji7lSTExuQwyztFPY,1360 +torch/include/ATen/ops/addbmm_cuda_dispatch.h,sha256=fl_i4wrG3FQLzCM9GGRx0FLBfAl_oTBeaIGmLkoURQA,1362 +torch/include/ATen/ops/addbmm_meta_dispatch.h,sha256=u6BqOgk1T64Kf8Y3Qfy1RdHkdU028zTEV14g2WMLtsM,828 +torch/include/ATen/ops/addbmm_native.h,sha256=i0CdPzwqErgzCe0RgtAA5q3c1VvDJzfH3AjibEY7rh8,939 +torch/include/ATen/ops/addbmm_ops.h,sha256=6RT3_qGKVZfYJdzbhH5yTQDd4M3n4GPr5S_W_msYop0,3181 +torch/include/ATen/ops/addcdiv.h,sha256=lfG0FChMwaK8iLXNZ3RNH_eYycMGLZ1RmwMX7llg8K8,1497 +torch/include/ATen/ops/addcdiv_compositeexplicitautogradnonfunctional_dispatch.h,sha256=O2hmGLuG1uMX3QbWpkkKUxG1bTQVcsdR-WGXc6w1lYE,1011 +torch/include/ATen/ops/addcdiv_cpu_dispatch.h,sha256=UaOpX_jcOji4dy8OyAaG2jeBPeI7uiAFWRK7XXoESE8,1266 +torch/include/ATen/ops/addcdiv_cuda_dispatch.h,sha256=RmmcfK8nLzBaKunJk7MRunpuI9gNerwY9LMWPkEavkk,1268 +torch/include/ATen/ops/addcdiv_meta.h,sha256=SaaXGMvNpyRVryFkQYiQy-pP4yD6AejtzuVvIWZ5o7I,669 +torch/include/ATen/ops/addcdiv_meta_dispatch.h,sha256=nQI-eU_kFhkVcFFcIiJKlQwyBBtEtofhCUuwCrRspfM,1268 +torch/include/ATen/ops/addcdiv_native.h,sha256=sWjVbnrfcDCLJTn4_dQL9-CwKadwnBGTrJe1Ux5xn8s,692 +torch/include/ATen/ops/addcdiv_ops.h,sha256=bqUz629Mmxa7r-Y1Vq6iSaWMiSUiu4v_pWput2bedks,2953 +torch/include/ATen/ops/addcmul.h,sha256=vj8P8Iy0xctbZDo4Zn1g3ChleCAHdW0l_49J4FO9wUo,1497 +torch/include/ATen/ops/addcmul_compositeexplicitautogradnonfunctional_dispatch.h,sha256=iT2tdmTUBkdu2qGNWVuVXkiHs-MbXEM8cJYx91DNX3Y,1011 +torch/include/ATen/ops/addcmul_cpu_dispatch.h,sha256=TrQXPeEDv-tDOenvoO63lTWo70r7tq12JnITApzhDHw,1266 +torch/include/ATen/ops/addcmul_cuda_dispatch.h,sha256=KyvIz560P8S3-Keno6f-PLeAFGSofTSWhZ_cvfOGj3I,1268 +torch/include/ATen/ops/addcmul_meta.h,sha256=lFMI7GKNJAB7M3S4CozFn6iTdxjqYcgR98o4JcTf9LQ,669 +torch/include/ATen/ops/addcmul_meta_dispatch.h,sha256=BZKfPpgkZ094ykWvhuxXt1Ek3LgyZeN-2ZffHuSiR6U,1268 +torch/include/ATen/ops/addcmul_native.h,sha256=xOluk4DMhuqom77B1kkAiVCS867pjPCZI8JeNvP6ko4,692 +torch/include/ATen/ops/addcmul_ops.h,sha256=2F_xsljhXJlKtY_3ay7iTBzOWkpgXzHoczEbhSMPeMs,2953 +torch/include/ATen/ops/addmm.h,sha256=xwXjsCZPXn5Pek5DnOs3SbORMOPP7L62Sdy1GsgPRfg,1565 +torch/include/ATen/ops/addmm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jqOudEZYHHcOXTWtPbeFfXnW6ObyVxS1l1KueE_7JPo,1049 +torch/include/ATen/ops/addmm_cpu_dispatch.h,sha256=hiyK_jE3TrYjxzoOuu675SWApWms-hKL-knXeGmOlKo,1340 +torch/include/ATen/ops/addmm_cuda_dispatch.h,sha256=FH4ZTIr2jx6zatXsROZDxxSgxVhWrKgECuD0bBbHU6c,1342 +torch/include/ATen/ops/addmm_meta.h,sha256=ws1qsZ_N9KbXjCrTxcNInT3WsoZPpsB6dYTYpUWZDhI,686 +torch/include/ATen/ops/addmm_meta_dispatch.h,sha256=fFBtcWp4A_kC2smXp662y7hLAQShxAuS0kCET8rNK8g,1342 +torch/include/ATen/ops/addmm_native.h,sha256=YI4somfOzDowYDORn9Nq60C4ijl0JTfCJ7gMvqx-kvs,2628 +torch/include/ATen/ops/addmm_ops.h,sha256=2V4Wqbr9Wvt3GfLCeLEG7Fhm_2iTNXZ329UAmECK3to,3136 +torch/include/ATen/ops/addmv.h,sha256=442NXsM8cSWq5kCN1pFQQKwYs4qFdC6zSeuHZDN6f18,1870 +torch/include/ATen/ops/addmv_compositeexplicitautogradnonfunctional_dispatch.h,sha256=fcvwwlmcROsF7RMPFKZrAkt22mT4-tLpx7367_thNDw,1045 +torch/include/ATen/ops/addmv_cpu_dispatch.h,sha256=f8GvqB9C5_E_8LJJtnhS2DmfZZsmaP3EA7zoGCVrlg4,1332 +torch/include/ATen/ops/addmv_cuda_dispatch.h,sha256=hXvCv9CLCih6tx03U4lhu6U0Q7s7JmSpoDeGwG5R5co,1334 +torch/include/ATen/ops/addmv_meta.h,sha256=J5_ncegSbAdxnPkrqWDAJic8CoV6BFuZbGxwIPhz2JU,684 +torch/include/ATen/ops/addmv_meta_dispatch.h,sha256=jzzplhFZukrmnODgPZ1HN30Xixnu3aYzw9ZtStN-FgM,1334 +torch/include/ATen/ops/addmv_native.h,sha256=WAAsLUru4Zmcdz2E7vJM_H5nXYIvnhSDfwTlwy6p9tU,1343 +torch/include/ATen/ops/addmv_ops.h,sha256=Gclb1xcdEXiLSGSBkeudC68BvE9ZPNTOLBsaQii9o8s,3118 +torch/include/ATen/ops/addr.h,sha256=mxgHj1RRzJAwdeL_2KkB0NsekNWTtCra5T7oZkiCcJ8,1555 +torch/include/ATen/ops/addr_compositeexplicitautograd_dispatch.h,sha256=bOc7NyFek0_nkLCbJp0hBRLou_qHwoFK2PrMA6IGMjI,1380 +torch/include/ATen/ops/addr_cpu_dispatch.h,sha256=jYQdOB0bS-rn2re-pqcnomYmtsNbHKDmREn4YQDkkj4,1182 +torch/include/ATen/ops/addr_cuda_dispatch.h,sha256=1OJL2mngSnw4kZoIgvmeiXg8qVmXK0F3-Z1zr8qlRW0,1184 +torch/include/ATen/ops/addr_native.h,sha256=NQIraBfXdR3a7FK3qAPZupV6pwcZ7Xt9C9tpW5Vi9xM,1265 +torch/include/ATen/ops/addr_ops.h,sha256=onvG12Ch5Px3w3KkmHCFyYg59l4ETPGf5g-9RZduXiU,3127 +torch/include/ATen/ops/adjoint.h,sha256=4jWA_fD_h6fZKi1uQuCyVHUVjAMJi2BGQE7Tg-CdMdM,635 +torch/include/ATen/ops/adjoint_compositeimplicitautograd_dispatch.h,sha256=BesD70OxuwD2C4d9wA1ZThjrS_jgl-zwz2NcDz_mi3Q,765 +torch/include/ATen/ops/adjoint_native.h,sha256=3FR_AmzcrNBiGkk_e6wvx_GsIiUnVvVnuD192jo_AoY,488 +torch/include/ATen/ops/adjoint_ops.h,sha256=G0gGnVej_a3yCd-il4iwnPZhIQiBvS1dlv33LsNYNpM,976 +torch/include/ATen/ops/affine_grid_generator.h,sha256=dsHqwWhOOmJQVB7_He-MFXqgg3Je_NHk1-oEwcaImQk,4544 +torch/include/ATen/ops/affine_grid_generator_backward.h,sha256=6lNEt9pjxOu9lnuZ-OW64E1eJL5s35ExiPQ3Jny8a9g,1815 +torch/include/ATen/ops/affine_grid_generator_backward_compositeimplicitautograd_dispatch.h,sha256=1YaTzIDDslmB_kRpQNu_XINLKr5hJbULjycu0w-JK4Q,961 +torch/include/ATen/ops/affine_grid_generator_backward_native.h,sha256=tyo1pI70NvSrbSjbHoZ6tg9iGDnBI2K6Vc4hsTB2sIY,553 +torch/include/ATen/ops/affine_grid_generator_backward_ops.h,sha256=Rcp22vnB0FSOEhwZSyei01rPjlbb6UUicb_44qIAgpk,1193 +torch/include/ATen/ops/affine_grid_generator_compositeexplicitautograd_dispatch.h,sha256=YSde4i--4aHYeOubjnopPAqprHHj_-BBFgMM0Jn2m48,1513 +torch/include/ATen/ops/affine_grid_generator_native.h,sha256=XIAKzj_W4-3LvH-q_DKIQtlXgeG1HPe7N19KtZqiu8I,692 +torch/include/ATen/ops/affine_grid_generator_ops.h,sha256=6k0fHqvTJaAmH513lUMcbqbdy3Hny09BZZedP0Q1QcU,1994 +torch/include/ATen/ops/alias.h,sha256=k8LPlJmznTMD2kG-FToICN6wgk_RecU_5ZQ5OuuXcx0,627 +torch/include/ATen/ops/alias_compositeexplicitautograd_dispatch.h,sha256=6VotKbMM5R0GKEdKbiGXEYg61aUVwBkp8UCnJpub_h0,763 +torch/include/ATen/ops/alias_copy.h,sha256=3ZnhAgZhhiKLUeK3MoJXzTJ-FmxmV_sYEq9HbGiXdHk,1055 +torch/include/ATen/ops/alias_copy_compositeexplicitautograd_dispatch.h,sha256=5WlJxs_AfbbyZgIoQOn5WluDQFgHf-hth5uNZAKiUpk,875 +torch/include/ATen/ops/alias_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5igB1i3qMZZwWLGxwYjkaXdz9ocfcYrbOyoil58SKWQ,794 +torch/include/ATen/ops/alias_copy_native.h,sha256=1M3lWL_kkQ_AbMTZVSV-_uP4nam6ZfilDJ5EyGfvwB0,573 +torch/include/ATen/ops/alias_copy_ops.h,sha256=_SDLRmwZkNxnaElSTbSXlnvt9epYSCHnlyKjBNok0EY,1614 +torch/include/ATen/ops/alias_native.h,sha256=41xkLLXSrXYNnM8_EC9ZB5wWlxgJr3RZe4q_kLP22cc,486 +torch/include/ATen/ops/alias_ops.h,sha256=UdmTY1sWnrUkUI6XtE_M8p3je5vY_js5UOX_k3NESwM,970 +torch/include/ATen/ops/align_as.h,sha256=93qHC2YP0lnN6sLVXMsRud0AuyvHFHnXG2mYWeXq-nc,493 +torch/include/ATen/ops/align_as_compositeimplicitautograd_dispatch.h,sha256=nb-cMhkOmO8r21o10vcHCUTjuffjRoyvRLWGU21kApA,792 +torch/include/ATen/ops/align_as_native.h,sha256=_4PsFbHeKcJTJPN5nVaiVa7xae4TjRgUs7Z0OCiZXjs,515 +torch/include/ATen/ops/align_as_ops.h,sha256=4iaBOETSXa0al1vsFhwJ2yMf_YniZFr0wiE4AXHMqwM,1059 +torch/include/ATen/ops/align_tensors.h,sha256=HjtkOWQ2TRBRBsU6EltfXSIpe-W2AbIakzFQgs_2IsE,677 +torch/include/ATen/ops/align_tensors_compositeimplicitautograd_dispatch.h,sha256=rU4xlJF6Io3cOrjdgnyjT0rdhqC3YJsWrxQF0FxX6sc,785 +torch/include/ATen/ops/align_tensors_native.h,sha256=3LDIIxkBnbLWZ33bk6i9BaCSdLuH80rbtn1hSW9lgzs,508 +torch/include/ATen/ops/align_tensors_ops.h,sha256=uJC6UJeoZDJXzNh6WeOq8_TuXP7MTYZGZpOnWrjgZHk,1034 +torch/include/ATen/ops/align_to.h,sha256=FnzJPP0AR0B9P-4bkRngkcGuoWTwJ-Rya16yWVHvROs,493 +torch/include/ATen/ops/align_to_compositeimplicitautograd_dispatch.h,sha256=mB3Eed8SeV_HwN3Lo0_01loyRCJ5u70IzWGRL4uzlzs,890 +torch/include/ATen/ops/align_to_native.h,sha256=DWVrykTO1f71EiRoylvuy5zhDEbQMPjZN5OUTby3P8k,613 +torch/include/ATen/ops/align_to_ops.h,sha256=F81q28IjjCeqx2d5tac3lSucPfArMprvzi79cBwA6uY,1793 +torch/include/ATen/ops/all.h,sha256=6CD2T4HepvSyw_GRMrCI7zPGRVEBaAs2Z-70fU5C1Uk,3343 +torch/include/ATen/ops/all_compositeexplicitautograd_dispatch.h,sha256=-_BR4CX8sA0M6UOMb_ZQtlBnDvtyDVf-eCOnhlXQ5PE,1053 +torch/include/ATen/ops/all_compositeexplicitautogradnonfunctional_dispatch.h,sha256=O8k4zyELAzs9wZSRkvhyxBeMpgOHW_LBnWeSwdgLU8s,971 +torch/include/ATen/ops/all_compositeimplicitautograd_dispatch.h,sha256=kQxvnzw9ZOK7Dl_a4eGZ14boarkNjAn83f9NDPoP4DM,1017 +torch/include/ATen/ops/all_cpu_dispatch.h,sha256=VEvzY92jUf1eH3De9dEu2qeBygt5u-zwB2e-UmhQTGw,1506 +torch/include/ATen/ops/all_cuda_dispatch.h,sha256=hLSwkUrnjWwnVGoZTeAK1x6ihYdCBadIcVHptJe5B4E,1508 +torch/include/ATen/ops/all_meta.h,sha256=sqWMKpw9OXx3WLF1hRxzKXfIKnuMoe3FDadtAIBDU-U,892 +torch/include/ATen/ops/all_meta_dispatch.h,sha256=gI7mXiscbMIjlHsW_c7wyYBNEzTjF0ipFOmn14rw7_k,1508 +torch/include/ATen/ops/all_native.h,sha256=TTsNtZANVGbYdEUKUYmSXF-S1I7lvG7qUa1bdlmb044,1407 +torch/include/ATen/ops/all_ops.h,sha256=pCvxj32lpHnOGrwAffa95HsjcI2Mb3pR7hFH-ApYUUk,5817 +torch/include/ATen/ops/allclose.h,sha256=wS6-9QjgHoA1-ySNa2w6z3H53MXwD9dfqURvIA6fKjk,813 +torch/include/ATen/ops/allclose_compositeexplicitautograd_dispatch.h,sha256=qPU-HKtBOEw9esjjAgBPDcIbEW-M0vvEYcmaMjpiDBw,846 +torch/include/ATen/ops/allclose_native.h,sha256=zOn0by00uyb-qIvPYTFDkHqOZ1z9j4HDwONv86vOMkw,569 +torch/include/ATen/ops/allclose_ops.h,sha256=c2Z_4uavSZhxT3h2hDzitlQiz4xukkyf4anrhd_G4UQ,1203 +torch/include/ATen/ops/alpha_dropout.h,sha256=RzOZFh_vLZvnTu2jDv7HkbgDXHY5KCJsrA347LjftpI,925 +torch/include/ATen/ops/alpha_dropout_compositeimplicitautograd_dispatch.h,sha256=1rAd24UqhI4E6zicZY2T-xcYYa89_UNOgVLns3eX35o,874 +torch/include/ATen/ops/alpha_dropout_native.h,sha256=RwUH_84XkWBkOEI_DDT4NtSy7tgxZ6lPAo-ckrJJo-I,597 +torch/include/ATen/ops/alpha_dropout_ops.h,sha256=qUIiVs70WkXA_gimoLech1U1F0wk29hq4bT4bpXhG9g,1702 +torch/include/ATen/ops/amax.h,sha256=GlKpuv3yuva86v_2Fcjr810TTdtuXjEMizfk8toyiwg,1265 +torch/include/ATen/ops/amax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=dhhdZ0veuV8ZJgob87RF2br8KyyKQ7_hHv3hKNw2nrI,832 +torch/include/ATen/ops/amax_cpu_dispatch.h,sha256=bTSDLN-9YaOQ19tOGvZfTcG5Ft-Uv_z31m3I2CJ13Uo,994 +torch/include/ATen/ops/amax_cuda_dispatch.h,sha256=7l9HqnUM1ITMjbqhv00bDf9RbVRIhqQaUUo3pujE_RA,996 +torch/include/ATen/ops/amax_meta.h,sha256=VgUUz00R56nX9dHp6mF3rpzFyzrDdl653E991Ix4Ntg,619 +torch/include/ATen/ops/amax_meta_dispatch.h,sha256=N0iRa_0MrwaSYe7RERp08xNHexkJTaGAqNPFeVZp_-4,996 +torch/include/ATen/ops/amax_native.h,sha256=gc9HvK2uI6izL7_k-fcVVWW-28QnVj7kqetY7jj5V94,636 +torch/include/ATen/ops/amax_ops.h,sha256=iAJVRECY9vFxm8NmI_uuwiApd3O2R58O-Po7jjAYX7w,1834 +torch/include/ATen/ops/amin.h,sha256=naRws08ETbQZvLMXgJ-zuYIWqQCx2XkS8GeMwPRVIQU,1265 +torch/include/ATen/ops/amin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=n4l4av7to9aq1T46rMJIiK7x5QQ-ZdveuYq2Kt_1OKo,832 +torch/include/ATen/ops/amin_cpu_dispatch.h,sha256=ItocUOwWj82YOdae2NPjYLpsYE5CrmDxMWeJIFeG0Qk,994 +torch/include/ATen/ops/amin_cuda_dispatch.h,sha256=06N22SMiD6AgUOUtQVnUBq2Vu53hnzYeSRmWwIYLJ60,996 +torch/include/ATen/ops/amin_meta.h,sha256=8NP6dSMUScqzSLuqRvDwfDTd29vCP1XbOWPRnUvkIMc,619 +torch/include/ATen/ops/amin_meta_dispatch.h,sha256=pygboi_K_Wt6BTxgR3EQukeYGMEIuBfHQ5sMz3_ByA4,996 +torch/include/ATen/ops/amin_native.h,sha256=esqNxlfZsA1KvJ1O2XQBbT947ETBI9zxQbFfmyY0D7Q,636 +torch/include/ATen/ops/amin_ops.h,sha256=bMiKY_toulTQ37lsjcxrgN8PhkIoNtWerXNDt7wfZ1k,1834 +torch/include/ATen/ops/aminmax.h,sha256=4Rr37gqqBS3pifd053ClABhT17AtgVvAaMC7Qg__p9Y,1558 +torch/include/ATen/ops/aminmax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=535pLH2zlL4ghQ8Ys4x2_aSy8KY_RCqSd1GoqTQz0yc,877 +torch/include/ATen/ops/aminmax_cpu_dispatch.h,sha256=2I4HGuv0mdFk9ioVLJ_LQiMUlgRsJvj25PY5SZmQoSM,1159 +torch/include/ATen/ops/aminmax_cuda_dispatch.h,sha256=VZDAdHQM8iFRwADrwiRrVxVmDU0YzoRFH9udnbT_pbA,1161 +torch/include/ATen/ops/aminmax_meta.h,sha256=p0rrwV2gcD9ev-UMbc667f7f0_wS4jfX9Y3lK0VUHSM,629 +torch/include/ATen/ops/aminmax_meta_dispatch.h,sha256=Vz3zIqS4_ct52RNDEIUeZD-S0ySTc-yU3x0y0V15Bik,1161 +torch/include/ATen/ops/aminmax_native.h,sha256=XFoNbzjJQHFzTIWIYwJosc3LsD1BZWllI2xOWaQhVgE,676 +torch/include/ATen/ops/aminmax_ops.h,sha256=xPhShry37RPwZVmwioj3YsPL8A6JIkyK-Kw-UvgBWx0,2159 +torch/include/ATen/ops/and.h,sha256=UN2emxvrE27Vd8zL8jbB8OelML3QcAkgNO3P0psFPb4,885 +torch/include/ATen/ops/and_compositeimplicitautograd_dispatch.h,sha256=ctXesQUpQ1hfL4Dn-q5t3U_t6qS_dBXGQnLmEqE1P08,1028 +torch/include/ATen/ops/and_native.h,sha256=d_EPDUCeLVvT-cl21Mu45dRusZiCFAUE70OWYWqVbfU,751 +torch/include/ATen/ops/and_ops.h,sha256=5E07x4OAK77LKxNiGzck0e9QPTWR0vHIOSHqQfpy8hQ,3000 +torch/include/ATen/ops/angle.h,sha256=j8Ah-mAy9qDat4XAYIsDXRZz8v_iBt8h5gS5FCbhubY,1005 +torch/include/ATen/ops/angle_cpu_dispatch.h,sha256=WUvzdsQUiT6_2piUZ-GMqNj5TKPj1xR1ZXn3RAwELXE,874 +torch/include/ATen/ops/angle_cuda_dispatch.h,sha256=8GLy2DqUmgoypN1MhJlOpa6fTk_Ei-PCt1iFXpeJStk,876 +torch/include/ATen/ops/angle_native.h,sha256=nUhGb3s6vlGFaWEreAdK19TpM8dqXKof7bO8etWhMVw,715 +torch/include/ATen/ops/angle_ops.h,sha256=ngOD77_TJI1PPxDcgRc3WW_ln3faBNwF9G8TjTlHoVY,1584 +torch/include/ATen/ops/any.h,sha256=Y7BYeJJZuPUcJFsPnLExuJhir0jw_sp2CcJzzt8mrRs,3343 +torch/include/ATen/ops/any_compositeexplicitautograd_dispatch.h,sha256=-Mfm-PFlLBwYShF2nkvgq3WrBzQpoTnGwGeDDKL8F5Y,1053 +torch/include/ATen/ops/any_compositeexplicitautogradnonfunctional_dispatch.h,sha256=SLNTt6owPxxWO7vdqEhXTG2XoFQZemNjKywixgesqcM,971 +torch/include/ATen/ops/any_compositeimplicitautograd_dispatch.h,sha256=w4q59ZxOZzeeaUeo56MtK3xxkRBreQxI0QSzYDqt0Qk,1017 +torch/include/ATen/ops/any_cpu_dispatch.h,sha256=0wPYeWS0J_m9Z2SvOHBwzi2-WvZlHNVyE_RqhkXO2GU,1506 +torch/include/ATen/ops/any_cuda_dispatch.h,sha256=YTBNllhYHcauscodcajqUciY3ZgkF2XtKuzfZWkiIfg,1508 +torch/include/ATen/ops/any_meta.h,sha256=4CcedkOAETmbPavohHNoRVhsBH3kHEjcFi_k6jG-LEA,892 +torch/include/ATen/ops/any_meta_dispatch.h,sha256=34-luNWSVXBKVgddZf7vWwUbimKA1TJ-qAGG_7MrY4s,1508 +torch/include/ATen/ops/any_native.h,sha256=Q4VRpgNOTo9X3C1xkEeF5G3vhMgSjBPkDRv-rCPWeAQ,1465 +torch/include/ATen/ops/any_ops.h,sha256=_7rGnuK_p2AO_HPd88hVwzlLvgW89ABVOap-NtlmMis,5817 +torch/include/ATen/ops/arange.h,sha256=0PpT8yq9ltl_uWxQ_QoF0w-D1mcxXcqiCuLyLFKzb2I,4135 +torch/include/ATen/ops/arange_compositeexplicitautograd_dispatch.h,sha256=r1mJchj0MXDoVIWwq2d1kVB9O1OzS-JfghD9EFvgCFQ,1838 +torch/include/ATen/ops/arange_cpu_dispatch.h,sha256=C9Ypq3u7F4qWbk789bHniQ9ymtIaKZcD3VuFsOBZtTg,923 +torch/include/ATen/ops/arange_cuda_dispatch.h,sha256=-qDx-i9dGxN7Hjb4agj2kiiqymNjlQk0Txo82GRrWA8,925 +torch/include/ATen/ops/arange_meta_dispatch.h,sha256=y9edn1kvM-Vqm1UQnotmCTG4u7QKl6O6C-g16zWW0i0,925 +torch/include/ATen/ops/arange_native.h,sha256=08IxBFRE71G_Hk3fpwnehNFQGnISKtgcvHA1T9nRbMA,1456 +torch/include/ATen/ops/arange_ops.h,sha256=8yVa2r6tzQtI39hcns3fmPmU5OjfU3pP0i6dgnod-iI,5175 +torch/include/ATen/ops/arccos.h,sha256=if4Cj4fjSGCN1yfte9SmAS3pq9NOk7p6oG8dSV8IIEc,1157 +torch/include/ATen/ops/arccos_compositeimplicitautograd_dispatch.h,sha256=jw4rphQLHHWCbSigf7ZPoPWNUpOuOgheIke_dAHWvDU,972 +torch/include/ATen/ops/arccos_native.h,sha256=iLeqRhKkPet-4bJ--JOH2PgFaR9wL0y7qJdOcoiRa7Q,616 +torch/include/ATen/ops/arccos_ops.h,sha256=XzT7b2OmYlKiQzgijFX0O-UzI34yQ4AlkotHAsgO514,2122 +torch/include/ATen/ops/arccosh.h,sha256=cG1CGQcppI0ZJ13jl1tvcUIAql55dPf9OVBnmPeU60o,1170 +torch/include/ATen/ops/arccosh_compositeimplicitautograd_dispatch.h,sha256=M69I6MFjaHKVp03uZT2S_pDD6_hQ4jV8BJY8OU_1kBA,976 +torch/include/ATen/ops/arccosh_native.h,sha256=D7Po5aC9eSDBo2hkyxgfbgjYT30CAXCRFdQPvMtoZBI,619 +torch/include/ATen/ops/arccosh_ops.h,sha256=LXGf18YmN3spOeU3-AcJ5NCFJt0uD9uvfKeCELgHtoA,2131 +torch/include/ATen/ops/arcsin.h,sha256=iWRVeBTrv3YEqDXzrinwj33UW3pldnUDgXp8HGGw66c,1157 +torch/include/ATen/ops/arcsin_compositeimplicitautograd_dispatch.h,sha256=76NDHrGaKw6hf5SOCh_z0Qp9UTlYFqLEkKJ2FIg4TbM,972 +torch/include/ATen/ops/arcsin_native.h,sha256=nLvT1NGE0PC0utZFgsbWDVth068Y8AcRDxm4Wp5-jTw,616 +torch/include/ATen/ops/arcsin_ops.h,sha256=Y-yors0QJcbJIGFLa08-PK1QMO24kHpQeidg7EhQldU,2122 +torch/include/ATen/ops/arcsinh.h,sha256=RlICZheO4gTuH_DixdnLhA775wObD_e94vcXreqCFUc,1170 +torch/include/ATen/ops/arcsinh_compositeimplicitautograd_dispatch.h,sha256=-u5rHNy3oW5PM8Chink7cK_FotvnDM7X7fiRO1zEpSY,976 +torch/include/ATen/ops/arcsinh_native.h,sha256=hhyoE6-iSLm9iCVGmhoqudyMOdprfRS3yZ9MlrJrktw,619 +torch/include/ATen/ops/arcsinh_ops.h,sha256=AwAHIDoEgRtbWybqgsbNDR57iEonzht6qtu4ZAKxYZw,2131 +torch/include/ATen/ops/arctan.h,sha256=-hWZ2XpperhQ2yUj9V8sL82rdticoFvZ9CSCcrL9LVg,1157 +torch/include/ATen/ops/arctan2.h,sha256=WtSjeArEF40fg6u-eE9_iivnd2EHtVcX-zdez4QvI50,1166 +torch/include/ATen/ops/arctan2_compositeimplicitautograd_dispatch.h,sha256=Mj6_sZPVIQkHQPq0CLPgTvxVtWiTGUtPKxQI0nZEAIY,1080 +torch/include/ATen/ops/arctan2_native.h,sha256=bIKaUvATwwkzLtMKDJj84wvFnTNfw9xdwiahKBVzMuw,697 +torch/include/ATen/ops/arctan2_ops.h,sha256=ab0oc92yfahperoSk0YZlqrluPhpDBgFgs9XnkOF0IY,2389 +torch/include/ATen/ops/arctan_compositeimplicitautograd_dispatch.h,sha256=a_ZC-HFEXxXTPp-PtIXhh8Oeb0Sxsw633Prlmc9Ido4,972 +torch/include/ATen/ops/arctan_native.h,sha256=3UKxB8TrRmuPT-wn8u4P1e7yx4iBdH0XQthqOuM9L2U,616 +torch/include/ATen/ops/arctan_ops.h,sha256=n1F9speHGRI513G5VnKIphSzzJHuGPnM1c3x7MeftYo,2122 +torch/include/ATen/ops/arctanh.h,sha256=zYuIKTKFeSwGOqxypu1e1c3vFAMjNIeEVdV-Cuohjng,1170 +torch/include/ATen/ops/arctanh_compositeimplicitautograd_dispatch.h,sha256=NHmbbBPpnIzLN7JRZNM1BjOwMHtjZOeAwTx3x8cy0gk,976 +torch/include/ATen/ops/arctanh_native.h,sha256=94kgWrxq5krZJYImSG7P-aIXEQqaWv-ANF5c8_uJ8-8,619 +torch/include/ATen/ops/arctanh_ops.h,sha256=Br9XaLb3raJg1PQAnV5meZ3ftkflbXAsF6ZtDNfOiMs,2131 +torch/include/ATen/ops/argmax.h,sha256=yRBg6cy1OeOshVz-QFimPQP5nolsnslM0KWgotFVj_I,1326 +torch/include/ATen/ops/argmax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=n17Hc2GzodSQsk36F_OhrKHuNdTawcb1K5kVkEJ7Pbw,851 +torch/include/ATen/ops/argmax_cpu_dispatch.h,sha256=PAPyv59kdLIpXD8Zu0cs0FTrd4viqTMAmsQnDeVD2-k,1041 +torch/include/ATen/ops/argmax_cuda_dispatch.h,sha256=rucpeTqsPJMzRCPNAS_t0ZOtcNOvvev88KaW1VUF-1A,1043 +torch/include/ATen/ops/argmax_meta.h,sha256=927S8HAxRm9KbvWQ7_strmf2RG435_3_x_rgc9zlt8E,628 +torch/include/ATen/ops/argmax_meta_dispatch.h,sha256=puzy7ayCioLtMnqbSOeFyugCFQFLpEoa7SSHZ6SOSuk,1043 +torch/include/ATen/ops/argmax_native.h,sha256=qhoAqVjAVmJrW3GNLrZvekk4RnUIdnZe9CfXHuNAVlk,649 +torch/include/ATen/ops/argmax_ops.h,sha256=zernOXy0Ev1maXdvLpjNjQljxus09bELxjLeozlzYLs,1888 +torch/include/ATen/ops/argmin.h,sha256=yTOgQDalGmLMzdH2FMG_2lSRzxoDupB_ik6kPxoXFtY,1326 +torch/include/ATen/ops/argmin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=cIGEEW7zyAk69vSSwlYJz_mpaN-Y70mTbaH0-QkSwWI,851 +torch/include/ATen/ops/argmin_cpu_dispatch.h,sha256=rNDXzNaOOACYCQ_2BjYl7WU1bmB9bu1Ylae6xSPMYoI,1041 +torch/include/ATen/ops/argmin_cuda_dispatch.h,sha256=bRnipHNYD6OscdRXGfqQowWNGSrrwVgUh3pbkti6bfA,1043 +torch/include/ATen/ops/argmin_meta.h,sha256=iM5hYr9ncE-jC8bcp5wB4LywAUxNj6BdyxHxmitu5n0,628 +torch/include/ATen/ops/argmin_meta_dispatch.h,sha256=BNvEOzCM27s7EXG7VFquSXjBhlVGRX7xJCZ_DbUZb-4,1043 +torch/include/ATen/ops/argmin_native.h,sha256=8KmNvvZlNysRu-nElpmHV30NoWNpMrEB1qmezzeZqGs,649 +torch/include/ATen/ops/argmin_ops.h,sha256=QtWIEj3Hxd4Yx5eN3_s4BVbinL_Hx5B0fJ6xUK97J_w,1888 +torch/include/ATen/ops/argsort.h,sha256=oZgAiXJbbOCAUnLt6mhMDlnUWUXgIhGPC_VKlRnRujo,1912 +torch/include/ATen/ops/argsort_compositeexplicitautograd_dispatch.h,sha256=kriIrT3xEyoKQQOQ0yH4OI-hFWUXBLKOAbWdbYqoV8g,964 +torch/include/ATen/ops/argsort_compositeimplicitautograd_dispatch.h,sha256=ALi_yQ4xbpCl8z_HMTr-Q1ySmRNXWUQ__s6Ol5bUaBE,899 +torch/include/ATen/ops/argsort_cpu_dispatch.h,sha256=_tDikW368xSMbc2Co80wIogHxGmgtTgVMrwSBL4JAfU,773 +torch/include/ATen/ops/argsort_cuda_dispatch.h,sha256=MGKQQVtoM6onNkO6aqR3szVYmW-OKfVJT4zWwYXSL9s,775 +torch/include/ATen/ops/argsort_native.h,sha256=-hk4eH2qmjJV1RZIVEPfaW_Bc8FEtOEx7yNCFDHcc5I,865 +torch/include/ATen/ops/argsort_ops.h,sha256=TcLI2sBHnwoTcGUv9YrlJbFBJz_oEGPVvxSAHUFq6rE,3278 +torch/include/ATen/ops/argwhere.h,sha256=lxW15m2c-BL2bFgzNv4vOJ_RLjElIJw795dw93nR5Cc,633 +torch/include/ATen/ops/argwhere_compositeimplicitautograd_dispatch.h,sha256=oEmh9Sazbi83mlQrioLOkXjuaGywuSxfAar2MLfTUkg,766 +torch/include/ATen/ops/argwhere_native.h,sha256=hYnHPpZCIqRqvYhwZcLUXYbvII8tpvEOwzq33TyhLSA,489 +torch/include/ATen/ops/argwhere_ops.h,sha256=FiKHmo4Q5NhVVCxfYYmT6-AJVCZaelmqOms9kE5Rm8Y,973 +torch/include/ATen/ops/as_strided.h,sha256=R2pPGGDpWlH-jkZxO97ywKAkomNYpcMOK1m4pmEUVjU,3838 +torch/include/ATen/ops/as_strided_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XaOGU_eKyv1Uw3Vw93_QjQcTkF7t2r3qeYUPthLHXIc,1085 +torch/include/ATen/ops/as_strided_copy.h,sha256=rO8wLKQwmSkBxSI_XuTpW57YOi8OE2psevIEyL3guyM,5884 +torch/include/ATen/ops/as_strided_copy_compositeexplicitautograd_dispatch.h,sha256=JTK1XQ_nIXnPXUPPIEpNlojof-81ZrgSya2MkXPbtbY,1464 +torch/include/ATen/ops/as_strided_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=_iwe7uIwKamVxTq6uetsbcHWS890dLTyM__YS8P7OkE,1077 +torch/include/ATen/ops/as_strided_copy_native.h,sha256=OqG6pWQW_Sd0PSreW4CGB8oar9ENvsp-FMaS99C01jQ,804 +torch/include/ATen/ops/as_strided_copy_ops.h,sha256=47b2wQ37ppdrHt2D_S_dTRUjAGVSYhnqDJJISIOimZY,2294 +torch/include/ATen/ops/as_strided_cpu_dispatch.h,sha256=pj-lH8S3lI1bw-wJL6D1SeqenmF1zdSrw9EHQFjjJxI,997 +torch/include/ATen/ops/as_strided_cuda_dispatch.h,sha256=W9iPnDCbJPcR0JH4-a2eiATs7f_5fSfLgvW9sY2_aTg,999 +torch/include/ATen/ops/as_strided_meta_dispatch.h,sha256=VqrCp6v2ceCqhXLVgslmKYjcCF76W74Jp2x038Ma-qg,999 +torch/include/ATen/ops/as_strided_native.h,sha256=IHd-jAOmkjxoIvHh6Yn6jCcmQ-sDsFKJzIWnzs-gcGQ,1143 +torch/include/ATen/ops/as_strided_ops.h,sha256=QCDxaOrWKuBMfyt92kWgTsIHyGv-B4UyGZsTRUMUUpA,2215 +torch/include/ATen/ops/as_strided_scatter.h,sha256=0T7bv7OtsDFcgenv_FLlmdSaoLYxOl_WImlpl9p8Vsw,6397 +torch/include/ATen/ops/as_strided_scatter_compositeexplicitautograd_dispatch.h,sha256=q1JAMzPNeX2mLk_-j55nUR-ZTNpz81l2EBiTQ9i3btk,1572 +torch/include/ATen/ops/as_strided_scatter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=0lZWkqZUN0o6G5LGYWYIEeicpI3NxvBP7e9x2uVpU6o,1131 +torch/include/ATen/ops/as_strided_scatter_native.h,sha256=jgGv3U-hVetUjstNQ0ebx2kr5vjjb-4zRSTz6dnSpSI,858 +torch/include/ATen/ops/as_strided_scatter_ops.h,sha256=VPhc5_PIwMCzw5r8TdcjGV9zt1KcaNWiKTG82553mHM,2472 +torch/include/ATen/ops/asin.h,sha256=8ONXMaz32EZXKOTGdpB-fGcPXVrahyjZz1-pasEx1B0,1131 +torch/include/ATen/ops/asin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rQHAdGl_lnlZVEffdFCs2AaXlBmpzAb5wzfcIbds5I8,837 +torch/include/ATen/ops/asin_cpu_dispatch.h,sha256=OuHL9pTRifagYOu7g6iUfFQMJreoJodOWdFbgPVcJbk,920 +torch/include/ATen/ops/asin_cuda_dispatch.h,sha256=qVhBQh2CBSfrBUdf9zFKS-KGDXK26Sl1QIcnh1609z0,922 +torch/include/ATen/ops/asin_meta.h,sha256=GRXe2VNCu3KRMuloF_wDzFmvWF-1lSu0hzDgMHYRSsM,584 +torch/include/ATen/ops/asin_meta_dispatch.h,sha256=TBZ94Bnz43jcXA7HeDKlOcQsRZMPkHMCIFfL3j3dNRo,922 +torch/include/ATen/ops/asin_native.h,sha256=K_K9H74BbxF_Qn0VNxbOOPKr5rRBibe9MP7B3XYAiSs,1009 +torch/include/ATen/ops/asin_ops.h,sha256=0Jtnf_pn6Q7BfJ-IwT64m7F17ciYPVL_MS07Kj73HRQ,2104 +torch/include/ATen/ops/asinh.h,sha256=sXha91JMQNclGr_fY4jVep9jiaB2VSiZmlMpANMok1o,1144 +torch/include/ATen/ops/asinh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XWUBJVXWCOR1SGb3SMCsbBtGfphnS7peYo66N9DqMNQ,839 +torch/include/ATen/ops/asinh_cpu_dispatch.h,sha256=vaPhg0Yu4RhDrwXY9uMyvJW6cXCSsEN-Axudj9Z5Gx0,924 +torch/include/ATen/ops/asinh_cuda_dispatch.h,sha256=HhALrALFbQq2j0EFNZin2Gy0ofneP_RMuHZn2uWTjQ0,926 +torch/include/ATen/ops/asinh_meta.h,sha256=MpO7WhZmrrjNX4EZEVs2_ozt11mSeytvDH7yVTSppTI,585 +torch/include/ATen/ops/asinh_meta_dispatch.h,sha256=ruiNpAsP9VM-FNYJnMUtSNrT6I5Sif_czWTS0GpSMLA,926 +torch/include/ATen/ops/asinh_native.h,sha256=lqI_XtKQ-5rmd_p1kRj7Dm1lWti3xoShS27fClY7z6Q,1018 +torch/include/ATen/ops/asinh_ops.h,sha256=1TGQXVsHDV_WAJCq4TsRH79uDgdbIR3dJlLBBcRCAr4,2113 +torch/include/ATen/ops/atan.h,sha256=jEwBbE72H_Owpw0nejwRdipfFkLrz12dTLW7WbQyqxI,1131 +torch/include/ATen/ops/atan2.h,sha256=lR2icqAxi8F9Mr84iN_nbumFjKAzbVWMQL00o6WhEjk,1146 +torch/include/ATen/ops/atan2_compositeexplicitautogradnonfunctional_dispatch.h,sha256=YqjnXLlGksLr4zjEjpY71TGCLDd_j8c6wekt-xoRi8g,891 +torch/include/ATen/ops/atan2_cpu_dispatch.h,sha256=zMYn6YJFoYVrRH1gECfH-7d8fQIy0pnPRyom2Fx6CT0,1028 +torch/include/ATen/ops/atan2_cuda_dispatch.h,sha256=xTWeq4ixt7FJW7kqKHfBxGm2B30LWHz3Me9ibvIuuv4,1030 +torch/include/ATen/ops/atan2_meta.h,sha256=MuBBlxVqP6e-uEhSW4xf-C8QyxhRkMT5ux5gE_JW6Eo,611 +torch/include/ATen/ops/atan2_meta_dispatch.h,sha256=0FeW_H7IsRfktHWg5g928-SR-M3tSnUhxwRBTwDVQRs,1030 +torch/include/ATen/ops/atan2_native.h,sha256=yYL1F7rygVuSSJmndffxs_xLFF19DQAvi_3OXwuMgaI,630 +torch/include/ATen/ops/atan2_ops.h,sha256=oPgNhC4iDShrIVTxeQsF3Ite2xfq7X8uZ5_VEk56hnU,2371 +torch/include/ATen/ops/atan_compositeexplicitautogradnonfunctional_dispatch.h,sha256=gOueKxq4BYkz195quAbAgPb9RC-j40NJoguAcxD7Qv8,837 +torch/include/ATen/ops/atan_cpu_dispatch.h,sha256=RsD0iE3lk2CMWuWAqHSt9ms0l_vLIWDmG3ZacMPf5Qg,920 +torch/include/ATen/ops/atan_cuda_dispatch.h,sha256=-0BMCkdLIhuV69cmGYNL6geP-n2cgn8CBR2IruVHQ5A,922 +torch/include/ATen/ops/atan_meta.h,sha256=88tLgAJ5J_HnqZzyM15uTCOKDUE7LKxRdI74v1bh10M,584 +torch/include/ATen/ops/atan_meta_dispatch.h,sha256=e3sGwmIE1cTJ2t9XlEKXzh7X_unwMwc44R9bXUn5lNM,922 +torch/include/ATen/ops/atan_native.h,sha256=KvokGFMKxha8JApZWmB1n5a9cq0ADNLF5hPeOYg57rU,1009 +torch/include/ATen/ops/atan_ops.h,sha256=oy_zB32bOoengD4QcXNcksPDGm38xwhduenSGkJqet0,2104 +torch/include/ATen/ops/atanh.h,sha256=QXR6X55rBZ4ZeBWdevuuT0obX-OSku7JPr2u78IjsYE,1144 +torch/include/ATen/ops/atanh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Oo-i9SdkZbDJgWn5INR4ery80-el6-uZBItpmm_GU5I,839 +torch/include/ATen/ops/atanh_cpu_dispatch.h,sha256=DkPSF_j83bb_UQOtoNwRdKH8v0Z3a-IxFY2ryYlYS4o,924 +torch/include/ATen/ops/atanh_cuda_dispatch.h,sha256=0pjqsnPEi1m2644blhUV3ATJD-Z5Ok2lrLTzlCodzF4,926 +torch/include/ATen/ops/atanh_meta.h,sha256=y6mCbeBlntzffvILKQJIb96p4cwA2F9N6HKwGo_XQFA,585 +torch/include/ATen/ops/atanh_meta_dispatch.h,sha256=ie0GfrrAcdXNSxSKl9isvfgjqa9ezsWqoaA4wZkp670,926 +torch/include/ATen/ops/atanh_native.h,sha256=q8UyNsh142pXJiVYCKWs1F9X6RKvIVPQ2GsPeK3KucA,1018 +torch/include/ATen/ops/atanh_ops.h,sha256=_7X3D0VSyw_jU08ktUwx5SfzNqN6zyNC0zYEr41X8z4,2113 +torch/include/ATen/ops/atleast_1d.h,sha256=5Y1eg8Ub_Vpq0K2CV5HNnSghToCQoFH_j1bZ6fytFKU,830 +torch/include/ATen/ops/atleast_1d_compositeimplicitautograd_dispatch.h,sha256=sabjmZ2Q4zW5Ki65GKr0Q5Jx9i5cug-_a4u6EFccaZo,840 +torch/include/ATen/ops/atleast_1d_native.h,sha256=wJRd7nPCXUkBY4TkkXkROXyksiUThteTI3DPMt-mC_E,563 +torch/include/ATen/ops/atleast_1d_ops.h,sha256=58ALb0rasaRybi3xUXE3mIJgG7UBbT3JbUe9nu3ntbc,1596 +torch/include/ATen/ops/atleast_2d.h,sha256=TZqmYODzByzFbOT0Dlw0gLTSqRWsiiWpYyhC2ITlptM,830 +torch/include/ATen/ops/atleast_2d_compositeimplicitautograd_dispatch.h,sha256=Es7bwCTh6K1Hrc1ObtFm19xqK0SEAkdGyBhAeZgdWk8,840 +torch/include/ATen/ops/atleast_2d_native.h,sha256=bGLCAcHQ31advYNBb7jcQFBexuc1oCpRg0gttohdRrE,563 +torch/include/ATen/ops/atleast_2d_ops.h,sha256=yv6WRKaUiFmV2Yk2JFgTrnyFqDS1LQcs-5xehaGKYuA,1596 +torch/include/ATen/ops/atleast_3d.h,sha256=CEhKzESP0GEJOS56eSs3P85tSVvEuFgoWhrsniw3u4U,830 +torch/include/ATen/ops/atleast_3d_compositeimplicitautograd_dispatch.h,sha256=SRXx--ZpMZn0FFTDEadUZ8qWG492up2Wf4YY4duHnYg,840 +torch/include/ATen/ops/atleast_3d_native.h,sha256=Rq_jJ_QxTzpbZ443eOJC2sCUqKB8JAbi9iRUwb2Pt-A,563 +torch/include/ATen/ops/atleast_3d_ops.h,sha256=9XG5HyLn-0rsZMA2fb7l8S4koTXjcK5rZSDApH_vjDQ,1596 +torch/include/ATen/ops/avg_pool1d.h,sha256=4cZBclWtNEBCRWIstXQuXaGZxuV17OKZQ4zAsIPunso,942 +torch/include/ATen/ops/avg_pool1d_compositeimplicitautograd_dispatch.h,sha256=NGtYaWPA-VLongy8-xut4L3di2ee0PApSxIjMyZp2wM,902 +torch/include/ATen/ops/avg_pool1d_native.h,sha256=Lqu0HNt2M6mMsNSfPXk4-HhTOXB10NTEkiejq94dBj8,625 +torch/include/ATen/ops/avg_pool1d_ops.h,sha256=m3VLF_jB5PbRHzrnwPJba_z7eMc855AWB15oEYkhXnM,1385 +torch/include/ATen/ops/avg_pool2d.h,sha256=TXjhjF4O90Z5Fs-59wvTyom-wATr0k2olngAj7YpS5M,2229 +torch/include/ATen/ops/avg_pool2d_backward.h,sha256=S5EpevD0WkugtuI5NoY_x4pehnUbtrE2OK-eC1tmApY,2463 +torch/include/ATen/ops/avg_pool2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=qBtt06HJok_XevG1_GjWD5o7x11M_awWjcLd7J1pOgE,994 +torch/include/ATen/ops/avg_pool2d_backward_cpu_dispatch.h,sha256=9i_PpLOgJgbQlDtjQVvaUIS9_6byS6a8rI8-H36TWoc,1503 +torch/include/ATen/ops/avg_pool2d_backward_cuda_dispatch.h,sha256=8jgr0DZTxxZ7Ch9PywQab-xTrPvE_qtGNXedKgXvo3U,1505 +torch/include/ATen/ops/avg_pool2d_backward_meta.h,sha256=N6gejBw0Zn0NDEtPLy21fZblX3EL95Trs0WmsumLWdU,790 +torch/include/ATen/ops/avg_pool2d_backward_meta_dispatch.h,sha256=Dlv6WdslgdTJtSkBesDPKJ7eZKRWJ56o4iGFsGyzLto,1505 +torch/include/ATen/ops/avg_pool2d_backward_native.h,sha256=2Y46X9pOa5Wwo5Kqb4m1ZHI4H0ai7PoPo79DV5EQ1To,1779 +torch/include/ATen/ops/avg_pool2d_backward_ops.h,sha256=8HLnY1P6JzsEYzZVjFBVqytWdsQUF2cbiBkpiwc6YjQ,2956 +torch/include/ATen/ops/avg_pool2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=PATNJ92Ucm_HOci1T13JUYbHezBCmgkmitJGnLNhn3U,982 +torch/include/ATen/ops/avg_pool2d_cpu_dispatch.h,sha256=kliz-tkTUURRseoXqxoHW6ahCEYSt9lX7r4q0MhLmrQ,1424 +torch/include/ATen/ops/avg_pool2d_cuda_dispatch.h,sha256=QShMDo80cvQxiYO8NkXIWVyNtxlKiqaUyfRwiPYnXEE,1426 +torch/include/ATen/ops/avg_pool2d_meta.h,sha256=OaS2zUGL5NNNKf7oGa_yyyBhFVo4rdg-I6XYyzhOUAI,3571 +torch/include/ATen/ops/avg_pool2d_meta_dispatch.h,sha256=1WxYS5oupSyoh9KbKD1xKgpQS7Aebq128XsoVq1Ye-E,1426 +torch/include/ATen/ops/avg_pool2d_native.h,sha256=j0X_3qoDSUcPHjYwTCsuj1E4thu0qZBZFMa8GC1SqAE,1852 +torch/include/ATen/ops/avg_pool2d_ops.h,sha256=5YHh-trVjCVUgY_TkQLw-6TI7feLLmqh4qc-VE3jM_w,2694 +torch/include/ATen/ops/avg_pool3d.h,sha256=YXnWnAaHsK1YLTi5-Wui0trC44xQI8qPZk0cLnsTydA,2229 +torch/include/ATen/ops/avg_pool3d_backward.h,sha256=_tbFty3oE9_6k37qDsewYYe-2nto7fS2o9VBd8LZWHI,2463 +torch/include/ATen/ops/avg_pool3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5tLBeGAtcVckq0_rzD1tSTjMS-QitQZPZ2TCz1RRVts,994 +torch/include/ATen/ops/avg_pool3d_backward_cpu_dispatch.h,sha256=Yla6GcLsLve2Lz2LGG3cB0x2rmZEJC3WOdyFYuLQnQM,1503 +torch/include/ATen/ops/avg_pool3d_backward_cuda_dispatch.h,sha256=6jByG8WmOuHnH8Jt9VmxXfJfWVVqCZ68eD6TAGK3Wp0,1505 +torch/include/ATen/ops/avg_pool3d_backward_meta.h,sha256=hICckbq8dKRQAXJLsYCxnxVqGTQwu1vT0ABvZLeyHgs,790 +torch/include/ATen/ops/avg_pool3d_backward_meta_dispatch.h,sha256=bbNnC1hA0A3FWQ578NElXOqt0eTByg-cbPgtm8J3ddA,1505 +torch/include/ATen/ops/avg_pool3d_backward_native.h,sha256=Z5cUVN4VXLGsyZ0qVMcA9_QUGPc4tyPGmKW3Vq-Fz7o,1779 +torch/include/ATen/ops/avg_pool3d_backward_ops.h,sha256=-aXNcyHcLPJ71p5F8xwgQyDA13wHtrUUFO8yVIbl7Pc,2956 +torch/include/ATen/ops/avg_pool3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=IssKgSWOyFIOfeiAJ61Wo2hJazh-RuqY-nJpds2nSm0,982 +torch/include/ATen/ops/avg_pool3d_cpu_dispatch.h,sha256=AStxN8QR2QV-jzh33i9fWiLvc3pC6PvkOddbOcmkCMk,1424 +torch/include/ATen/ops/avg_pool3d_cuda_dispatch.h,sha256=sqdbp_9DBQKVh4RI5GvX9kgKn_8oD9eySeZC9PIRvA4,1426 +torch/include/ATen/ops/avg_pool3d_meta.h,sha256=w9l-GVd0PuzbdOFZa0mtybRguWiuxxcwoDCV_G_6U54,749 +torch/include/ATen/ops/avg_pool3d_meta_dispatch.h,sha256=k2UF824yw0Tuc5yEChqzA2Qr-8uQk9nuNNDG8gSdLYA,1426 +torch/include/ATen/ops/avg_pool3d_native.h,sha256=hSap_dPrF3y4m5hso3YYCdT9DMIOkpvOeUNDCYxUwpA,1856 +torch/include/ATen/ops/avg_pool3d_ops.h,sha256=KaX905vlNmlkCzGKA-FzjzHYhmXMH_cXsYY5a2Zsj3M,2694 +torch/include/ATen/ops/baddbmm.h,sha256=mYItcuxuRST-io2SE2eZKOy80aGmi6uFTshF_ouLgSQ,1621 +torch/include/ATen/ops/baddbmm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=8Ofyo5U9fpQA2tb4KRJai0j1Sk0D6ilq5kJ0WnWFptI,1061 +torch/include/ATen/ops/baddbmm_cpu_dispatch.h,sha256=9bF7yR6FY-nWl9qxwu6Az1oPbYpqql3ULwyMmpoSsDM,1364 +torch/include/ATen/ops/baddbmm_cuda_dispatch.h,sha256=JOgoWdK9GwbRal6wS-omqqnR9Z05CihOLekwAnC5wi4,1366 +torch/include/ATen/ops/baddbmm_meta.h,sha256=D7B3j9II4JTyOOAbGXlBdvAWCCy4_wSTv9sOU02EipQ,692 +torch/include/ATen/ops/baddbmm_meta_dispatch.h,sha256=ssHIzyYP0Iywmv5IUACn6bnK5wNfBZUIZuYBCquGTLU,1366 +torch/include/ATen/ops/baddbmm_native.h,sha256=oCeklPKm6GEK0wapqF82RtyU6t2muxKC2uDDQrIOLWk,1172 +torch/include/ATen/ops/baddbmm_ops.h,sha256=p5wuL6dyjIRTd7JhOX4J9PDLyj4oV0PodhUo4Vr71tM,3190 +torch/include/ATen/ops/bartlett_window.h,sha256=4u69O_eV6kYFplysjHCY20bptcsbJuSG4cwuZlb8r9M,3389 +torch/include/ATen/ops/bartlett_window_compositeexplicitautograd_dispatch.h,sha256=30KoVdso8BsDWk1W_lwzLV_juM2_o7atzlUX7AkIl6w,1690 +torch/include/ATen/ops/bartlett_window_native.h,sha256=dN-91InHJXKAEp5DEOvC8bql7nH-rIKe83O8DUDz0Vo,1062 +torch/include/ATen/ops/bartlett_window_ops.h,sha256=QfYvSZHp-onsJbx4qCpl5PZ3Pme6i5AL5h02ADXDgYg,3917 +torch/include/ATen/ops/batch_norm.h,sha256=oU9WWz9AKTkeVZB9iG2nGbcPJTicH36G1fQvQy21wEY,1101 +torch/include/ATen/ops/batch_norm_backward_elemt.h,sha256=0CeuXiiqNQcfzGUQVtcaxSqfXgtvxH0kJWvis6gEu_4,2339 +torch/include/ATen/ops/batch_norm_backward_elemt_compositeexplicitautograd_dispatch.h,sha256=mtdCGUJ0aFPvyUxoRBGj3lrCXTWyt4nINF2KIas37bU,1321 +torch/include/ATen/ops/batch_norm_backward_elemt_cuda_dispatch.h,sha256=t5kGlMhsEkk2R_KrqQxm22MPPS8hXAWwvbxZMYwbP58,949 +torch/include/ATen/ops/batch_norm_backward_elemt_native.h,sha256=3-93EaSHbWjcRb6sD9WNs8rpoJj_5nrfAsqjeOIhMDI,1024 +torch/include/ATen/ops/batch_norm_backward_elemt_ops.h,sha256=tceaxufU_8Loyx_MaaSSVDL_8_McfMoHSsbCgpQr_es,3066 +torch/include/ATen/ops/batch_norm_backward_reduce.h,sha256=fAYaRguvwQ0VxR1pP-4_5-b_wh3Pz9jztPVRd8w4sM8,2718 +torch/include/ATen/ops/batch_norm_backward_reduce_compositeexplicitautograd_dispatch.h,sha256=eI5a8ukg7bzJN1R5bZcaRn2RYhj7JA0Kz-B83oBfETc,1461 +torch/include/ATen/ops/batch_norm_backward_reduce_cuda_dispatch.h,sha256=5Ad9VK9Qw7MaNVd1cC9UFvvW1bHCLNdA9xEco9D4ZMo,955 +torch/include/ATen/ops/batch_norm_backward_reduce_native.h,sha256=Cl2xfL4tY0g83qWFIdC72KiQkDg5LVAqqDgmpAgzwdI,1100 +torch/include/ATen/ops/batch_norm_backward_reduce_ops.h,sha256=5bNhTCas1kLRaHe3NA8EXRtlro2joEfWxG4wSberhvE,3382 +torch/include/ATen/ops/batch_norm_compositeimplicitautograd_dispatch.h,sha256=kn9FsqyZn0CVw3VT-6jEbyiLHYrLYvZ6NyZ35BvdLnU,1010 +torch/include/ATen/ops/batch_norm_elemt.h,sha256=nXcT1UepqeP4omhz2PzZ3vN9oR_lkIalUp3PcWMdJIM,1868 +torch/include/ATen/ops/batch_norm_elemt_cuda_dispatch.h,sha256=Jya5SkCpUBqzUIISqLltfU0PFS06b_-jlUqnv7Pxs_8,1350 +torch/include/ATen/ops/batch_norm_elemt_native.h,sha256=_QIEupSCfWqvlYSv6OIjY23CSAiiAYIQmvcxkP_-Z_g,889 +torch/include/ATen/ops/batch_norm_elemt_ops.h,sha256=GMTsBi6sq_rQT1Uu3z8PFTkA3yF3Tzn_N1WJZt3mlS8,2614 +torch/include/ATen/ops/batch_norm_gather_stats.h,sha256=YPiOMbefHCczm8lP0wRXf7rWg8GS4mhSelysNSePiQg,2490 +torch/include/ATen/ops/batch_norm_gather_stats_compositeexplicitautograd_dispatch.h,sha256=Tht28TscYWONQy9AQVGWJG9UDKRjBfmi0yso8fnuKLE,1379 +torch/include/ATen/ops/batch_norm_gather_stats_cuda_dispatch.h,sha256=96gvuaEsZjO7_XiObBgpYkYeIXfAFI3AUYGVR-u0Rm0,956 +torch/include/ATen/ops/batch_norm_gather_stats_native.h,sha256=9RZLIb2MAAkzKzG99So6pXsyLqIwRhTYqOaPr483NUg,1060 +torch/include/ATen/ops/batch_norm_gather_stats_ops.h,sha256=4FecxG4xy96nL0IlVIT2VeAHEqIrUjtELhZQFMUm-I4,3202 +torch/include/ATen/ops/batch_norm_gather_stats_with_counts.h,sha256=nGIvTue38jk0uruO-6Iv5-czDOKdX9hWZqw7Np9EXHM,2661 +torch/include/ATen/ops/batch_norm_gather_stats_with_counts_compositeexplicitautograd_dispatch.h,sha256=XxJUPjcDHYKglwRvogKVzVneybIxsi1_arhMnOBoa2Y,1427 +torch/include/ATen/ops/batch_norm_gather_stats_with_counts_cuda_dispatch.h,sha256=xiR4D9N3ymi8swKy3KuHnyLEI7O-LAZwmrB4eXbmZjg,980 +torch/include/ATen/ops/batch_norm_gather_stats_with_counts_native.h,sha256=sMVrRCMLf_Zh0Wd905mBiuL51m03WExtZOkWxtfcSs8,1108 +torch/include/ATen/ops/batch_norm_gather_stats_with_counts_ops.h,sha256=vkC89nfBV2n4ra2nj6nQUCDE2fW2oFrgjGwcLGU4aOY,3352 +torch/include/ATen/ops/batch_norm_native.h,sha256=MsmaGWwk6B_PgL9qH4rdIay6MvgrmLxOORlOgSkV7Hs,733 +torch/include/ATen/ops/batch_norm_ops.h,sha256=fB9xWkvMSaW5_UPoeTvo5NRcOW0ht-1a3W2jiuCV1JU,1767 +torch/include/ATen/ops/batch_norm_stats.h,sha256=eXOOAp6MvpNSRjI2R_qYaGo2VyRia3JZFiIMAC9nz1o,1415 +torch/include/ATen/ops/batch_norm_stats_compositeexplicitautograd_dispatch.h,sha256=ZAPOV0qBmd-GZ87oVVTWdPecx6jR9YeA_z1gDsbwtTo,1007 +torch/include/ATen/ops/batch_norm_stats_cuda_dispatch.h,sha256=HOpegR8AfirwAstSrTCTvVDqyNrGWWNDY54bLXZOhYQ,770 +torch/include/ATen/ops/batch_norm_stats_native.h,sha256=iD5HOO3IGPNuhrJG94G6jMtudA8DcELgaXRvTURkLFw,688 +torch/include/ATen/ops/batch_norm_stats_ops.h,sha256=freO-jdCYv4k0MRr3Z1QDyUDFQ-Y4_68lg-RG1JyvJQ,1994 +torch/include/ATen/ops/batch_norm_update_stats.h,sha256=XANYrkTH2feH8i2LKmaS72UkTksHdmRiAZ9J0xOUjq0,2025 +torch/include/ATen/ops/batch_norm_update_stats_compositeexplicitautograd_dispatch.h,sha256=HBKzU7LKqxlKpvVjoMfzat31NVO_QCmv4I4sLQWc53Y,1221 +torch/include/ATen/ops/batch_norm_update_stats_cpu_dispatch.h,sha256=1zMLsexRNu2tzbaAZvZ9tSQ2kF-rdfJhdAnyZEuWLpE,875 +torch/include/ATen/ops/batch_norm_update_stats_cuda_dispatch.h,sha256=1fKkXSeGlSLxSZBFYk0zlSv4Lj2KRi3fvm_xNsZCqU4,877 +torch/include/ATen/ops/batch_norm_update_stats_native.h,sha256=J8e3D5tgpjKA_wd8vmfYdxGavsuy2T57sujSTgzJ-iU,1115 +torch/include/ATen/ops/batch_norm_update_stats_ops.h,sha256=ZH74nDAtfAZexdA4bYejJqp_dQIZoGZ03Lu4PIhQbE4,2672 +torch/include/ATen/ops/bernoulli.h,sha256=tvrGOsXKc83h5HDPzEoMz4XqL9xzuWNijR7_DLuuS2E,3191 +torch/include/ATen/ops/bernoulli_compositeexplicitautograd_dispatch.h,sha256=p-XoapokZsFOhIxlrVwyds_SVofX-cwmHYlOYX4stAE,1532 +torch/include/ATen/ops/bernoulli_compositeexplicitautogradnonfunctional_dispatch.h,sha256=HStMSm9jpOIs9CDx6H8px5LQ3xvVx8Lzyxi6UIWt7sk,856 +torch/include/ATen/ops/bernoulli_cpu_dispatch.h,sha256=znXI89aHfPEOD_n4hGU4jYVs5ficbZjIvpTCIZjY03s,1172 +torch/include/ATen/ops/bernoulli_cuda_dispatch.h,sha256=HztPSNhE-7mO8xYqZk9wTJQ3ZZu06bgKjduPb8Nzypw,1174 +torch/include/ATen/ops/bernoulli_meta_dispatch.h,sha256=6xesPnlzoN5SXQ1QPnArdxslxK6_LFqAmRBcv2hDxmA,918 +torch/include/ATen/ops/bernoulli_native.h,sha256=G4D0DFRHwHlw6-XhHgyQHYkTTOmaLsUycUW0RczilZQ,1453 +torch/include/ATen/ops/bernoulli_ops.h,sha256=gLzQpwFRUwKULM75PLYIG1wEvtymbFNwtuE3xIBR-O8,6591 +torch/include/ATen/ops/bilinear.h,sha256=SK0pjZcijWWPiNsXuJjA0xHbI9NKdA80ay_Q_4mqRsw,807 +torch/include/ATen/ops/bilinear_compositeimplicitautograd_dispatch.h,sha256=GaW2DpnOeGKaMU4wpFbJ443dQwK5I8AzyCOSHUDMess,865 +torch/include/ATen/ops/bilinear_native.h,sha256=_VAdEFq9womuhbHz3bTrECl4GfoQXroM_v5SuIF8cjU,588 +torch/include/ATen/ops/bilinear_ops.h,sha256=tj-wh1r-F7PpEJ5LggWoGRFOG9Wf07L2U86FDhTJhc8,1291 +torch/include/ATen/ops/binary_cross_entropy.h,sha256=KWxGFd4YxkorHnB6bgll2VQZUD3P7i5EJaBX7HhDtKA,1714 +torch/include/ATen/ops/binary_cross_entropy_backward.h,sha256=kfia5nS6Pz4fzxJXD9usd4IQm_cVDU99gG3uoIk4fu4,2069 +torch/include/ATen/ops/binary_cross_entropy_backward_cpu_dispatch.h,sha256=eBrlB2_E_0IIeKGrEo6LA7aGkcOtqDrmv1CyHEIYLa4,1366 +torch/include/ATen/ops/binary_cross_entropy_backward_cuda_dispatch.h,sha256=g4F6TTmmpfDBdtNnN9-EdeMXWKVjFUuyNq4BCyDFZDo,1368 +torch/include/ATen/ops/binary_cross_entropy_backward_native.h,sha256=1hzxwaMNJQbMMIroEileaRokqGbLP8hgF35BUr7do9I,1347 +torch/include/ATen/ops/binary_cross_entropy_backward_ops.h,sha256=Mhb9IOXAv4c6nkk24QQ4zRNdv8FcYKNzcHzH2Y41MS8,2570 +torch/include/ATen/ops/binary_cross_entropy_cpu_dispatch.h,sha256=jSc6VTqmDD9T4591-u1EHlJSff0ukttl_gSBtCxmdiQ,1229 +torch/include/ATen/ops/binary_cross_entropy_cuda_dispatch.h,sha256=iih7RLF2370rjgWo9PbSajZ2fFm1hL_2S5e2MGxyrMQ,1231 +torch/include/ATen/ops/binary_cross_entropy_native.h,sha256=q8q_koVtme9OTG7-FIZvxYuwsgimq9ZMR8kgdghBHJk,1169 +torch/include/ATen/ops/binary_cross_entropy_ops.h,sha256=vV5a7kAVyjHcBs0Gl2y-PjN90k3w4DyvEgwboX3KhnA,2266 +torch/include/ATen/ops/binary_cross_entropy_with_logits.h,sha256=fbUMZmCNOYXoNctTUzFu3s_sdwpQsSGK7afiOQe0m80,2089 +torch/include/ATen/ops/binary_cross_entropy_with_logits_compositeexplicitautograd_dispatch.h,sha256=l8MfZQAOufGn5moGKLM3gMvouMFoB5dVpjmiQBTYrTw,1453 +torch/include/ATen/ops/binary_cross_entropy_with_logits_native.h,sha256=lhFb0L-hKc3-O1s4F9ccbICn7OeEkjFeOLaNG7pB4wY,911 +torch/include/ATen/ops/binary_cross_entropy_with_logits_ops.h,sha256=XNheKS9IMsUTambNXab45FWsz24uNg1AIdkmHGdZ-vM,2642 +torch/include/ATen/ops/bincount.h,sha256=XkHN_dRVySEbfF_cnrkzzO6j0G6WF_WG7MJ8nFD4zr0,1408 +torch/include/ATen/ops/bincount_compositeexplicitautograd_dispatch.h,sha256=H1mpX2CYBMXqs4rIgoKq7Rr0qhms99LDNo2pxdRONEc,1000 +torch/include/ATen/ops/bincount_cpu_dispatch.h,sha256=Q2nPsKLamW3uIdtShVCTGIfet0Iz0QzH4_hUw7ni7jM,789 +torch/include/ATen/ops/bincount_cuda_dispatch.h,sha256=Ss2f3DIanHElOk_SFS6dcX5iG0Sqpf1JN24Act5M334,791 +torch/include/ATen/ops/bincount_native.h,sha256=Nm3lhT6XIFsg3dIkyxVX2NFUGNstbl6FQKWcQIanReg,832 +torch/include/ATen/ops/bincount_ops.h,sha256=9XPTiptz--0VLYSgwaSva8kDG2khchiBrO9Zw6A0Tn4,2016 +torch/include/ATen/ops/binomial.h,sha256=szhoNfRoDJiSPWiIqDc1Owr4bXUKCw2_yWc8k_dZhgs,1436 +torch/include/ATen/ops/binomial_compositeexplicitautograd_dispatch.h,sha256=-QxfaqR6tvB8wY4uJtTvvH7nyKfrFXgYOsCHmlf4ob4,1016 +torch/include/ATen/ops/binomial_cpu_dispatch.h,sha256=hOWLLZlY3Pk5n4F-p77Kr_wucq13H4C9jGUzwxc88hg,801 +torch/include/ATen/ops/binomial_cuda_dispatch.h,sha256=zp1rWPWxC6qUDPeFh9veqJCgbXe85woykjF5tYOEHYo,803 +torch/include/ATen/ops/binomial_native.h,sha256=Ts5WUQYGelafTJm9rf0VI8Dz3ZXctdUBbqCehydNF54,864 +torch/include/ATen/ops/binomial_ops.h,sha256=nx7mm1Y0asmHlEZWII0Q7owLLqo3F13vKPO0rWnArHk,2048 +torch/include/ATen/ops/bitwise_and.h,sha256=_FUh-JXy1Ux6H_mXdGIK5QnGKEohrKTiNBVW4NlKGzE,2796 +torch/include/ATen/ops/bitwise_and_compositeexplicitautograd_dispatch.h,sha256=8ZaI1H4eg5D_cXL24Bvi7jGQsDcbD5HbSUGog8qBGGU,1400 +torch/include/ATen/ops/bitwise_and_compositeexplicitautogradnonfunctional_dispatch.h,sha256=MJzsMWYVZHkb_5VyR6QjOujDYNDjFMvxA5bGR1eFi1I,903 +torch/include/ATen/ops/bitwise_and_cpu_dispatch.h,sha256=EKMSRJXrsv5kBpkeX3vZpLL7nOd_PhpHorM0coVr9QU,1052 +torch/include/ATen/ops/bitwise_and_cuda_dispatch.h,sha256=kj_kV0ws2q8v7fkOcnn5rNuai5j45Zxc0yiA634Ed4s,1054 +torch/include/ATen/ops/bitwise_and_meta.h,sha256=io9ZroX-MxW0agaSeyfTJ3_uUOyqkXSDYs5xmFpnhy8,624 +torch/include/ATen/ops/bitwise_and_meta_dispatch.h,sha256=Wao3v2z8ZnVqJdDL2fM5AioaxK2PQz-U8U3gxwC-6OA,1054 +torch/include/ATen/ops/bitwise_and_native.h,sha256=V5rCcRdjXXW50kwbhBewro6ozyqyhcYN4lgPt0D8TMU,1139 +torch/include/ATen/ops/bitwise_and_ops.h,sha256=BmmlioF68yYciK1hFJGuMqVccI77tcO2lOLtuEWFlyk,5979 +torch/include/ATen/ops/bitwise_left_shift.h,sha256=ugjGQYfqIVK02lSdoYHPUMXd_dZLloZOmnJxXYteTV0,3034 +torch/include/ATen/ops/bitwise_left_shift_compositeexplicitautograd_dispatch.h,sha256=AdNDWeu-6klGNM-OwdXdXixTJpsmOEpx-KERmCnp-64,1449 +torch/include/ATen/ops/bitwise_left_shift_compositeexplicitautogradnonfunctional_dispatch.h,sha256=xznL0Pf7UHLXibz6MhFFPfZTgxTqrueSt7SRfKgcAjE,917 +torch/include/ATen/ops/bitwise_left_shift_cpu_dispatch.h,sha256=Td4Rxgw-afqnp_BWY9OaUuaUFJ27Z-kSI-zTPvyHYNo,1080 +torch/include/ATen/ops/bitwise_left_shift_cuda_dispatch.h,sha256=-h5zYJVAPvIZN37TVh_ldkAjsqoQpKYEvjOLLLAjYj8,1082 +torch/include/ATen/ops/bitwise_left_shift_meta.h,sha256=h6Fx5jd0DS1gPQPbQm3ntmqtc9cMlk3VTSm5Hbccq-c,631 +torch/include/ATen/ops/bitwise_left_shift_meta_dispatch.h,sha256=eb5xFg84HRrRHn1ubU7lzu2AtnmSndxOlo3lFpOeRTw,1082 +torch/include/ATen/ops/bitwise_left_shift_native.h,sha256=vQOzM-UqhVPvMtDDgLveRVkCDQwqsunQ6ysdXucf7MY,1195 +torch/include/ATen/ops/bitwise_left_shift_ops.h,sha256=hkzyTGjLVduBjtavm6_17ZMRoq71nMcEtME7swaCIvw,6210 +torch/include/ATen/ops/bitwise_not.h,sha256=NqI4CD5P6Fe_fNVxiA-gMOVWKiyRqXQ6IW9g3zFrGio,1065 +torch/include/ATen/ops/bitwise_not_compositeexplicitautogradnonfunctional_dispatch.h,sha256=dfVbUdqzflc6_VEoePRAtcu8wYq47L8kN_ceko_WtsI,851 +torch/include/ATen/ops/bitwise_not_cpu_dispatch.h,sha256=X1haEgPEEWAhmDS8eI1eFu26hgsW81IEdCd88L9DVKU,948 +torch/include/ATen/ops/bitwise_not_cuda_dispatch.h,sha256=2OSMuXUSuYRNZrIMTmCcISa-jw6xGvwRo9C7IC0652w,950 +torch/include/ATen/ops/bitwise_not_meta.h,sha256=xozA2um9u3OpuzSwshAlMCIklldTLXK0rIKwIZlcc3Y,591 +torch/include/ATen/ops/bitwise_not_meta_dispatch.h,sha256=zmQxz6rREY57rwObV5jcWvwixD3sVMKyW3VFUDSaN8Y,950 +torch/include/ATen/ops/bitwise_not_native.h,sha256=Aegjgh1rLebwMK49kHDG-avQC5HdoE1zWMncRCGX6iA,622 +torch/include/ATen/ops/bitwise_not_ops.h,sha256=ytleaNcIwLgLWLGrRSLMIEgW-CDzZ-I31gct5MGdtp8,2167 +torch/include/ATen/ops/bitwise_or.h,sha256=bwutPfrjbOrpn6L5teHvp1JDgbORQSifNj9GkWZ4EbM,2768 +torch/include/ATen/ops/bitwise_or_compositeexplicitautograd_dispatch.h,sha256=JKEgJ0whAcAMbO8NtAt46GUbI-UyQiXVAqHDOIFyxz8,1393 +torch/include/ATen/ops/bitwise_or_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Z1JKmNLgp7K5WmPpXI-oJKMrFrTGHLIogCIZH8m5Al4,901 +torch/include/ATen/ops/bitwise_or_cpu_dispatch.h,sha256=aNXdW5P3YMnd-YnGKwlcz6_jzyRxfVdno8JHOF0B6mk,1048 +torch/include/ATen/ops/bitwise_or_cuda_dispatch.h,sha256=QqkgltCyXXVfabHm7AUK7I6MCvynqL0jsgQ-ruX-nck,1050 +torch/include/ATen/ops/bitwise_or_meta.h,sha256=1KVIJAf2ChXEj6Zv6H5EwmI1GykIgq8qvH8HzhKUeMg,623 +torch/include/ATen/ops/bitwise_or_meta_dispatch.h,sha256=n4UN3njmnUIPZrAvOcob-GKThUtUpouN20gaPZvMunQ,1050 +torch/include/ATen/ops/bitwise_or_native.h,sha256=OHhp27C_hisUO_xM7qCmAP-OW9_OFWHrZJZ-wVmKIkA,1131 +torch/include/ATen/ops/bitwise_or_ops.h,sha256=6HUyKGYr602tD2WkTZI0OKJ03nmjUBoGb_d30PIkp2E,5955 +torch/include/ATen/ops/bitwise_right_shift.h,sha256=WZL7IWwZxkwT91kBLgs12e-iQH1xvTWugkJmptemgTA,3062 +torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautograd_dispatch.h,sha256=Oeyu_Q4mUOeLpeJ6hLvmvW021M-XSTNwbOXTAhQrsgQ,1456 +torch/include/ATen/ops/bitwise_right_shift_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ZLB1Q67deHOZ5bUJYfyETrdQdj21ElCllB4XTdTXkaQ,919 +torch/include/ATen/ops/bitwise_right_shift_cpu_dispatch.h,sha256=98hmqzwBwCeybollq59L1pkfYnPsYJLDEsmVD9ZNPN8,1084 +torch/include/ATen/ops/bitwise_right_shift_cuda_dispatch.h,sha256=3OCzn7HkXoXiXzX8CjCC10oOf4yYqeR74vVFSOHrTJ8,1086 +torch/include/ATen/ops/bitwise_right_shift_meta.h,sha256=zPmfcKx58L1wdBvzkCwdoyZcTu4f6IzdaaA8Sw9q1OA,632 +torch/include/ATen/ops/bitwise_right_shift_meta_dispatch.h,sha256=SMycmub9tn68MQc92iVR0w1BGeldVvAj1wh9V2IuzLY,1086 +torch/include/ATen/ops/bitwise_right_shift_native.h,sha256=Ynzm39qglxrm5BRgo_qSVqnetYDLWL9DE_FDDIKFPGs,1203 +torch/include/ATen/ops/bitwise_right_shift_ops.h,sha256=edmQcHytzGX40reKv5SCX4DDmZzKsAHrprPFXqCbQVg,6234 +torch/include/ATen/ops/bitwise_xor.h,sha256=SpTypmAnaB8yNqBRKkD-G0DpyKgRTAnOJ7Fp6fcp8Ik,2796 +torch/include/ATen/ops/bitwise_xor_compositeexplicitautograd_dispatch.h,sha256=cXHAagz2ZgByCJMCtRiQDqol_MQNDNTnzRifpF6ijfk,1400 +torch/include/ATen/ops/bitwise_xor_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rMofNG8-fc5ojqPyq3YW7EeHRF6qcjAHg-xyO-Z86hw,903 +torch/include/ATen/ops/bitwise_xor_cpu_dispatch.h,sha256=k_hDQhYCc6IQJKGHHZ7W8Z8_Isz7y28HJrNgXjFxLbw,1052 +torch/include/ATen/ops/bitwise_xor_cuda_dispatch.h,sha256=SZV093s2DccxtNOVrKT3ekL-Vz4iiXogTrUIZaCvN-c,1054 +torch/include/ATen/ops/bitwise_xor_meta.h,sha256=hYvN2b4JUdhHc_g6jFU2RRhR_XnjAAMme8F7_ZPpdek,624 +torch/include/ATen/ops/bitwise_xor_meta_dispatch.h,sha256=7-USEQJJdk4qFc-jZEQAoisApIlk7O9s7L6Db5Tau8Y,1054 +torch/include/ATen/ops/bitwise_xor_native.h,sha256=AZMx0BZsPzG-bZ9XN8WkoZPzkHafEDHg-CM6xwQ5eW4,1139 +torch/include/ATen/ops/bitwise_xor_ops.h,sha256=d4n-37PghtUXE5VbG9OKgCpbkwQyPVv_zLX-tGp7DHc,5979 +torch/include/ATen/ops/blackman_window.h,sha256=Loy5-807qf7kmtwGQSPYoGPWRzk274Rxn8XFNDwTUvg,3389 +torch/include/ATen/ops/blackman_window_compositeexplicitautograd_dispatch.h,sha256=vXLhS4MJi6rQtFFcSfzByM3EkRccTZcjdf1fHgVdEeU,1690 +torch/include/ATen/ops/blackman_window_native.h,sha256=pz4CV8Nh9T5lGK9jwYsi1XlZS2o4Zol5sq146xMCkuI,1062 +torch/include/ATen/ops/blackman_window_ops.h,sha256=IiNEYK5mqBlB_UZXGlUg5WrwMzvhlt53zT7KaT1dCso,3917 +torch/include/ATen/ops/block_diag.h,sha256=E1gUutESogZomlWX4me92MRfu8ac9s-4oGhgGGHi5Bc,1076 +torch/include/ATen/ops/block_diag_compositeexplicitautograd_dispatch.h,sha256=-LBKvYSKIsSqmw7cYB_Io13cOf82V2S1pV9EZik8Us4,930 +torch/include/ATen/ops/block_diag_native.h,sha256=UBnUOISd1Avg2JdjbH3uhp0ULVLpji1LFTg-140GzUE,571 +torch/include/ATen/ops/block_diag_ops.h,sha256=l4JLjof1d39O-oUEMySJRmvBSj3TJtQr036qz3U-JIY,1612 +torch/include/ATen/ops/bmm.h,sha256=IjrgXxSCL5piSW2nTWzimkkehyKdsF_Psoj2RmpRP58,1117 +torch/include/ATen/ops/bmm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=lkPn0Te0SbAOYDsmtNCHddxe9ROOx6MJVuXdKj-PxP8,812 +torch/include/ATen/ops/bmm_cpu_dispatch.h,sha256=Tk5v-4kJbuVK7VkvuF8DGjJ7Fx6GncR276JJqANcUdw,943 +torch/include/ATen/ops/bmm_cuda_dispatch.h,sha256=VkOtk3avLtOl0jva4BcubsGfuzJdaNYmYekAUPTPEY8,945 +torch/include/ATen/ops/bmm_meta.h,sha256=iJ3c4HQIOO6JM8qv7ztrBLYj3SrdJaSuuUxavC1sbak,608 +torch/include/ATen/ops/bmm_meta_dispatch.h,sha256=a7XP4cS94lJOIKLhwdGa54UN5gcH5FhLZ7LeLfVGnLU,945 +torch/include/ATen/ops/bmm_native.h,sha256=oqnd5DEPyBdcbPxqVEBgxzAcmTGecTFxk0u3tA7hoTQ,1477 +torch/include/ATen/ops/bmm_ops.h,sha256=saJsW5oNDUmOQUSi9xEWoDdyP0O16MiJEq4WIcdxfRg,1738 +torch/include/ATen/ops/broadcast_tensors.h,sha256=c3hCcZuuhiOzK-nz9gzKxqGB6t1-kutInvVYcPLnwmM,693 +torch/include/ATen/ops/broadcast_tensors_compositeimplicitautograd_dispatch.h,sha256=2EVZOKuLXaOqBtct3I5TPA5NsexwS7BsyNJYEX3Xmq8,789 +torch/include/ATen/ops/broadcast_tensors_native.h,sha256=6HD0eshbLXLkds5znbSBENcxp7ofgBTpvCS_T-BKgnA,512 +torch/include/ATen/ops/broadcast_tensors_ops.h,sha256=ehTAWOiBPdDKtWik0HirwiKJxlgk014HnCsSiqTlKks,1046 +torch/include/ATen/ops/broadcast_to.h,sha256=7c8C6a0_dV2BTkoPyVIFqGaWQZBh_4WlJbIFf9g8QUg,1449 +torch/include/ATen/ops/broadcast_to_compositeimplicitautograd_dispatch.h,sha256=rDQbKsedKW7I22IjBMmS2vBlpXzpyNCnuZDMYBETdIc,885 +torch/include/ATen/ops/broadcast_to_native.h,sha256=lY4b_1WfRzb1Z3O9QDISRyA7_dNm_12z3WOwaWAnUsY,526 +torch/include/ATen/ops/broadcast_to_ops.h,sha256=DsQhBtOk1s23x2qFzyKiFtKCcN57o3zzj49Gvil6_Mk,1079 +torch/include/ATen/ops/bucketize.h,sha256=1eAfCitKSZgRZsYV1XM4mixQWynh8bdoss59L31lfDc,2623 +torch/include/ATen/ops/bucketize_compositeexplicitautograd_dispatch.h,sha256=shWFqfYbLNpHzLp0RpXHq2GZmSdGEaRVWFZUCzhDh4w,1003 +torch/include/ATen/ops/bucketize_cpu_dispatch.h,sha256=EQG2QlwM8JXWINglJO6oNeBStDj7td5AilcSdw6JVmU,1215 +torch/include/ATen/ops/bucketize_cuda_dispatch.h,sha256=F2wgBJDfZGEJpJDliBI-LipB8cHdVYOIdnKwz5ThySs,1217 +torch/include/ATen/ops/bucketize_native.h,sha256=yyse2LQbBfjvXENypQINnXk90ZJed8FbBWE_CtUyFW8,1399 +torch/include/ATen/ops/bucketize_ops.h,sha256=FOYgQ7sprI6Ca_xHOX4G6jkts8Bb4tchvtzS0Cvh_eM,3706 +torch/include/ATen/ops/can_cast.h,sha256=H2vntXRMooq4ZA3Mt7Tkh96L7sZ0U5cA85wZ6ScWams,663 +torch/include/ATen/ops/can_cast_compositeimplicitautograd_dispatch.h,sha256=--_7px36ywnDOhsip0btroMK9sL_yky5zCeWWrg0hzk,775 +torch/include/ATen/ops/can_cast_native.h,sha256=iRDzbPZQ4EcdUa65qRMFNlXDDYCMLb58O-vWPftH7H4,498 +torch/include/ATen/ops/can_cast_ops.h,sha256=oPSmAc5luyXgin6Vqy1CM0CMV9lPOWTFCZG8I1BwL8M,1014 +torch/include/ATen/ops/cartesian_prod.h,sha256=KD15pWOg6YNxgLiZN1JAfI_U1iL_y0wJgYdEndeY2aY,664 +torch/include/ATen/ops/cartesian_prod_compositeimplicitautograd_dispatch.h,sha256=dmymsj4ZqUPsOKgt_d4eaastHOR4f1xiXDui4nLIIlU,771 +torch/include/ATen/ops/cartesian_prod_native.h,sha256=z1p6HCfEISZiu3HmYXv3asVe_9aTV4KVsWLXtbpCuVo,494 +torch/include/ATen/ops/cartesian_prod_ops.h,sha256=LMWJEGAovV_6FIi8jlIrqeV3u3eMU9sdDPb32OKupeE,990 +torch/include/ATen/ops/cat.h,sha256=gKWX3V_peiG7f20XoNKvqRxWM4tH_eyRSzzgfjtfWfA,1793 +torch/include/ATen/ops/cat_compositeexplicitautogradnonfunctional_dispatch.h,sha256=dRkwFq1hCtidrynksryEs8L442Z7RFwxTjywwk0rZUY,813 +torch/include/ATen/ops/cat_compositeimplicitautograd_dispatch.h,sha256=KxjO71AjyTb-EdyPDOUZTFEJp6fKFil6SUoNqWTdMkk,960 +torch/include/ATen/ops/cat_cpu_dispatch.h,sha256=_zpLE9puvNocjc75ELNUuJKbRyyZ0K2dYHFN-ks69P0,944 +torch/include/ATen/ops/cat_cuda_dispatch.h,sha256=9JBIkZv7H-4HETgykO21_GSencT12_zgC2YrBpfU60U,946 +torch/include/ATen/ops/cat_meta.h,sha256=4jgqbU1wzsZOQqq6mATZJCZBVPHdxuHhN2VwoLhBwZ8,4937 +torch/include/ATen/ops/cat_meta_dispatch.h,sha256=vAbAQK7lGBPpvvC7nGZ0XgqqecLedHQ_hkzB6SyWC0g,946 +torch/include/ATen/ops/cat_native.h,sha256=UDyUnarH7KPioQJaGISLfF-jQN3ED4QtWdI08Ekd1Kk,1562 +torch/include/ATen/ops/cat_ops.h,sha256=K7QjsdAt9yaqHsz7JgR5cNkiWmNvI5ztjlJwXmKY3Vk,3025 +torch/include/ATen/ops/cauchy.h,sha256=BOjf0QQ4lREDfoxcvkq3xL51dysUlMxZA2C1k1P_4Xc,1511 +torch/include/ATen/ops/cauchy_compositeexplicitautograd_dispatch.h,sha256=r98akbPet4aCJe3KWomaAEe_TB7OX4H_wXM9rQrLOLY,1162 +torch/include/ATen/ops/cauchy_cpu_dispatch.h,sha256=8hg5SQ-B2BNWSROQUXwdCmKMeCosTxrGI6OJ6zK0-g4,803 +torch/include/ATen/ops/cauchy_cuda_dispatch.h,sha256=_0NEyT9aRzyRzFS2EXcFXbGY_tp7Kydtt2KDQBFWYhs,805 +torch/include/ATen/ops/cauchy_meta_dispatch.h,sha256=u-l4XJe6Hs3kTZbK8iM5dZOFGRCltq6OC3vKdGc_s3Y,805 +torch/include/ATen/ops/cauchy_native.h,sha256=pXsh3NeiipQ9ll5cAax_eOrrXxMXh9XGT7C2q2Zw0hc,857 +torch/include/ATen/ops/cauchy_ops.h,sha256=qlgPG0k5emdgphglzFfwDIt0_MMs6AZgTag-PlfFHzw,2854 +torch/include/ATen/ops/ccol_indices.h,sha256=v4xJ6OO7Fu3a87VNNn3ZxIPaemWm-IUlQqbGc9LKXwE,497 +torch/include/ATen/ops/ccol_indices_compositeexplicitautograd_dispatch.h,sha256=4WGOOfAKe5FzRJgpgbWPk1dpC9mT6flRTo-jlF7Rgks,770 +torch/include/ATen/ops/ccol_indices_copy.h,sha256=tpAE14u2zoDYVmL0_aP4ktnu-S7a-1bDNgdAIT22-PI,1125 +torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h,sha256=bVxleViJAnqMvlb0AnvtmSsAQfECmNGip_Sf87jmMU0,889 +torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3K7KeH9UnDDQD9xzgR5RCuyDyaRymqeSHQHgfU4Yzds,801 +torch/include/ATen/ops/ccol_indices_copy_native.h,sha256=IrYHdmjBWAKeqk57IoJG1ic70-qtwFPZaJCayoWBPcw,587 +torch/include/ATen/ops/ccol_indices_copy_ops.h,sha256=BweOv85XAZhhyDvMGxLl9eJxdBoL14WGTx1AraF4kJs,1656 +torch/include/ATen/ops/ccol_indices_native.h,sha256=4XvKnlpvgiM0QHxXnPTLhagrtyRcvtQtm1x3VCqCHNI,572 +torch/include/ATen/ops/ccol_indices_ops.h,sha256=TCNpDqKhvU__pRQK-u7ALujYLuz9-C6R2tenD49-qcs,991 +torch/include/ATen/ops/cdist.h,sha256=KCOFnvlYZh2qfeB59EGDwxY4u3mncue3r-CIFbO-ENw,767 +torch/include/ATen/ops/cdist_compositeimplicitautograd_dispatch.h,sha256=M8iNt3shwLITy_LFRNsqBQXCMgS60DLQgZ06wJuRvNc,846 +torch/include/ATen/ops/cdist_native.h,sha256=XojwW14jdnUOaehM7IbfGYjIp9UtEHIajNc7kWHCdvo,569 +torch/include/ATen/ops/cdist_ops.h,sha256=8h3dP9vBlujAivBmLjq4q03lt7K_cxYIqgysMgGjNLA,1196 +torch/include/ATen/ops/ceil.h,sha256=t3chF36-LOfgq2AibS9CYkqgVnRb9vJyaY24A06VKFQ,1131 +torch/include/ATen/ops/ceil_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WP7fIJDR0KTZohmjmePgEXX00sN3cbK4u8hi4PCZM8Q,837 +torch/include/ATen/ops/ceil_cpu_dispatch.h,sha256=7zwcrxZGixOXwT561Voq0rQRziNhnK953PwQRbmsvAk,920 +torch/include/ATen/ops/ceil_cuda_dispatch.h,sha256=Tpk2bpAj3aYJ-gptXs2H-4Avb8GqWK_bZWVQa9-OfkU,922 +torch/include/ATen/ops/ceil_meta.h,sha256=xkveZ8cWVBREa1fuzxg2oDI75uGR1wsL2ozX_S4pJlk,584 +torch/include/ATen/ops/ceil_meta_dispatch.h,sha256=QQfHlzGmC3pWl94y77QsMZP0SgSMC8cqV5tlvtDf-5E,922 +torch/include/ATen/ops/ceil_native.h,sha256=wg1LkQCIrESsqa_1vCdJmbgVmX6k7kqc3yeJq59zhcs,1009 +torch/include/ATen/ops/ceil_ops.h,sha256=fo4Onq-4ct-r5yZXyTLSXFbmYj4OGmoA-ydeqMlB8r8,2104 +torch/include/ATen/ops/celu.h,sha256=KkbzXvMULCcREIML6gTYpJBfkjHEtQ1rv5t7W0SkQrc,1347 +torch/include/ATen/ops/celu_compositeexplicitautograd_dispatch.h,sha256=d9sUBHZ9CwUxLUt7_FTphTtbiVqNbgB1DCAFPblSESM,1080 +torch/include/ATen/ops/celu_native.h,sha256=3dl-xBxzwybt5rdAC_KiG1ZMUAeVAH89bYxNHST__5E,696 +torch/include/ATen/ops/celu_ops.h,sha256=80eihAqTJDKPDQoTReOXXZSTRqOQIfX1V6daxFSC42U,2374 +torch/include/ATen/ops/chain_matmul.h,sha256=lFspfx_iqWBxA1fq-13w9JJ-gVSAg1FHdX53Y2gp8G8,1105 +torch/include/ATen/ops/chain_matmul_compositeimplicitautograd_dispatch.h,sha256=tXk-x1GHWlZ5qbO2J5K-nr7IReloIamp6TqcWRt3DU4,939 +torch/include/ATen/ops/chain_matmul_native.h,sha256=8ItxEld4IFZhiJ0xhuyULm4o2y0ckRBt4UIvCsGJeZw,577 +torch/include/ATen/ops/chain_matmul_ops.h,sha256=xlp6Mt5OVgW8NnOly4enx93pLjomTP5hSp2m1rKw1ts,1630 +torch/include/ATen/ops/chalf.h,sha256=kcpcRrk_J49-k4q9yOYBQ4DNOK0Y2-ErCUMip3oR650,490 +torch/include/ATen/ops/chalf_compositeimplicitautograd_dispatch.h,sha256=l1LkqLeNO--gbrhYuvbR1-aRNnz0X9EDj3ts_b5wX4o,823 +torch/include/ATen/ops/chalf_native.h,sha256=bJwO-XLaNqdfi-4ExiC09mhwY8e8PRWcfuz1o4kuTdQ,546 +torch/include/ATen/ops/chalf_ops.h,sha256=aUzv8xNcpmQQWs9m5SrzdvYULyRBMKGI0EpufbMFXsw,1128 +torch/include/ATen/ops/channel_shuffle.h,sha256=1WImMnCK17UscQEaBg6p7EdBE30q1opxFCjvmhKsurE,3584 +torch/include/ATen/ops/channel_shuffle_compositeexplicitautograd_dispatch.h,sha256=xFU9dYhNLYPJpMfKn_q4cGbvRc5Vk1fyTysp6NINZQI,1146 +torch/include/ATen/ops/channel_shuffle_cpu_dispatch.h,sha256=QK4ePyg72Ho8o65p_egeK-ujnrdXE6obVJruRUgfAAQ,835 +torch/include/ATen/ops/channel_shuffle_cuda_dispatch.h,sha256=UgzPWdfgg7OGtmaGlgejv9Nl7gNTBh20AvJeY_ZuJS0,837 +torch/include/ATen/ops/channel_shuffle_native.h,sha256=LBp3yC5I2TpXhCmt00Sglul3nvN482KBTYvy6kdGp_w,719 +torch/include/ATen/ops/channel_shuffle_ops.h,sha256=rDZpX0e1ZUfoP4sGac703LAyVs0c_zgr382GH_qNhmA,1780 +torch/include/ATen/ops/cholesky.h,sha256=fubKEihGyoIoVczIUsXnL3Ps0zNFXURH9Po33PSt244,1158 +torch/include/ATen/ops/cholesky_cpu_dispatch.h,sha256=D58RdBAXHqkk2keK-Dxh3TnwKkOsAE8AJvhg4Fbs6WU,931 +torch/include/ATen/ops/cholesky_cuda_dispatch.h,sha256=tgs2VPSBRRpUsnTj-vm-RmrCWgh1ckRu-K5WDSMzHIE,933 +torch/include/ATen/ops/cholesky_inverse.h,sha256=_6erhe50xzrUWCsLuCmtxEyiWbpPofPU390gmkuoNpI,1238 +torch/include/ATen/ops/cholesky_inverse_cpu_dispatch.h,sha256=DRZm5bNPDnMmwGXtdtRc7Hu7Sk3G9whru8UVL-GUN3U,955 +torch/include/ATen/ops/cholesky_inverse_cuda_dispatch.h,sha256=yuJ_hQntkLoX8PGe4sMY7IVf_vhR5lu-YnAh5KRZCYc,957 +torch/include/ATen/ops/cholesky_inverse_native.h,sha256=96rTnzp7WQtUt0oaZV_AD7unT3Ode6QjNHaJLfTv1i0,615 +torch/include/ATen/ops/cholesky_inverse_ops.h,sha256=lag6qy1nLq6TIwAEYdpxyoyL3VvurLM2-Os9N4goUp4,1746 +torch/include/ATen/ops/cholesky_native.h,sha256=oMIU38xLlOqUt7whxBSyyWAiU67lB-V65RGnIeulPBA,599 +torch/include/ATen/ops/cholesky_ops.h,sha256=opgK2hCt2HAVPeEgGnPdhFgpz4JDkQiC8usdwZVapOc,1698 +torch/include/ATen/ops/cholesky_solve.h,sha256=zt8rIFTIwyQW-2LkQq7CgyNV7_3-98VL1R6UORMJUvc,1368 +torch/include/ATen/ops/cholesky_solve_compositeexplicitautograd_dispatch.h,sha256=7LP8DVCZhUR-9GC-shuwTxYYkZlm42sa5qXbAxHK1V0,1074 +torch/include/ATen/ops/cholesky_solve_native.h,sha256=oXc4gW7ulSUgnX94kYsGoseQrRxEo5lmm59F_-pOxqo,665 +torch/include/ATen/ops/cholesky_solve_ops.h,sha256=YyaVFFLYcMr5QjW7_me7ZvuDHDHZ_jsWUVfl82ao_00,1912 +torch/include/ATen/ops/choose_qparams_optimized.h,sha256=7vNXB6Nij2JCBi5Pnki-hs0rrKEf2QHGifIlxwwfJ08,883 +torch/include/ATen/ops/choose_qparams_optimized_compositeimplicitautograd_dispatch.h,sha256=RE1in_qBLmU9q-dyCaPFiEziALzkifJw1kLDiYL3t2c,872 +torch/include/ATen/ops/choose_qparams_optimized_native.h,sha256=_789iok4WpKgLUAxcl-Dtyh12NTGzX4dXRi9B2hUJyA,595 +torch/include/ATen/ops/choose_qparams_optimized_ops.h,sha256=7PU9tBu6mXzWLinsmsmfuYETXClz4xBkkJVzZPAggzA,1323 +torch/include/ATen/ops/chunk.h,sha256=o-4impzEtgQJxKIcC41St_mGy4TCJA2TNkCn8TdA6G4,716 +torch/include/ATen/ops/chunk_compositeimplicitautograd_dispatch.h,sha256=Z9whs8-l3niDCyIflFS2476ld4SW4YEQK-EeS8fkay0,809 +torch/include/ATen/ops/chunk_native.h,sha256=Y2jyIWNv-4nFeF8hjxDiMMyoez3QNBOns2fvPQ3NFXU,645 +torch/include/ATen/ops/chunk_ops.h,sha256=-zUEHdV-jnUmwRKMjN75kirjxbVZT9ZXqu4EZ8pRVAY,1121 +torch/include/ATen/ops/clamp.h,sha256=fpg43QWF8ii8BdywaCYyJRkyTwLnW-Lmuh3BD-907rg,2904 +torch/include/ATen/ops/clamp_compositeexplicitautogradnonfunctional_dispatch.h,sha256=RoOVevnR27t2Px2ctZxT54hvW72V0UZi-mf1Lr4-Syw,1292 +torch/include/ATen/ops/clamp_cpu_dispatch.h,sha256=M-QSs2SxRFhYwGVMJXFS2KTWggUyKILLS3s_sC2_pJ4,1863 +torch/include/ATen/ops/clamp_cuda_dispatch.h,sha256=-kJdwG2zOc9IUOCAcfyDvHaAl9qQAsq2VnLtSJOUD-A,1865 +torch/include/ATen/ops/clamp_max.h,sha256=c25L3Z4GlsH_COxI4TMqBIFzpO2J4GjFjz6ksrq-BiY,2283 +torch/include/ATen/ops/clamp_max_compositeexplicitautogradnonfunctional_dispatch.h,sha256=W91EUPZhWIMWT_xkkeQz25f3Ye4BQ9YLX_7O7uxRWdE,1054 +torch/include/ATen/ops/clamp_max_cpu_dispatch.h,sha256=LDogH0WJh2EAWV4_ijIKirYlA6i87B_kdayAq3r46U0,1406 +torch/include/ATen/ops/clamp_max_cuda_dispatch.h,sha256=kXt-RgfBhjjof4v2D0k5iUYVwz-o3qyAKwPSbMeMR6o,1408 +torch/include/ATen/ops/clamp_max_meta.h,sha256=Ow1GmT0gXXZ-WSqtoY2q_mvt4QzUmzc8hx3vAfyR-RA,765 +torch/include/ATen/ops/clamp_max_meta_dispatch.h,sha256=w4HHJ5S7uHbWPiIbjWK1BNXcbCzTc1IM7MgnEx3anQY,1408 +torch/include/ATen/ops/clamp_max_native.h,sha256=eIkt_fe8dT9tBxXFUqf5BEm6HZiRbZKrxX6tcbXXoyg,825 +torch/include/ATen/ops/clamp_max_ops.h,sha256=-cc3F-ePLnza9KgJZNKK16yhpOuD4sK7sFu8HsXmLiE,4405 +torch/include/ATen/ops/clamp_meta.h,sha256=TUlbseYVkboL2QNy62_3Tv9QxR1QjuOfyoLQ2lfsHVA,817 +torch/include/ATen/ops/clamp_meta_dispatch.h,sha256=mWPAcATDIgaeyTi3JN21Qbc7BKaX2ajbpo4L0J8CjSg,1865 +torch/include/ATen/ops/clamp_min.h,sha256=n9BbMwJrua4RRy6Un-UEIjO2_kw9TcgwkLBTyzaJ6qU,2283 +torch/include/ATen/ops/clamp_min_compositeexplicitautogradnonfunctional_dispatch.h,sha256=VcAAaMT34NKMJrYZba60ovpPs6FqlyP2C9-notPuqXE,1054 +torch/include/ATen/ops/clamp_min_cpu_dispatch.h,sha256=pWeh2HkMexdrYj8juQmQlpidc-J2dkkaehdcNc7jZVE,1406 +torch/include/ATen/ops/clamp_min_cuda_dispatch.h,sha256=2GQ470IpvGVcnQBastPbzBNsxa-wRs8nMdIbUK4tpF8,1408 +torch/include/ATen/ops/clamp_min_meta.h,sha256=I7sZCDZNcCOVI-XPXCHK1mV4Kw_o8AF1ge94vvoBO1s,765 +torch/include/ATen/ops/clamp_min_meta_dispatch.h,sha256=rjEqR4kNym9Nt7gI8nKdXNPbZRRdPhpHFL1gJJmj048,1408 +torch/include/ATen/ops/clamp_min_native.h,sha256=NsMPM43wjWmapG6WdXIIIWeUByo8QgNePj3ReKj6umE,825 +torch/include/ATen/ops/clamp_min_ops.h,sha256=Xyq3iXsYp1IfPLvWKTr_vezfHQQsYdQtpzrUJVgprhE,4405 +torch/include/ATen/ops/clamp_native.h,sha256=2nizzIMojQH2VYj-grWUboLfaONbLfEsPlYPkbArT_g,1036 +torch/include/ATen/ops/clamp_ops.h,sha256=EhoQR0jjxP3cuL2bpGT7MuagUg_iWjZnQD0S8Mfj-Tk,5425 +torch/include/ATen/ops/clip.h,sha256=FiGsY_fzcId-D1e_Cd3V5flfDSzJgOmHE_5ayvubPNo,2879 +torch/include/ATen/ops/clip_compositeimplicitautograd_dispatch.h,sha256=nyGBffmrABwG4rTxvRAI9AqHhj_eeDPS-hq4F7X1bU0,1899 +torch/include/ATen/ops/clip_native.h,sha256=zrpEq7r5bQm3YBLtkxcbfIDwYDBTYP8IL5sElWGrbY4,1319 +torch/include/ATen/ops/clip_ops.h,sha256=SbS9C5tgMdBBI3JKzWcp8rJpoMi6J9Z6AJrMnwdegJU,5407 +torch/include/ATen/ops/clone.h,sha256=eON04UiITPZHWkntRiYZDBpsJvrnQ88ng6pxgMcsXpA,1322 +torch/include/ATen/ops/clone_compositeexplicitautograd_dispatch.h,sha256=x-W9EWrMIuxTY5xrl4YEXbZ7fWBr3d2zElhVdc4Mu7s,1085 +torch/include/ATen/ops/clone_native.h,sha256=ObYwMwtf1f_iL5Jb-vqbQMlQTZ1jA0RLiDKADLzTn2M,1284 +torch/include/ATen/ops/clone_ops.h,sha256=Brg7izWGZI3BrRNsDtJTAYg8x-fX8DsyhpgUFqFbMFc,1909 +torch/include/ATen/ops/coalesce.h,sha256=rmUKD0Hzfnk_oeyI6W-hnSGb5byS7qmZbSLrgxrwmYg,493 +torch/include/ATen/ops/coalesce_compositeimplicitautograd_dispatch.h,sha256=nFzB-bQ0N0MOJHUFrhpowltb0DP2uxWppm6if3mWlck,766 +torch/include/ATen/ops/coalesce_native.h,sha256=gYgKk2GEC0h0le-CJOK7OTUh1hOc3bx6ik8ylSd4YqU,489 +torch/include/ATen/ops/coalesce_ops.h,sha256=KmwTa2FF-PbDFY3MNLGUQ-FqKzHiEsITfSUQScQd59Y,979 +torch/include/ATen/ops/col2im.h,sha256=naww8VjZeBwcPBZJrw3QSp4ER9UWwJbXnjS_xQk-HjQ,5861 +torch/include/ATen/ops/col2im_cpu_dispatch.h,sha256=0p1Ni6Xvk1tICZ9Lfl_dX-BDlnbvlZBhu9wCIJ3JQSA,1919 +torch/include/ATen/ops/col2im_cuda_dispatch.h,sha256=cjoEDOZBzvgv4GDYNhFPR6RMuI-YnA7eAnRfJz93V7g,1921 +torch/include/ATen/ops/col2im_native.h,sha256=r-nW_Ia3iFIltYUSsPaY7R7-ARS0dJwP0kfs2BLGHoI,1247 +torch/include/ATen/ops/col2im_ops.h,sha256=MGUGJTvKYzo3RgnjykO5TOY_op0fsDui5pHqkrJZVPc,2498 +torch/include/ATen/ops/col_indices.h,sha256=Q4eoCQVEKpnrlbqiQZ1yPAZu7MnNQgEqoAwkXd2T060,496 +torch/include/ATen/ops/col_indices_compositeexplicitautograd_dispatch.h,sha256=GcY7_tnCy0qrhoDP335cbHGm240I6UcwcrCd1n5-5KY,769 +torch/include/ATen/ops/col_indices_copy.h,sha256=YGPf4yQvJa0dSJM4yUzo-eJ4jR_Ygqacm4hryqrQcyM,1115 +torch/include/ATen/ops/col_indices_copy_compositeexplicitautograd_dispatch.h,sha256=U65MR5erMxTs_pIluZKSFHpvZ6hHgcalC-vI-xYgng4,887 +torch/include/ATen/ops/col_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Xf1aREZaOYqUgVxd2-Qn1IjPYv8L18LmGzKFlh9HHGA,800 +torch/include/ATen/ops/col_indices_copy_native.h,sha256=Fa4-6NL_HH2EyrxjM7uT4KG7jQ9RjGQqxYAZah8tqIg,585 +torch/include/ATen/ops/col_indices_copy_ops.h,sha256=7JmMq4iMovPyKKrbcgIef2lFbpycg7fcO7lkkpvY66c,1650 +torch/include/ATen/ops/col_indices_native.h,sha256=xLFS2nZqwmr4R7TObfWfSolaxegp4FRz3U_DdyjDKpQ,570 +torch/include/ATen/ops/col_indices_ops.h,sha256=pM9TZIz9_V5gGXDwTp_3AztwISpmNECJDCOpIvf2huo,988 +torch/include/ATen/ops/column_stack.h,sha256=Ug2ikY87OSfewXxYx-gjHIrjKyJiEeHyjioyDDDUkDQ,1096 +torch/include/ATen/ops/column_stack_compositeimplicitautograd_dispatch.h,sha256=JXWKV1zOf0K0vJJILsp3bdowyzsxkdk1PIAlTL3OIDg,936 +torch/include/ATen/ops/column_stack_native.h,sha256=aIUmsUhSHnGmxtyg1vCfTgqLHGTh9jhXEe1Jq5hHywU,575 +torch/include/ATen/ops/column_stack_ops.h,sha256=kAJY-cQHtEzNluwP0MOlzmKm7gArdC6HUJJgUn2SRfU,1624 +torch/include/ATen/ops/combinations.h,sha256=NWScgM2SxlGfChTxm0Za6xCVC4D1_z8Z0Gys7u3neAo,750 +torch/include/ATen/ops/combinations_compositeimplicitautograd_dispatch.h,sha256=HINIJGIdGdJCnEIXLIEMdqOz8Pb_sUL09bhrFsb2bRs,812 +torch/include/ATen/ops/combinations_native.h,sha256=yvhvDZ8A5gmnLJsUIDnT6zXICjNSH2l6Kta3unyR_vM,535 +torch/include/ATen/ops/combinations_ops.h,sha256=Ou4OncrZaNXCWCyQ-t1SaiWWCDk_boERF3wFyDJc-6o,1106 +torch/include/ATen/ops/complex.h,sha256=J7c_P-xGmmBMHkhbfct66sllaFMJm3DNeF5uaer1KZ4,1157 +torch/include/ATen/ops/complex_compositeexplicitautograd_dispatch.h,sha256=FjsHHUPn2jQRIC77XSuQZZzklU-WCHpEexVYM9HJTq4,790 +torch/include/ATen/ops/complex_cpu_dispatch.h,sha256=-nU9jv1fw1XsrEK7JVNMMsor3ntzNGYO23zDDHgDE6Y,875 +torch/include/ATen/ops/complex_cuda_dispatch.h,sha256=BEbeYfSJrsq0qQcRdwz-Os_fCU_pumWVfLI-QDpL_Wk,877 +torch/include/ATen/ops/complex_native.h,sha256=kXCL1jZYfEjcfUzO9397u_jJJmi-PR6ZCwyqi4xgS2k,617 +torch/include/ATen/ops/complex_ops.h,sha256=j0j87eF3wJAjHTx_IZ23Y1MP54ep2LgsVH5vUk0hw_M,1762 +torch/include/ATen/ops/concat.h,sha256=1ble04qzcL-7i0NKpAUL69a9JNFNSMsJiSHg4jUObZQ,1814 +torch/include/ATen/ops/concat_compositeimplicitautograd_dispatch.h,sha256=XSGUZa5yG4c8FnA7utPF5aMBFpNPzrF-P7nhoxxeuFc,1220 +torch/include/ATen/ops/concat_native.h,sha256=-ikaio4EV5c-x1duOhas56qRAwY__aSuHHEXMgVXfCs,755 +torch/include/ATen/ops/concat_ops.h,sha256=XIapH3VbCTpWyyQHO0U0LaNVWze9R4BfcQOtiPsLmA4,2989 +torch/include/ATen/ops/concatenate.h,sha256=NykVcQeJGb9ddGrWBeL1BB1ZAW5tPismlxpYgqrhn2s,1909 +torch/include/ATen/ops/concatenate_compositeimplicitautograd_dispatch.h,sha256=T6BBiY0g95HyKHsqrTldtdhEI99tUt2y6Zhwh6Km7-o,1250 +torch/include/ATen/ops/concatenate_native.h,sha256=R-kYRvjMAUIsZZi8FKIMia8IUkA_7gGoRRaXXlG7KfI,775 +torch/include/ATen/ops/concatenate_ops.h,sha256=--8eAcukqtnJ8lJRZQUacnmRllTsMYiGjEfbX1psUbk,3049 +torch/include/ATen/ops/conj.h,sha256=Yrr4wM8OXxYbJx2O7ZxTwmTo088c1z_so8sA5Dld57c,634 +torch/include/ATen/ops/conj_compositeimplicitautograd_dispatch.h,sha256=gG4OYaWXqTf9ozYuc1YoSj3ATrwz3RKKf9yw6asFJoA,762 +torch/include/ATen/ops/conj_native.h,sha256=ccV3L79a5_371E4JJ3snb51Kje7zBqp9JbCffoqb9YQ,485 +torch/include/ATen/ops/conj_ops.h,sha256=6nSy_L-Sru9NrhANH_IMgM5NOkC6CDh0qh78WGtMmFU,967 +torch/include/ATen/ops/conj_physical.h,sha256=gSuryA8uTRUlyq3Eom4Zk84f797FbAXEQYoSlksjaeE,1248 +torch/include/ATen/ops/conj_physical_compositeexplicitautograd_dispatch.h,sha256=on5qUc9_taEPD9Krkd4JsZdCoXvZUMQjsyUQvJO2J_o,768 +torch/include/ATen/ops/conj_physical_compositeimplicitautograd_dispatch.h,sha256=VmeGaNahiSzBJT4RTXMB8BDqQLvOZcjWe_xRimIPP2I,771 +torch/include/ATen/ops/conj_physical_cpu_dispatch.h,sha256=7iNhZm--iZqCsPzG4GWqc9BOPh7maSzZ9hxNtCkJxPQ,837 +torch/include/ATen/ops/conj_physical_cuda_dispatch.h,sha256=GjNPY76piL4f1icyPg4h3C95b9pnFthC2EyXFooNxZI,839 +torch/include/ATen/ops/conj_physical_native.h,sha256=_xoj0umfvOG8PfAD3csYeAmjCbH_m49cj07AcjFpEn8,894 +torch/include/ATen/ops/conj_physical_ops.h,sha256=WtTpCmlW3A5vN42JNmIIpilyBOIlcuEEUJycskWgpCc,2185 +torch/include/ATen/ops/constant_pad_nd.h,sha256=KbAcEQDMiKu1mhoQFDi4wJGiiV9yDQ07KbShKKv8vVE,4266 +torch/include/ATen/ops/constant_pad_nd_compositeexplicitautograd_dispatch.h,sha256=ATkctSPAvOi9sYa5tHfr3rsOl7CMokuNOQvLfF3HsKE,1509 +torch/include/ATen/ops/constant_pad_nd_native.h,sha256=NvSlsKrNttQlLeEbri2nkALLePyvofQOXQh-mslr7es,690 +torch/include/ATen/ops/constant_pad_nd_ops.h,sha256=9bVRY9N3p_R5nh4deSiDVIfIygGIJ6ZohcFLgb7nbOc,1990 +torch/include/ATen/ops/contiguous.h,sha256=Ebaxi1AV2oouz9br36sKlH6bn81Kajve-mLTWyJErDs,495 +torch/include/ATen/ops/contiguous_compositeimplicitautograd_dispatch.h,sha256=oL4NPlaZqvXX13dtjOU5l3VddJ5WjnAkua_r-YYjodg,825 +torch/include/ATen/ops/contiguous_native.h,sha256=phoJmN4A4-gxMTT786BMd7Br8ytBLaUXIbahkvODsZg,548 +torch/include/ATen/ops/contiguous_ops.h,sha256=v77OBaWMddf3c_raOwYYFb3nVa4EC-FBeNADmk24wqU,1116 +torch/include/ATen/ops/conv1d.h,sha256=2u_joBCNbLVuPpBG1CUhmOhYQ0WkGpAVsTgfr7uzit0,4512 +torch/include/ATen/ops/conv1d_compositeimplicitautograd_dispatch.h,sha256=uo_-SOSkjSlyovEwXMFcxkuhYmK4yCt_3yn8V43ktOE,1688 +torch/include/ATen/ops/conv1d_native.h,sha256=UBc5gI0perapMRxlpcAO_6FgKTAk4pWFRsuAs8iR6jU,1003 +torch/include/ATen/ops/conv1d_ops.h,sha256=ue-6E3r_xTsMiC2DpEmBgvyJpKw5gdU9OqKboZ7qwm0,2708 +torch/include/ATen/ops/conv2d.h,sha256=LFUS1AZjZE39eEoQlshz5pUPAMJ5MA1qbIAb7rqA5NU,4512 +torch/include/ATen/ops/conv2d_compositeimplicitautograd_dispatch.h,sha256=IseZ6TmNapUT2Y6KaVoFmQx8EYxja8vhG-amSCgoFyk,1688 +torch/include/ATen/ops/conv2d_native.h,sha256=t0DBzDxJMvKT_TynVAZ3ybXHKDNitBx4j4J4tqTzBmo,1003 +torch/include/ATen/ops/conv2d_ops.h,sha256=9LOwHOU5hILF1cwzLphkIsF0CD130TDydNG6f1wo74g,2708 +torch/include/ATen/ops/conv3d.h,sha256=5HVSsZuI6nkQbTb8d7jXsBXwV5zNhlWhP3bzMP8wfRU,4512 +torch/include/ATen/ops/conv3d_compositeimplicitautograd_dispatch.h,sha256=McCHFNs2Q5IW5RMNHjq_wVImhOEeVq13A9JVrmg6f98,1688 +torch/include/ATen/ops/conv3d_native.h,sha256=M0jNXcw8V3kOg50wCeqG4XM1pAEijchmaxuwzTZy1RE,1003 +torch/include/ATen/ops/conv3d_ops.h,sha256=2RpP5Wm76kLfsZ3XsA57xXqICQo7U2hajQK1wvCjCw8,2708 +torch/include/ATen/ops/conv_depthwise3d.h,sha256=qCIKmH_yfDSplPaPrha0mBNgirtJW1woxE1B8B5mzxo,7287 +torch/include/ATen/ops/conv_depthwise3d_compositeexplicitautograd_dispatch.h,sha256=AwmvXmaSmHDNIBdgVCGND7otPyPErzJVeNHC0tKoFe4,1794 +torch/include/ATen/ops/conv_depthwise3d_cuda_dispatch.h,sha256=OVPvo6eQx6OJixcytFObD-qJo0KfDJowv33_ymCx-BM,1161 +torch/include/ATen/ops/conv_depthwise3d_native.h,sha256=aPs8S2rnzxO2pKPETXcqNB06IgZ9D8Y4ZVeVJFBNNEA,955 +torch/include/ATen/ops/conv_depthwise3d_ops.h,sha256=ShkUVCydbjAqe9bP7B08FMZL4mN7-aN9GisiMlgagqk,2894 +torch/include/ATen/ops/conv_tbc.h,sha256=XH8pn-sN3aIVhrJaaw5QcUdL91Zjjz4VvjUzpNJ1Prs,1408 +torch/include/ATen/ops/conv_tbc_backward.h,sha256=cD1Qi9gE6JiZ8vF1ekkunJDCYT8BXn1aRvTCbY6wvls,891 +torch/include/ATen/ops/conv_tbc_backward_compositeimplicitautograd_dispatch.h,sha256=6GxVEHNMyW6tottxNnWkUrZxE53IhThRBjiQLDvzbzw,902 +torch/include/ATen/ops/conv_tbc_backward_native.h,sha256=mDAH-TNpRqXEx8KePuViWFPEB_eZkpemKFzLvfN5t-Q,625 +torch/include/ATen/ops/conv_tbc_backward_ops.h,sha256=JL1k2YE_y183lmlttbhSHMxedpGdo0dRyDy4qfkl3O4,1428 +torch/include/ATen/ops/conv_tbc_compositeexplicitautograd_dispatch.h,sha256=hprKU4WmQ-Xao_LP1nzdSbQ31KxB2cBTP4mZeT9DTz0,1126 +torch/include/ATen/ops/conv_tbc_native.h,sha256=lx_eTHVYbgqrZWadlChFPB5xbQdRDnrg8EKP1yefhnQ,701 +torch/include/ATen/ops/conv_tbc_ops.h,sha256=wezqCTeMACjDX_li8DUzM29swjUWnHQ8d7A6XkkehRw,2038 +torch/include/ATen/ops/conv_transpose1d.h,sha256=QeQkZraGvTc5g4tv1QPsHVFMk7vN7yO2sbToaf6GNp4,2997 +torch/include/ATen/ops/conv_transpose1d_compositeimplicitautograd_dispatch.h,sha256=2Y41khW1U0M8PFt3IHXwlflkWDDi1_At41v-GtSyu3g,1325 +torch/include/ATen/ops/conv_transpose1d_native.h,sha256=Zy6uQtTTBSn09XFqCcNBVcFB3xHUMMacZ9iOfcNMMp8,780 +torch/include/ATen/ops/conv_transpose1d_ops.h,sha256=A9oQtWHGnJAt1rOkJnVyaAR4OsyW80JiR6XOZG_m8Lo,1714 +torch/include/ATen/ops/conv_transpose2d.h,sha256=2uWbeXSC95gUsYBnq8yWUBgrO1mNsT9_iy3RCjZiq5g,3033 +torch/include/ATen/ops/conv_transpose2d_compositeimplicitautograd_dispatch.h,sha256=AHb6IxvbzwObA2MMNshgABNqyMzz5BqmCAuei7uZPgs,1325 +torch/include/ATen/ops/conv_transpose2d_native.h,sha256=CZ1ngu7oZ7FtdobdU4zRp2chGgdqZy3rSxXCwJe6-lc,780 +torch/include/ATen/ops/conv_transpose2d_ops.h,sha256=Y0UchChY4ymH4CgnNhnKuBPwR_1wYqc516Pq1mq8R0g,1731 +torch/include/ATen/ops/conv_transpose3d.h,sha256=AZ7kgW58Rx9Nb3YjFRkzajXKaKtbhEhWHLcx8OEmD8g,3033 +torch/include/ATen/ops/conv_transpose3d_compositeimplicitautograd_dispatch.h,sha256=xVzoO0xx8yN-OmYfTlnaMi389wng3U6wzu-DN9gXntA,1325 +torch/include/ATen/ops/conv_transpose3d_native.h,sha256=d4dY7w0-LWDlxgNfBnuKLvomY0An7dv8esHJwDIUghs,780 +torch/include/ATen/ops/conv_transpose3d_ops.h,sha256=h7ejH_O3zKW5_cg9frHvXpLJXH85w6uLFSEFZNPYbMo,1731 +torch/include/ATen/ops/convolution.h,sha256=5fLQQhYkr4MtfzzJTFfPBy13dwAqPbebJdXMmdi2eYM,8080 +torch/include/ATen/ops/convolution_backward.h,sha256=FqJA3xWgWcziQAVbtkGyFxUHqi1XMkrEoxbaFAq3x5Q,11481 +torch/include/ATen/ops/convolution_backward_compositeexplicitautograd_dispatch.h,sha256=-0UXHz1KzXh-H7Pe8e1f0vGLIKTqoqwQa-JcCu_xCVM,3314 +torch/include/ATen/ops/convolution_backward_cuda_dispatch.h,sha256=aLZEMnvCvqGljYhKD5L2LJGjzm4sCcISEKCoiOhz_1Y,1446 +torch/include/ATen/ops/convolution_backward_native.h,sha256=T7MAG_5pX6Ylwfn3KORtm2eqZwbrp83xkAjT_3ts7To,1278 +torch/include/ATen/ops/convolution_backward_ops.h,sha256=oYjQRexK2qvLA_1gOH1JOkxurpOIS4K-H_wva2RuFJY,4025 +torch/include/ATen/ops/convolution_backward_overrideable.h,sha256=JJx517KQA2NVlOZ6Dc3CyPQ3GDl3zFsdbe4z1JgxasQ,10702 +torch/include/ATen/ops/convolution_backward_overrideable_compositeexplicitautograd_dispatch.h,sha256=GWt8g0mT9y6Tq9Gusu0jhNFOAZ6WinapWWHLnYctkNg,3167 +torch/include/ATen/ops/convolution_backward_overrideable_native.h,sha256=WNQ6Yx5X3_QYxUb1krRy6eK6kwKsW-qUzBpZyuUZqm0,1229 +torch/include/ATen/ops/convolution_backward_overrideable_ops.h,sha256=ikYeQaFezwrsDwQB8NyllHzzhyy98cj4YVS1Tn-wCDk,3880 +torch/include/ATen/ops/convolution_compositeexplicitautograd_dispatch.h,sha256=TEcGN7hn56pzSgJiOLNP_E1-F1CwUqrJFsS88tDAkUQ,2491 +torch/include/ATen/ops/convolution_native.h,sha256=KpCRd3-0yHTpayMZ6fdt5MDneKHnd2wXderZBiAZHw8,1018 +torch/include/ATen/ops/convolution_ops.h,sha256=AyUdn0_Isa62CbCHqwCY7hGStueQtzEAQHpxf1ilRQY,3130 +torch/include/ATen/ops/convolution_overrideable.h,sha256=xIgRNNMg5SRfejjMAnCud6OTp1ZRCtsQOxyi1Ocx3qc,8483 +torch/include/ATen/ops/convolution_overrideable_compositeexplicitautograd_dispatch.h,sha256=CpkyBeec5nBwJ4i-GOXrJCDRMw3IP9tHjg7Bl52svwk,2569 +torch/include/ATen/ops/convolution_overrideable_native.h,sha256=UPa7oK8LzN4y4yoCDGZ8Q0Txck1M6DhRb1SaQfFJjDE,1044 +torch/include/ATen/ops/convolution_overrideable_ops.h,sha256=LqtgLK3o4JSErGHoyBMzPlMYKMkc_i5P_e-PKQjct_c,3208 +torch/include/ATen/ops/copy.h,sha256=9Y460pVP3fYuz9uEhh4LzWTkBGk6ghTMZO1wSvA1IW0,1304 +torch/include/ATen/ops/copy_compositeexplicitautograd_dispatch.h,sha256=VDFyaba0I6QR8Yg9StZHBY4CgstzvxVeyQPfsxTCdUE,1053 +torch/include/ATen/ops/copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=pRa4Ov8t7RUzBl7h3WOwkTPHPjcesg51lwjazDCtCAQ,837 +torch/include/ATen/ops/copy_native.h,sha256=eP9E5RwmvTbL3bKfsX0OCB5y5b7JEp8WKlCLvRDMtWc,1190 +torch/include/ATen/ops/copy_ops.h,sha256=imBnwomr5Br576Vh5eyrS2GK9W0YLA73f8MsoDgLtLY,2551 +torch/include/ATen/ops/copy_sparse_to_sparse.h,sha256=FvSaxqLHFSFgwjd7XN4QGsPfpagx20y4QL5WqKLnZ1A,1766 +torch/include/ATen/ops/copy_sparse_to_sparse_compositeexplicitautograd_dispatch.h,sha256=IEEjBlmvKAh1ItZgSsA0H0UPNjEQXT_VZAj6-YkPWPM,1107 +torch/include/ATen/ops/copy_sparse_to_sparse_meta_dispatch.h,sha256=vhi9mRGJHF2CPBPW9LjmsDnH08quPjkZa-8pPp5oxNk,783 +torch/include/ATen/ops/copy_sparse_to_sparse_native.h,sha256=A7UuhoYSo5nRqlwNFyUm7sygctG0l6pvCKYOK4r5ct0,792 +torch/include/ATen/ops/copy_sparse_to_sparse_ops.h,sha256=JiUMVpriD2t5THYB4Y9KkEBo2AKT_kTy_4BdAdOQxtk,2704 +torch/include/ATen/ops/copysign.h,sha256=V7T8Hjo5E2W6g3IUKgc3-qMbNdkjD86WRZt-khqALjI,1916 +torch/include/ATen/ops/copysign_compositeexplicitautograd_dispatch.h,sha256=Y1mTBzgiIs3DB2TkEd3whbVatSUTnomrFtMPxAz3SR4,1084 +torch/include/ATen/ops/copysign_compositeexplicitautogradnonfunctional_dispatch.h,sha256=sO_Fu4Yucd8CXmcJJ-wm-t8WZwdjEG57WOYQ4FCITYo,897 +torch/include/ATen/ops/copysign_cpu_dispatch.h,sha256=h9zyuXG5gbYPpYL8XcLK-CrNXwcU0V0R_SOi1RIyl0c,1040 +torch/include/ATen/ops/copysign_cuda_dispatch.h,sha256=JdAHfnBrhDrHvXiwfJdx39rBw9qdTl3owMh6E7S5Lis,1042 +torch/include/ATen/ops/copysign_meta.h,sha256=gFvSpx81Nkvn2TIiCdGhsIfIjGGmRQIWnxVDmV-PsqU,621 +torch/include/ATen/ops/copysign_meta_dispatch.h,sha256=nVtC1rX3wIQtjbiUUQfJqnK5w03tHevfth62SoItA34,1042 +torch/include/ATen/ops/copysign_native.h,sha256=ZblMCtZpT4i7rYSO4Wp8cy9iEn2IPdplVeaGlnHNMQ0,913 +torch/include/ATen/ops/copysign_ops.h,sha256=Tg8r8fC8cGxFNI7lOSOZ2bV2ZF5NSodfZZZl6CKTHS0,4463 +torch/include/ATen/ops/corrcoef.h,sha256=GDBasS1FlJ6aPhH5_9L-iRi7eMVB5eN3TCgq5uJOvXQ,633 +torch/include/ATen/ops/corrcoef_compositeimplicitautograd_dispatch.h,sha256=Qgr8zzSJSOy98Wk5pDDY4duS-gwWzpWCRiyuGLgoISc,766 +torch/include/ATen/ops/corrcoef_native.h,sha256=lNqqSSZ34u5SYG8-_Qby1_Yj3MBlqvpGYvcsrHryEpM,489 +torch/include/ATen/ops/corrcoef_ops.h,sha256=3svqaxwTkyRZfKzUmndCwBSwwGkcsC9n-_GUuujMn_8,973 +torch/include/ATen/ops/cos.h,sha256=swTtg8boheoyxfQiEVPyGiL9yZh9calbm5kdaSSlJJY,1118 +torch/include/ATen/ops/cos_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XKVvuZOuv_bPHRX7C4cwM-cfWPODj0pSOvZ1ZGFxhJE,835 +torch/include/ATen/ops/cos_cpu_dispatch.h,sha256=gw277qd8XP-Y724zsxGLvWZHBCHldZxJXMs7ukg16MQ,916 +torch/include/ATen/ops/cos_cuda_dispatch.h,sha256=bqDfjG5_6nHr06NGx5DEwadJSmaiB-qJzokbef0p9Yo,918 +torch/include/ATen/ops/cos_meta.h,sha256=PPWqlwleiz_3VkN-bCTFI1BvLv-AB7QTAeF-fXLDko4,583 +torch/include/ATen/ops/cos_meta_dispatch.h,sha256=tSRNtVElJrkcfn1ByDc_ochQ6ZAk7DrI-3ZrEloalgQ,918 +torch/include/ATen/ops/cos_native.h,sha256=YUbSFd91EaOFtFfGHxaqq7l8G_taazf6crfoxjFWPtw,656 +torch/include/ATen/ops/cos_ops.h,sha256=1KspHRzN6LgwSy2kNtehQ4btQMjLMZpR7EciXa6POxQ,2095 +torch/include/ATen/ops/cosh.h,sha256=gLjEMFOtkGB_Zd_F0bqDRNaipL3JhRQaSpCmLUgeWaI,1131 +torch/include/ATen/ops/cosh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=2Uur5cBIzb7T_-M4SQ1xA2Us7H7rhSDakvpYrF1eHSY,837 +torch/include/ATen/ops/cosh_cpu_dispatch.h,sha256=I5W4NGGCfpx2W1Lf3jjJn_Hq8tCI0OCD0hzhbvC5ku8,920 +torch/include/ATen/ops/cosh_cuda_dispatch.h,sha256=-nja_h6zd3bKq8ed_lFUz5aAqNhPBtkz5HYO39zYNqs,922 +torch/include/ATen/ops/cosh_meta.h,sha256=hqQNhhhZj2xPbGGTT6zaaHQISGJ0A4EBgu5QkmywaYE,584 +torch/include/ATen/ops/cosh_meta_dispatch.h,sha256=yQDVX0UfehAZOYAEBrIJgDgC-5HjlM96eSEkK8dgbdw,922 +torch/include/ATen/ops/cosh_native.h,sha256=7TeexHzGO5RH7KuhVooiMB3h2LzJ3turt5rg5qexkas,601 +torch/include/ATen/ops/cosh_ops.h,sha256=PAwhLupMbpiseVgzR-2YBW0pepMXIGNhxZvN-kfQmws,2104 +torch/include/ATen/ops/cosine_embedding_loss.h,sha256=GSFFIkw954i9D4DmyC9xkS3t7svSX6h9w8zTL0BbERo,906 +torch/include/ATen/ops/cosine_embedding_loss_compositeimplicitautograd_dispatch.h,sha256=WHFcFub8Z_kx9KhnXYL3N8SQtZxtyd3ixksFaRlO6u8,893 +torch/include/ATen/ops/cosine_embedding_loss_native.h,sha256=fLOvgDbDeTC5w8gJPR0sIuGTEA40D0KofWtYm7teUOA,616 +torch/include/ATen/ops/cosine_embedding_loss_ops.h,sha256=fzR_H035Svh6Fcbo8vBMKEM9My9eEnEm4jQBzzgbjPY,1319 +torch/include/ATen/ops/cosine_similarity.h,sha256=zQYcKeTMk3kjZSjuhW0xnan17heypWPcDdC6jhcRhF8,772 +torch/include/ATen/ops/cosine_similarity_compositeimplicitautograd_dispatch.h,sha256=g6y8I6nkWoEnPKivCrGWtqMLMQxIBsQtfXSHOu26imk,829 +torch/include/ATen/ops/cosine_similarity_native.h,sha256=ONwGubUJBOhKWdlh0im9sq7j_6h_a6wAI05I4fg_ReI,552 +torch/include/ATen/ops/cosine_similarity_ops.h,sha256=lVQiKaHbQlvcUvnM-cBjkP5ohOm0RhQUI_XmGp1Q_MU,1166 +torch/include/ATen/ops/count_nonzero.h,sha256=QQdNvTpcywP5jIB9fTzJLa9eKz7hHPcfxpCPinU8iCg,2026 +torch/include/ATen/ops/count_nonzero_compositeexplicitautograd_dispatch.h,sha256=tf_oqqVynMMTV5RV1NeNydcYMaDUGzn7kmVdY-ZKil8,1265 +torch/include/ATen/ops/count_nonzero_cpu_dispatch.h,sha256=FBrVfXgU6x3nFFrROZJKjhe_gxOe32MuX6zhEQIwfes,748 +torch/include/ATen/ops/count_nonzero_cuda_dispatch.h,sha256=EE3oYmEhT5abweGJHngTdMQKNV7_XqWr0zoHg4NUWiM,750 +torch/include/ATen/ops/count_nonzero_native.h,sha256=qXLoaT1xOGt2ZlaW32q6mg_AMQfipo6exTF7J_TRbi8,939 +torch/include/ATen/ops/count_nonzero_ops.h,sha256=1AYz-6CG_TB7fEf1J61j30IrtWS1Xm9uGGb5ckV-oPA,3231 +torch/include/ATen/ops/cov.h,sha256=P3inDkhG7ucnWDQhVd5mi3l2BEXxksw5ivbi289Usuw,828 +torch/include/ATen/ops/cov_compositeimplicitautograd_dispatch.h,sha256=ntaixdaSpkcAEhNE2y1ZUGIc90nhM-D4dJ3uXyTyPvM,877 +torch/include/ATen/ops/cov_native.h,sha256=d5oNU-F4YjToTKSiNE7IQRoUphSeQ84PtsDmfG_1Es0,600 +torch/include/ATen/ops/cov_ops.h,sha256=yBvEavr4JQeuJ71SOmjkL1XAIiRSjrOovnpvp5H0c0s,1320 +torch/include/ATen/ops/cross.h,sha256=mmPNMpMRkxGUcXM4P0AFuPwbK_DqoFuJKKjD5jtd1Q4,1316 +torch/include/ATen/ops/cross_compositeimplicitautograd_dispatch.h,sha256=TZGA85XiomuwH-fptowxUavTZ4aPf48AGpMa0Apv7qU,1106 +torch/include/ATen/ops/cross_entropy_loss.h,sha256=78F98L-LGeVd3OT-xUr8xjLYB0JY0sMihJnja4cYapI,2423 +torch/include/ATen/ops/cross_entropy_loss_compositeimplicitautograd_dispatch.h,sha256=-LyNol1846RdmBY4V9SEjmsEXvNkI7X4Ju69UsADitQ,1185 +torch/include/ATen/ops/cross_entropy_loss_native.h,sha256=WT2qcAGqNZdUc5jZ3mMAsvjzyi6nW49c96UyNN-vwmI,676 +torch/include/ATen/ops/cross_entropy_loss_ops.h,sha256=WYShcNmT3enrGndEsoAbB7cPFFXcoSlRYqHTQNnb3fE,1473 +torch/include/ATen/ops/cross_native.h,sha256=jOfUPzn9Rsen8gk6fhkJQA9WZBUvwhtrRMAWr-dzuEc,684 +torch/include/ATen/ops/cross_ops.h,sha256=b9lPwQ5z8TMTaKoDI0wDoC2CMLxfaSZkgCVaRi4owTs,1946 +torch/include/ATen/ops/crow_indices.h,sha256=ZHcmhuwvI1juYRE4EpqfcJFDKWpe44liAsYjvSFrYa0,497 +torch/include/ATen/ops/crow_indices_compositeexplicitautograd_dispatch.h,sha256=_w78fpD5cPDBFa5l2dFfGTzKOBPSx1jMppVkqzJ-PyU,770 +torch/include/ATen/ops/crow_indices_copy.h,sha256=GEnii1icR1E3iYVYOITAapWE_rdNNTvTUn3FDKDGkrc,1125 +torch/include/ATen/ops/crow_indices_copy_compositeexplicitautograd_dispatch.h,sha256=LEDe0wumTfyPrFVFsmJz8FomL-_aWjXLgfmg3put_kk,889 +torch/include/ATen/ops/crow_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=dor4GEDzsCoPlSlsDgkJFeuLcKD4k-i-dWyLIFgHUrw,801 +torch/include/ATen/ops/crow_indices_copy_native.h,sha256=a0p9mrVfns8hLkgf1VZCKNEag9AwnOiLA4Q5SHYRJq0,587 +torch/include/ATen/ops/crow_indices_copy_ops.h,sha256=lsEF3UjL0ui4H8HP5ZajAsJfQGDW5WVqNsmbb5okT9k,1656 +torch/include/ATen/ops/crow_indices_native.h,sha256=WUqGYIWxLUO0nLDvO9LCYpaRKaZGqX995IdpEnq8DWU,572 +torch/include/ATen/ops/crow_indices_ops.h,sha256=36t3TF6AYe_mVo7wWA88kZwXQu_uupUJtdxglVl315A,991 +torch/include/ATen/ops/ctc_loss.h,sha256=ESWQTS-emMvqSZG8ACs6AWu0K71TRqpD75zCpSkH9V4,1570 +torch/include/ATen/ops/ctc_loss_compositeimplicitautograd_dispatch.h,sha256=lodC6QtfIpGZWarBKx1EU-y_ZEKhUrjerqhrkNgiWUU,1184 +torch/include/ATen/ops/ctc_loss_native.h,sha256=pHmklPZN9i5zb-lHs2PqZxHyhOLBJkQ1JRNlsaIXblU,907 +torch/include/ATen/ops/ctc_loss_ops.h,sha256=tam1NB_sGcegE5oh9ZpX6WS7oM3ztQcsFOzz_IPnKXE,2577 +torch/include/ATen/ops/cudnn_affine_grid_generator.h,sha256=dWNL5cgN_wp0IH1iVrfNE4MnCUFfGl8r-u6XcehOjmc,1491 +torch/include/ATen/ops/cudnn_affine_grid_generator_backward.h,sha256=u7jEVVDw2U4DYC6GyAYnC5Ee4SgMs_cFxo8ruh0HRKU,1578 +torch/include/ATen/ops/cudnn_affine_grid_generator_backward_compositeexplicitautograd_dispatch.h,sha256=omgVfGaYsaVWSRcW0IB3KYtsgv8tj7uY_3ok0Udwmuo,1015 +torch/include/ATen/ops/cudnn_affine_grid_generator_backward_cuda_dispatch.h,sha256=6c_zsSS4UaFFGCahgjtd-5WGJASaHHpFX-n89fHjLkU,796 +torch/include/ATen/ops/cudnn_affine_grid_generator_backward_native.h,sha256=lbDDk5Jlm801sC4bs6rlnpZypeUPL9VrQZ1RNVmcxRo,713 +torch/include/ATen/ops/cudnn_affine_grid_generator_backward_ops.h,sha256=-aRwVQji_g2Qov33XjUVMi4wg-3GzmqL8fmXTG2n9Bc,2085 +torch/include/ATen/ops/cudnn_affine_grid_generator_compositeexplicitautograd_dispatch.h,sha256=rXr_id-lUlL0PZLDFAndWFduVVPk9zmcBHSbRU54_34,999 +torch/include/ATen/ops/cudnn_affine_grid_generator_cuda_dispatch.h,sha256=Mg-Zbx9D4KO_RHKckBZyuaB5ZnmL5k_ybw-VOv9BAho,788 +torch/include/ATen/ops/cudnn_affine_grid_generator_native.h,sha256=1lwqidKk5c3TKoen23G29f1lyL10-0d099w1slRZOHM,705 +torch/include/ATen/ops/cudnn_affine_grid_generator_ops.h,sha256=lqPhdrBfovnJl1upr6QbHLRy8MZg7Rkzrr2jREInA58,2031 +torch/include/ATen/ops/cudnn_batch_norm.h,sha256=5714EFo_UdZ9xhuNac6z3X0_9v8jJeB9uxueCNQ3-p8,2993 +torch/include/ATen/ops/cudnn_batch_norm_backward.h,sha256=VQEGutl9d87uxghSG1Blk9rDDKo8qdoLvD7BT0DEQi0,3179 +torch/include/ATen/ops/cudnn_batch_norm_backward_compositeexplicitautograd_dispatch.h,sha256=Wp2Yo2I9N87gSJ3STsOeJdXB3rQ2j0FdxxiGhb2Cvto,1649 +torch/include/ATen/ops/cudnn_batch_norm_backward_cuda_dispatch.h,sha256=af0anfv834uMvCbigXyf40ge7jf0KKBjh6lsQ1YSnjk,1070 +torch/include/ATen/ops/cudnn_batch_norm_backward_native.h,sha256=FrVekD3Yl6yiFm0TEQqdEm7XBHsGscruMpygmwiAss0,1304 +torch/include/ATen/ops/cudnn_batch_norm_backward_ops.h,sha256=ltJ3Q915QFb8GgPDQmM3sqm8J3X12WO14ByFqZwLAxI,4009 +torch/include/ATen/ops/cudnn_batch_norm_compositeexplicitautograd_dispatch.h,sha256=TFLBpIjks62tnVXVsbReuLiwDIGsTC3i1VJLf7BKAGA,1567 +torch/include/ATen/ops/cudnn_batch_norm_cuda_dispatch.h,sha256=-og_QsxPs2Yp-ACeditkEsckrTl9FG46JdEG1XN27Aw,1008 +torch/include/ATen/ops/cudnn_batch_norm_native.h,sha256=gBmosr7VyPo2URcQmoZoRHEQvmiix86FXG8lhy2alwk,1201 +torch/include/ATen/ops/cudnn_batch_norm_ops.h,sha256=rYo9zSp7xx15atqQrnSaieoBWPmSsMjUuuUzM3L8MJY,3708 +torch/include/ATen/ops/cudnn_convolution.h,sha256=iEAclXpb4jZzWyvmB8BVp0L73oLUNoYXIu0L_zvcVsg,7654 +torch/include/ATen/ops/cudnn_convolution_add_relu.h,sha256=NKHWQS94MJk5_yvjgJIa987S9fcKZe0Vv2IPLVi6_cU,8185 +torch/include/ATen/ops/cudnn_convolution_add_relu_compositeexplicitautograd_dispatch.h,sha256=HRCvRmsJnjj5Yn_kkQylUg1wh07BgOKc5U0UkgkppmI,2034 +torch/include/ATen/ops/cudnn_convolution_add_relu_cuda_dispatch.h,sha256=uyvvzlzru6gmrFxTWtblDaJUnA0IeWXD0uDm7JfDJ28,1281 +torch/include/ATen/ops/cudnn_convolution_add_relu_native.h,sha256=HtCFKlWAKpjElyk0JMkK_FjJGeZv7gZa34Et8akixAI,1070 +torch/include/ATen/ops/cudnn_convolution_add_relu_ops.h,sha256=Nc9Pu0XtgO3KXQFnFV1uF3d0_lJC--MyzwrwlsRjKb0,3276 +torch/include/ATen/ops/cudnn_convolution_cuda_dispatch.h,sha256=YaFY9gjKM4k1dNQOLAgTlELXPHQnZOONzBjMOnWfwrs,2251 +torch/include/ATen/ops/cudnn_convolution_native.h,sha256=WZcG0hFo3kC7SR81mhnnseI7ijjkgN-nlu-sbiXmnWM,929 +torch/include/ATen/ops/cudnn_convolution_ops.h,sha256=w5C4E_SBMlb_J17X-IAzhd3IHo0IiFIzoQCNHLFDl2I,2906 +torch/include/ATen/ops/cudnn_convolution_relu.h,sha256=Bv6wOIY-SPYifl6rowNkgk2iEnfsUWPs0P1zOFM879k,7035 +torch/include/ATen/ops/cudnn_convolution_relu_compositeexplicitautograd_dispatch.h,sha256=QsDN8KSKrEvOSCFxQiSV9rjH-3nbGaZKRFsBcHCKFbc,1766 +torch/include/ATen/ops/cudnn_convolution_relu_cuda_dispatch.h,sha256=YwPk7u7w4hDG10xI6wgQvBx5X_pY-BOSVVZljgUUIzc,1147 +torch/include/ATen/ops/cudnn_convolution_relu_native.h,sha256=KaewlwUZUjgNn5c4Ai6cCoTLUFlnYb1tWz5y2SjvWoQ,936 +torch/include/ATen/ops/cudnn_convolution_relu_ops.h,sha256=U3X4AAvEpYu6v5bxIFZoErZtA-db2iqMVhqLG835OTc,2840 +torch/include/ATen/ops/cudnn_convolution_transpose.h,sha256=tyEDMuMGqXmxmPwD4YPnnq8H_HNvBsI_tISaE017rjg,8870 +torch/include/ATen/ops/cudnn_convolution_transpose_compositeexplicitautograd_dispatch.h,sha256=Ak52MBqjj8TkxX5MtRq7zLDR_o3c0_SdQJXU1VDvbTc,1974 +torch/include/ATen/ops/cudnn_convolution_transpose_cuda_dispatch.h,sha256=xmvTx8EkFeA4j-xcn-a1SHY6LZr0XCE4xRAPxxn59T8,1251 +torch/include/ATen/ops/cudnn_convolution_transpose_native.h,sha256=mdPrhfSl-mmT2FzHcfWW0RLmdWdeImqc4VvnYUlhN-U,1040 +torch/include/ATen/ops/cudnn_convolution_transpose_ops.h,sha256=-euPsLDgfpwp5nafk1mKgSbN2csnwG3PSo3rNqX4wNw,3202 +torch/include/ATen/ops/cudnn_grid_sampler.h,sha256=VYlKE4mSTVAhrshRCESYJbKY2QTHfeS70Z5PZRnY6EY,1274 +torch/include/ATen/ops/cudnn_grid_sampler_backward.h,sha256=fomw9dbnm4t1SCZhhVEUxkHlBH-C7ihm8LhzOqb62aY,1779 +torch/include/ATen/ops/cudnn_grid_sampler_backward_compositeexplicitautograd_dispatch.h,sha256=blb1k5yEpgDhv-rEyyTpUiJ3PcvMuOwe2aF3lUvf7HE,1117 +torch/include/ATen/ops/cudnn_grid_sampler_backward_cuda_dispatch.h,sha256=6uvFt8Ug12xf33J9ANxaaRw67-qmJMwSXdSY69QXI50,825 +torch/include/ATen/ops/cudnn_grid_sampler_backward_native.h,sha256=SmJZPXrF-lIXpxiuVFTNfLYrraTLKlfWJf9sSbuL5yQ,793 +torch/include/ATen/ops/cudnn_grid_sampler_backward_ops.h,sha256=dKSQl1gW3FlHQX979J9yv-d_wvsjnVx92rJb79w_iog,2362 +torch/include/ATen/ops/cudnn_grid_sampler_compositeexplicitautograd_dispatch.h,sha256=sX_Pp6YMhGvDf0YSUuEeayTbV_Aqvp9oC_gHZ-HnzKI,941 +torch/include/ATen/ops/cudnn_grid_sampler_cuda_dispatch.h,sha256=YwZPDzrrJAefCUs8Vg15yk7OdmObQI4xsKjJ2veupUI,759 +torch/include/ATen/ops/cudnn_grid_sampler_native.h,sha256=IUM5kbqYJr65PbMnhQhEOyWA2UXOMB-eWMC-_c5w99w,647 +torch/include/ATen/ops/cudnn_grid_sampler_ops.h,sha256=yO2grglRr4SBRLFnkpDbI7ri_5xKFLs1TY-hLkurWCs,1835 +torch/include/ATen/ops/cudnn_is_acceptable.h,sha256=m8CPpy2Qu1DVRluJ3P7MYjkN5BNUudps58DfMF76VUk,669 +torch/include/ATen/ops/cudnn_is_acceptable_compositeimplicitautograd_dispatch.h,sha256=E0ZgfkRQcvvGaP34ONxiQn1PtPZlFmH9nyYCz3-wGUo,771 +torch/include/ATen/ops/cudnn_is_acceptable_native.h,sha256=sTzHj2dDjfIdvUHjqw5iU3r3kFWubRqd4DugykVNDAA,494 +torch/include/ATen/ops/cudnn_is_acceptable_ops.h,sha256=D3zNVwsWkeKGpVO8FW9NNku6YIOZMskTO2sV9NDD-gY,986 +torch/include/ATen/ops/cummax.h,sha256=pYukgwz9k9FY4aR_ACD56VOPuPRfFKeQ8voAgEr-O9E,2338 +torch/include/ATen/ops/cummax_compositeexplicitautograd_dispatch.h,sha256=JAsbyGjv8yHd9qvsIub_amJCvIqUy7kHnWUMFa1qpDk,1089 +torch/include/ATen/ops/cummax_compositeimplicitautograd_dispatch.h,sha256=ysKrZo_zIiCtP2NM7FWbx3t2jjXesY3qvwVU6d4PY8k,1101 +torch/include/ATen/ops/cummax_native.h,sha256=7-3BfiWgvH40pvnTrXBPPpaRFpf1ZH_l3gbnssqO-Ag,911 +torch/include/ATen/ops/cummax_ops.h,sha256=S2OwuixN8NCm1P7w1xUrbu2B9nV-Bzz7gSu1qzB_6kI,3595 +torch/include/ATen/ops/cummaxmin_backward.h,sha256=p3sPW55GCQrq3teTQLEgNIwC1UkUghNpuyr_uqxjjHI,800 +torch/include/ATen/ops/cummaxmin_backward_compositeimplicitautograd_dispatch.h,sha256=zgUxDvn3JeRV1T8HH7wlJ_SOmfWDblm-aRCdDuRLD6A,843 +torch/include/ATen/ops/cummaxmin_backward_native.h,sha256=7juatun98ujlPxyeFJ5rfX5VN3iVEozwQmfXqXVb0sQ,566 +torch/include/ATen/ops/cummaxmin_backward_ops.h,sha256=Loa8RpajstYXErtEYtUKvzDBpDwpTNnpUSPxT2GVHcE,1225 +torch/include/ATen/ops/cummin.h,sha256=_LWPoZjqhhpbDmFWSkTk8sP8mNryLiLIj06gNa0HeyI,2338 +torch/include/ATen/ops/cummin_compositeexplicitautograd_dispatch.h,sha256=kc3U0-PI7dbqXr1f0IXzDXAdz29cGdqR4FhmKxkXw2o,1089 +torch/include/ATen/ops/cummin_compositeimplicitautograd_dispatch.h,sha256=-0jp9zEiv4a_fMS1YeyFUKwVVAAKkA_OE9GEkAn3IZI,1101 +torch/include/ATen/ops/cummin_native.h,sha256=hmJnKx4lG5-PXImI-EAVSeO4b65Crhc3M4jhmEaxU1g,911 +torch/include/ATen/ops/cummin_ops.h,sha256=_BNGFROmStBNEyh_qn8vY1XGTGSEFd4OEVG0od2-q0s,3595 +torch/include/ATen/ops/cumprod.h,sha256=hz819Wqkr_1iPTgTcpsG6nnwcjYI-CYghIho33t4xyQ,2259 +torch/include/ATen/ops/cumprod_backward.h,sha256=ShGAhfyti9SNAP6EO2-Eaocc9LZvtY5S5iQbZh2mahg,789 +torch/include/ATen/ops/cumprod_backward_compositeimplicitautograd_dispatch.h,sha256=wLxWUZU6Af4t8iHIxKTlR7jCShqfM-MmgAgxaE0ORHk,840 +torch/include/ATen/ops/cumprod_backward_native.h,sha256=sty9vnj3HvZ1cGbwnXiZbbB2Xx-t2iSed47voKN6-6c,563 +torch/include/ATen/ops/cumprod_backward_ops.h,sha256=LCG7KQ3hYNzvBHGNf3J-J3DsgecR8miUl2uOSY4Up2s,1216 +torch/include/ATen/ops/cumprod_compositeexplicitautogradnonfunctional_dispatch.h,sha256=E9_ZmKUp56YfycDd8h3ucnkuDbK7ZyWypRz5dnQDg8E,969 +torch/include/ATen/ops/cumprod_compositeimplicitautograd_dispatch.h,sha256=EB6LQg40YBxcxc-UolVWUDC-HF13wr45rF7apc1f2sw,1231 +torch/include/ATen/ops/cumprod_cpu_dispatch.h,sha256=GgUQ7GgpJzSYiTI4LnpvULR0tDG0HGqblvEjYuDBJdo,1171 +torch/include/ATen/ops/cumprod_cuda_dispatch.h,sha256=F57tHG9mEXWNeMnWbrcIs2T2YuLpKKw_uXRGx_5pyzg,1173 +torch/include/ATen/ops/cumprod_meta.h,sha256=mjhqH75DXvuXxEt7b9cxyPZd5-4rdhLwJbMVzN4bmXQ,637 +torch/include/ATen/ops/cumprod_meta_dispatch.h,sha256=lMNVsQUBvx26iTL7brIp6BNwTADiSp0ASTUd8APLpmw,1173 +torch/include/ATen/ops/cumprod_native.h,sha256=8lRJ_FU1HtHTBmVfLb2jeMZbsOGRaVBh6K7cMiYr6qw,1034 +torch/include/ATen/ops/cumprod_ops.h,sha256=G-XIHDj8XtvNitB_fDEEaJS9ilWRyj8w6uGl46ZAYxU,4996 +torch/include/ATen/ops/cumsum.h,sha256=WMTrMWnya9kNt4avmiHSGsKMvhPOsCwmAZK6h60w05o,2240 +torch/include/ATen/ops/cumsum_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Q8ksAD3d97CruaYp3IZFcfK7WJCVG7CiKq-CacLWrzk,967 +torch/include/ATen/ops/cumsum_compositeimplicitautograd_dispatch.h,sha256=f0BpfNJf-Sr33LWhx0c2w31Lh0TLzvqqfGPoNJ23gOY,1227 +torch/include/ATen/ops/cumsum_cpu_dispatch.h,sha256=jviHbUasmrr7Yx9DNnFCYHMM90mbtSHUTzT4yaGOstA,1167 +torch/include/ATen/ops/cumsum_cuda_dispatch.h,sha256=CclAa1AkXe8RfhUj4aIPpi1JEuXHP1EHJvLBnELTsBA,1169 +torch/include/ATen/ops/cumsum_meta.h,sha256=Tfzp8R8q_7D_Svn99Bf4mRrWK09_NA_-a4eVwciGDqM,636 +torch/include/ATen/ops/cumsum_meta_dispatch.h,sha256=pRyCm5k6i-0bXHqWxmhA3OPrGYUtXpQSAPBUV7OAn7Y,1169 +torch/include/ATen/ops/cumsum_native.h,sha256=JwSgWvsUWSlwF4OSjxZStRhxWSqbzgy7KGkrN4d6AUE,1028 +torch/include/ATen/ops/cumsum_ops.h,sha256=MXtUqZcjwtDabBSYToebaaIEbY1pswgM8lV8WvjbIw8,4978 +torch/include/ATen/ops/cumulative_trapezoid.h,sha256=1exYeRsIoCOeR-hC7FpGdASwqjaDNgRtieGkjmX0xp4,999 +torch/include/ATen/ops/cumulative_trapezoid_compositeimplicitautograd_dispatch.h,sha256=8ZQtDNIBh_WBa_GRz5Y3eO_cP5jkEtEoH1wy8mknN5M,919 +torch/include/ATen/ops/cumulative_trapezoid_native.h,sha256=GWg0L7FvxvCFbSQayzlxc4vlY7tpyQU4fnRcgr7SBqs,642 +torch/include/ATen/ops/cumulative_trapezoid_ops.h,sha256=du_Q-ICs0YLOqj1kr5peSvhApZMrCOCIAdY21MpOLho,1832 +torch/include/ATen/ops/data.h,sha256=olRxkf7UOplqWe3e7OP5pZDmLe234zxef5mp1eUbCgc,489 +torch/include/ATen/ops/data_compositeimplicitautograd_dispatch.h,sha256=7rT5Ey_ek1MWNWGDWMK7RTglC-A8vrIUHUoogFmPrO8,762 +torch/include/ATen/ops/data_native.h,sha256=TsUamkwCK4ExXzifYSMe6iMIMSqsHz9w1wYJxXGWDIY,485 +torch/include/ATen/ops/data_ops.h,sha256=u5ZB5e0cuxEmIjBTvPBdEhTaN3oCXI_ZS7zVWaw209A,961 +torch/include/ATen/ops/deg2rad.h,sha256=_95ds-7gLx3c9HgRSqZDrUT0PIgyvrLjcUTdbvSRb60,1170 +torch/include/ATen/ops/deg2rad_compositeexplicitautograd_dispatch.h,sha256=DLSR889V3eHxDTyTDgFYjBFbYzyQ4e_g78K8hW3VHqU,976 +torch/include/ATen/ops/deg2rad_native.h,sha256=Y6lzpXKK7HUQZLS6XYY-VP1kJ4GtsXI8m3BOtRFYROQ,1045 +torch/include/ATen/ops/deg2rad_ops.h,sha256=OdRtNfWstIS8NuMt9u39a8jLyG23xWV_yPS9o1hnnl8,2131 +torch/include/ATen/ops/dense_dim.h,sha256=4cRjTPlG_8a9j6ZpuIQBweBtVoOlFBGFUNZMuzWkCg8,494 +torch/include/ATen/ops/dense_dim_cpu_dispatch.h,sha256=630cXfxbYNNA6dqh2CAUc2FIo7-kshaz_CXEWoR2wLE,720 +torch/include/ATen/ops/dense_dim_cuda_dispatch.h,sha256=b91WkiC6cmqrbwNTzIam_7cJePSfgH0ErIROjDrJneU,722 +torch/include/ATen/ops/dense_dim_native.h,sha256=UpsXu9HSMoiz_cAeKHvyTG0_98YmEKXeMI38-lK5NGM,621 +torch/include/ATen/ops/dense_dim_ops.h,sha256=dfFIdqBZog1yvhySDqWSuH-uZTbRkmTEMWQcAgXduyM,964 +torch/include/ATen/ops/dequantize.h,sha256=p52EhUaIvvxpDV6O3oRXCSxX-eH3_y6t9_OqWsfzDTY,1708 +torch/include/ATen/ops/dequantize_compositeexplicitautograd_dispatch.h,sha256=G79b9-0_JeOtygHHMAr06A1m2Npq-6vwZf8wU4ddJl0,1026 +torch/include/ATen/ops/dequantize_cpu_dispatch.h,sha256=PgMCnHQK2lewGWM_pKyXztqTdjHq1sphVO5wR-wODHE,724 +torch/include/ATen/ops/dequantize_cuda_dispatch.h,sha256=sbUXS-BxQPCsWFII-0-Yj7zMWV1u_aMl5gIEhBtWCPY,726 +torch/include/ATen/ops/dequantize_native.h,sha256=XlO3Aq6dGG39YUfAx73Ex-uT4rblKxU_pSr2nNQUMP4,835 +torch/include/ATen/ops/dequantize_ops.h,sha256=-OZ-tyqbEcR6eBGwELdE5M85Z0UpNdHHxetJke3sNog,2891 +torch/include/ATen/ops/det.h,sha256=wDePbrvqjm_Ledl4p9thQKnnhE8cC1W0WiCs7Gjhc7g,613 +torch/include/ATen/ops/det_compositeimplicitautograd_dispatch.h,sha256=vMhr6dD8nYriKxlO7LAas9mbHdj_bRMEbwKfkByWGcg,761 +torch/include/ATen/ops/det_native.h,sha256=xISiolu42yWEzVPa9ugUs0AbTV5EGU7at_avfwMugSI,484 +torch/include/ATen/ops/det_ops.h,sha256=Vj5DXd8PKWt2U3DCF6Q1VRea4zF-QQTORJS1tMO1nks,958 +torch/include/ATen/ops/detach.h,sha256=ik9ZE_g1hyvevsa9YgDwB_LqhfFZ9HguTDOVLnOlrdU,773 +torch/include/ATen/ops/detach_compositeexplicitautograd_dispatch.h,sha256=crcZzI_9nwLGaJvHqbeMlfQpDK3rghIb7ftfD7-K2Yg,815 +torch/include/ATen/ops/detach_copy.h,sha256=FKZ0Sf8MP1P7L_Y18hqQJC2-9_ZjZIM0Zk-RSBnYJtI,1065 +torch/include/ATen/ops/detach_copy_compositeexplicitautograd_dispatch.h,sha256=xqbDYRrKQ3HENY3MW9a_H2FO4r_MZEU-BPYRjjTJxKE,877 +torch/include/ATen/ops/detach_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=vW0hj53gbojTYp7awhEvCMgH3ATWwxH5LDf6gHofF-M,795 +torch/include/ATen/ops/detach_copy_native.h,sha256=7TGbutWNjSLEL7leF3o-fxOAf_SN__uGbGzrjINRNoc,575 +torch/include/ATen/ops/detach_copy_ops.h,sha256=d8aBlrElKzmbT7QyKh0KcxyrnjALAKKtRr8TNprn4yM,1620 +torch/include/ATen/ops/detach_native.h,sha256=Lqu0rAu8I4gE_gFia7O5TJcR0WUzUDgkgbiGqBnLNkA,538 +torch/include/ATen/ops/detach_ops.h,sha256=HCMLv23LQjjPvBb6SRS5SoI6sHW6Jdr5AJa3OYPdNHQ,1505 +torch/include/ATen/ops/diag.h,sha256=vb2jd7bEwwJJGk5eTa6exYSzYtEO_CXyX3oPQ82pMI8,1131 +torch/include/ATen/ops/diag_compositeimplicitautograd_dispatch.h,sha256=edYpNbx-uPwMurX3pmgjbRTGlyh-cXPUVb4hup1v0KU,973 +torch/include/ATen/ops/diag_embed.h,sha256=uTisEuRxIXjZf0nWRxVnl2RZ7OL3Fta_zLsqPCXCcBc,1383 +torch/include/ATen/ops/diag_embed_compositeexplicitautograd_dispatch.h,sha256=gg8ug0EHOEm6fljI_cZ4Uoc9S-U2fToKJT2DCO-DFr0,971 +torch/include/ATen/ops/diag_embed_compositeexplicitautogradnonfunctional_dispatch.h,sha256=BqH6JU_YRm-CUQFRUTvWhpZ3mYiXTmYXqqaZKlpTebs,846 +torch/include/ATen/ops/diag_embed_native.h,sha256=BJIeE3KzhiFUzPFrcxpPM0Cb4P0DC_FoEuDFxO9ZHqY,669 +torch/include/ATen/ops/diag_embed_ops.h,sha256=mptAqmzVQsq5iG3HhfAOAcYv3B0InnlM7lUkqDnELQ0,1924 +torch/include/ATen/ops/diag_native.h,sha256=yc4w-euyMh-gWFORsZPdg-D5Wc3Y_PCLxThz-M3xQi4,599 +torch/include/ATen/ops/diag_ops.h,sha256=S7jqrigTQIddIssEpjQGpYFWhe36gLkZf8_oCTi3vDY,1700 +torch/include/ATen/ops/diagflat.h,sha256=79q9p7mJ_3n4VmV_DoRfR56m_6yQV0SIl1l4xUidSgI,673 +torch/include/ATen/ops/diagflat_compositeimplicitautograd_dispatch.h,sha256=iAv9nwwoz86t3SP_zl3mQCCfQAF_QsHYZ_vBg8lLqh8,784 +torch/include/ATen/ops/diagflat_native.h,sha256=576p5a3hUPL7j6vSB347-c_-CPQ_8zVOZJfgOd6f1v4,507 +torch/include/ATen/ops/diagflat_ops.h,sha256=MOgSp8i8tHXdiBw5qpgqGCrWmrCauws3VABcgKQW9W4,1028 +torch/include/ATen/ops/diagonal.h,sha256=GvmjO5XV0raFRsRKQUHdTz-L8fS-22UQlbwxOtV8BgE,1073 +torch/include/ATen/ops/diagonal_backward.h,sha256=Cl99mg5hvmzqwhCh2_F2Zo21jLFjq-BQVJ46RyX-on8,5230 +torch/include/ATen/ops/diagonal_backward_compositeexplicitautograd_dispatch.h,sha256=AOBdU5Kt4gWehW06MCyD-vmUcCLIvk6MhVu9952CYQw,1711 +torch/include/ATen/ops/diagonal_backward_native.h,sha256=qBx-S9aA4IgMI_jwNXQRmbq-Zt89jw5bunmMBJyWvfM,769 +torch/include/ATen/ops/diagonal_backward_ops.h,sha256=VNqKKNrZmP5mYSw_CLSF4fAd4BKZjNAEfh8gamUTOB4,2210 +torch/include/ATen/ops/diagonal_compositeexplicitautograd_dispatch.h,sha256=YNCL9amA_G1wo5NJs2cWY13NlZUJhLaoM6LR-9sjqJ0,816 +torch/include/ATen/ops/diagonal_compositeimplicitautograd_dispatch.h,sha256=eFMJSnz1dq1oAiLRHonak-2wtUy0wI6EqqvdkPVofBw,840 +torch/include/ATen/ops/diagonal_copy.h,sha256=gpTSmzn8GRGOPvyPXd-8IHjKYOzTP_W6hUjBjnpaKD4,1403 +torch/include/ATen/ops/diagonal_copy_compositeexplicitautograd_dispatch.h,sha256=FqVEXXDUGjaBarEzXdKgH6vPnanN89fGkBUiL3JWP3U,975 +torch/include/ATen/ops/diagonal_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=1eCt651vj8kU98-XvhO2c7oWCIupIeanTt5z2gUjEzc,847 +torch/include/ATen/ops/diagonal_copy_native.h,sha256=eFapkmNecl7PG26LhOskH3TJIFFp-7inc--LwuqiauQ,673 +torch/include/ATen/ops/diagonal_copy_ops.h,sha256=tASZqgsDLLnaqQ451bt-C-OV_8HuYCBef4d6w4ovm8k,1938 +torch/include/ATen/ops/diagonal_native.h,sha256=q4RUZuLjAGo77_F7RqQ_kZZu5k_DRVUeVu55VxtKP5k,669 +torch/include/ATen/ops/diagonal_ops.h,sha256=pyLMA9TiT_xQcDDKJwbodaLaLCG5qU4bjbMGLXPQCwA,1953 +torch/include/ATen/ops/diagonal_scatter.h,sha256=uMzPG0jit7W0qvCQHnA59QQZEu4Y6y5xVKz48bOo4as,1556 +torch/include/ATen/ops/diagonal_scatter_compositeexplicitautograd_dispatch.h,sha256=St221yGHbtk1c16W8KqHEsb1Gp78kre72V65iTIC6Uc,1029 +torch/include/ATen/ops/diagonal_scatter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=gQ6Hz-GumZ1598dqaSGzKKSS7l1kd3AcB3m4kIsIa8w,874 +torch/include/ATen/ops/diagonal_scatter_native.h,sha256=CpZHiE3F3YMMKiGTl7RvzWqKjDNWdtbSeok090D3pOk,727 +torch/include/ATen/ops/diagonal_scatter_ops.h,sha256=fBMgl9nXo9wOAi-Zr9vxuZ4D1IiDmduYdEIG85GDCKU,2116 +torch/include/ATen/ops/diff.h,sha256=FvaXdOAqcuEXnRmvNh0u6DYdsd6H7DLOk9xQUqpfILA,1611 +torch/include/ATen/ops/diff_compositeimplicitautograd_dispatch.h,sha256=ofKsgvyaUDGtMy1yHbA2VOfXeeQjUIBoR8lXb687YXA,1264 +torch/include/ATen/ops/diff_native.h,sha256=t6AFB3b97s1eW-V9Db2CiVAHan7fg3FWVQ-OPKDX0AU,790 +torch/include/ATen/ops/diff_ops.h,sha256=NArhjbSSyqoskz8ys1aEFDE2NxNprBzaYxyWfZZ5DYs,2318 +torch/include/ATen/ops/digamma.h,sha256=DCbpb7Q5xkhbDiIG7fO4C0pF4MzdfBTymMsiurX9FAE,1025 +torch/include/ATen/ops/digamma_compositeexplicitautogradnonfunctional_dispatch.h,sha256=9X1iwB9nsSRxsdntZOMRgNxmGsS45_ZQhKj_pP0pwAU,843 +torch/include/ATen/ops/digamma_cpu_dispatch.h,sha256=MzP1whO9KAJd-sPTA-0DmQFm4nc7wudhV4fErigm4RQ,932 +torch/include/ATen/ops/digamma_cuda_dispatch.h,sha256=jR7Kxf3Kutt18KxH-jso7KLOqnEnbxR_Bq6rrPpplc8,934 +torch/include/ATen/ops/digamma_meta.h,sha256=UkRji9cCYf0tAz78fUaw6JIOnYgBXj8FH3JLNAdrsuU,587 +torch/include/ATen/ops/digamma_meta_dispatch.h,sha256=MuEijZQNPnfdw2EgfID4yZbv9rKtm1BwMxsKMYIHJ9Q,934 +torch/include/ATen/ops/digamma_native.h,sha256=1tf3qjn2Or8BnU0jcMjdcUOma8kOdt4EkSA1q5cGoXc,610 +torch/include/ATen/ops/digamma_ops.h,sha256=95pRtKCzuqvWcr25N4q5uURQ2pe2JkrU5GfP2iDUgi0,2131 +torch/include/ATen/ops/dist.h,sha256=YtuQHwSzsJ71p_2BOo_6BiAFDEE4OWVTy0UYTwzknMU,1251 +torch/include/ATen/ops/dist_compositeexplicitautograd_dispatch.h,sha256=pc6-HxVURdAmbQaoZuiKy0zBIcwKICyCIK7PEulFXsI,1063 +torch/include/ATen/ops/dist_native.h,sha256=yucZAgWqHKREO_tMuo3xHamCPkd1nXjQIAKYndSbQBg,659 +torch/include/ATen/ops/dist_ops.h,sha256=wyD7JR6GdQQ8otEPNeRNCs6wUtNu3EcNt_8m_ItGIPI,1902 +torch/include/ATen/ops/div.h,sha256=nhP4r6SFfgvf3GSspF0-SYkvHZ-2bSXr8hOVevp1qMk,3713 +torch/include/ATen/ops/div_compositeexplicitautograd_dispatch.h,sha256=jexmByoV23UmyCmY3PO7A0sUp68RnpLRbw8vjeg87Tw,1606 +torch/include/ATen/ops/div_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XyRbLM8ZmSEAQcOiXp37VvUFa9xSdBDmsHu7n_X57iA,1132 +torch/include/ATen/ops/div_cpu_dispatch.h,sha256=7OQ0D-Vy_f38vrzi03utqLgsoX7KaxW8VAPJuaKXpqk,1562 +torch/include/ATen/ops/div_cuda_dispatch.h,sha256=AAe1ndRGJxdXOnFF6FZeN1rbyAp1MQLigYbhrUYDHME,1564 +torch/include/ATen/ops/div_meta.h,sha256=WJ8kgOoWRLfbtQTBFEAzm84po3MsDlUNBoDhzlnEjJ0,816 +torch/include/ATen/ops/div_meta_dispatch.h,sha256=O29fXORCuFEwtXjL5hkPXRQE9Yx_2IU5uN79a5C88zs,1564 +torch/include/ATen/ops/div_native.h,sha256=06TvqUV9r7hXQMbeGT0ZtQ5ZlpFB6sAJ-DF3ZdIMnj8,2505 +torch/include/ATen/ops/div_ops.h,sha256=fWdk8l0oOekOYPsDjFj0bRsHdsKhvrBm9voc49siKWU,9296 +torch/include/ATen/ops/divide.h,sha256=KW2lNdW65x_c__CGQInqJl3qGblExW273a4yNdc48J8,2616 +torch/include/ATen/ops/divide_compositeimplicitautograd_dispatch.h,sha256=-I8ZrlENPBYi-mZHD18qqUlFmMYZITX2jwXOM7xmTAo,2038 +torch/include/ATen/ops/divide_native.h,sha256=6cHfFA03AmfvuwznqfVA_AXojvPg0YgsskZsMl5b0T0,1504 +torch/include/ATen/ops/divide_ops.h,sha256=75CNY0HcyN1dHR0uAXmYz1lICyvJYlNK225853lH1A4,7782 +torch/include/ATen/ops/dot.h,sha256=1UuXr9OmtAd1xeziesj5fD9rDu5eQoB0QEdc6Gvl5fM,1135 +torch/include/ATen/ops/dot_compositeexplicitautograd_dispatch.h,sha256=usIcLuparc2NVrF5TntbpbjqgiYJq-dhnbfKBM-ixjs,915 +torch/include/ATen/ops/dot_cpu_dispatch.h,sha256=ywDI3f52zvW9ZKo6diE_gnWH81jZEoKLcdRwFswIp5w,744 +torch/include/ATen/ops/dot_cuda_dispatch.h,sha256=A86RTtAXKBpGuszl0vJJJXB-rvKc5BIKkMrFAUY8Wuk,746 +torch/include/ATen/ops/dot_native.h,sha256=7PGyEqJljvQTQh1RS_BRGqkcMVn6ukufnxBk6M4LSz4,696 +torch/include/ATen/ops/dot_ops.h,sha256=gv9JbRQjSCoZLAJy8r_guZrkocYQvKipACGh6fSzl-g,1750 +torch/include/ATen/ops/dropout.h,sha256=ckLZuvwBwoFnSbwIm1UIYnI9xaLCK3HHk8W9JnwPbW0,883 +torch/include/ATen/ops/dropout_compositeimplicitautograd_dispatch.h,sha256=1oNmNCeNCWLHWL9vxzq3kL67NmtOUC8Ir9mLr81pUbE,862 +torch/include/ATen/ops/dropout_native.h,sha256=Am_s8C_2BP-limHudqlMYL7ncF-Z9COE4rZ6Q7HywsA,585 +torch/include/ATen/ops/dropout_ops.h,sha256=mEk39af2nGsRYGCqYkV5bmExg6es_HIHHUYCPXBtGO8,1666 +torch/include/ATen/ops/dsplit.h,sha256=jhKjvCiQhYFJ5iIQRKqJoV1k0LiQRc51Oyy8W_s-ojA,927 +torch/include/ATen/ops/dsplit_compositeimplicitautograd_dispatch.h,sha256=Lc_xGCKzhxHNU6F2ztKMmp3eKEXyWbtDoBFsS4gUTb4,891 +torch/include/ATen/ops/dsplit_native.h,sha256=v5CceKHVxUKD10prClTTwd6ftAXohY7vQAYgnUGwsf8,614 +torch/include/ATen/ops/dsplit_ops.h,sha256=95tud01xSOmnkYVwEZXPNYSCuUmJtbKvrDFYqugFXQ8,1785 +torch/include/ATen/ops/dstack.h,sha256=ircg8ZDuOcy-VbPr0jHcBHCB5fyZRTDmnoKbDdLWiXg,1036 +torch/include/ATen/ops/dstack_compositeimplicitautograd_dispatch.h,sha256=-PJkYjYTP0wjfRHnQapUQfgNNbnBYTdnEAawd6IfuGo,918 +torch/include/ATen/ops/dstack_native.h,sha256=odFJOUGWApyH5F92QolWBMQMtxEzTGJXonPFetCizCA,563 +torch/include/ATen/ops/dstack_ops.h,sha256=4m9Fy1WhPy3wNTRmRS7PCp2yHUEN2talXlJXvu-8kZk,1588 +torch/include/ATen/ops/einsum.h,sha256=GzvxeAQ5TKboaxwFMw0YHL-q5CRv8hTMImyI85iwkVU,753 +torch/include/ATen/ops/einsum_compositeimplicitautograd_dispatch.h,sha256=hucK0ab1nsQQBY2GcdF81yiW_K75Mt_RzC12vMHDd58,833 +torch/include/ATen/ops/einsum_native.h,sha256=kKPRKr-v2uK4Ie4HH0HE0U-GwIaH45vyCgq7MSM0ryw,556 +torch/include/ATen/ops/einsum_ops.h,sha256=JMHliVu9Pa6JRbdHnl_DhB6LgbF8l1UMQxOxmJZMRVs,1158 +torch/include/ATen/ops/elu.h,sha256=fRKWVT2PpUMonqJEnpiMjdmedkOea2a63w1VV9pLuSU,1796 +torch/include/ATen/ops/elu_backward.h,sha256=7J_sHaY7TpCRgElq-j5ULpIF_-QTy5fsNYHgwqAjS84,2036 +torch/include/ATen/ops/elu_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=qlCwY_IF0NLw-2QiE0jNvaoCpd26zZVloEMivjNBIZM,938 +torch/include/ATen/ops/elu_backward_cpu_dispatch.h,sha256=6oHWY1Wd3wCF7Qx-uJWFii0PBI5jgqRvVJ0mjgiQwnQ,1335 +torch/include/ATen/ops/elu_backward_cuda_dispatch.h,sha256=fdyXrsKqOmCUyGCynwJB6d4_L_c-d-d6VVSJIKHpi-I,1337 +torch/include/ATen/ops/elu_backward_meta.h,sha256=b3AuQ7jh9zd6EyyjjQT7BV3DLqv6CVDvGfFMDwHwZfg,734 +torch/include/ATen/ops/elu_backward_meta_dispatch.h,sha256=aBlORlbO3W34dcLIfKr813uBE6GBuldwHwh28Ry-2N0,1337 +torch/include/ATen/ops/elu_backward_native.h,sha256=uZS4uwoPgEMLTc7KKrAuDliFMbvOvA93CX7J6JERaRg,774 +torch/include/ATen/ops/elu_backward_ops.h,sha256=zX5DWE4G9aQiAX18ZwWC6dKNWHjGQLOuOpX0gN0_r48,2596 +torch/include/ATen/ops/elu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=h59xyTdy10hFVr9wqnuWFXy1RDVR5VG3mIUD1lDUzB8,1015 +torch/include/ATen/ops/elu_cpu_dispatch.h,sha256=MQ8vMkSuDHX55lAxNnE8GxsxQdYPu8IcXX_quyvHxRs,1270 +torch/include/ATen/ops/elu_cuda_dispatch.h,sha256=c65G_16MwTnsFIaTU3okr2z3a9D0i1a5jL3U43FHPmY,1272 +torch/include/ATen/ops/elu_meta.h,sha256=OGglh6nYU27YQctuuEVnSDQsxiNmHZsnHQQ5KBY7QFs,667 +torch/include/ATen/ops/elu_meta_dispatch.h,sha256=xRS9WTykrUufIbwrl9jW_EFxnQWvpVqdDpIOjNcLFek,1272 +torch/include/ATen/ops/elu_native.h,sha256=Yjsvox0DAq8d2SpuqtmjpTIW4-fhwf-bMzo1ZMKwpWg,682 +torch/include/ATen/ops/elu_ops.h,sha256=HRrvTP5tiN_Pb1tKku0NO1xbLcD0W2hR2Oip3f99k7c,2941 +torch/include/ATen/ops/embedding.h,sha256=pE5jrMHn2tTeFSnHJ9kpQ-YLV0hM2eShX0HgupzMCBk,5378 +torch/include/ATen/ops/embedding_backward.h,sha256=xoM3m72ARBZPvLRof4h-dCN-SH8Qm7f3o4FZSPXZa4Y,2189 +torch/include/ATen/ops/embedding_backward_compositeimplicitautograd_dispatch.h,sha256=5J0XifO3Bq1LhMsYc9b4M2PZNufoKk-ufaJlbRo3XBs,1073 +torch/include/ATen/ops/embedding_backward_native.h,sha256=zWrt7eb5i5O9y_XCjOJpxmlV3DWxNW2aD38kbBmmxVg,622 +torch/include/ATen/ops/embedding_backward_ops.h,sha256=g80RywFuN75gTB_QMR8erO2OH39-dnsiEIZs-y21Cl4,1387 +torch/include/ATen/ops/embedding_bag.h,sha256=KZ2eiX-ELF871cwwGhKLF7PPS1Ct-ojvhIo7TpqAkpA,1936 +torch/include/ATen/ops/embedding_bag_compositeimplicitautograd_dispatch.h,sha256=bAreZHYNMU2-pqrtMt_yzNVqBYZptqfsEln0UUC8mbY,1365 +torch/include/ATen/ops/embedding_bag_native.h,sha256=N7-TYMqvTTeLz_1GVVOy6G8dA73W32C_jvZhck3RJcg,1088 +torch/include/ATen/ops/embedding_bag_ops.h,sha256=2fTYKwo2YBRR4nQngynwsWspvV3kM2BL-9utUO_iH9c,3286 +torch/include/ATen/ops/embedding_compositeexplicitautograd_dispatch.h,sha256=8eczPbmzXRyTbrpuGcqT8-kLZzcRab0-ufAGe8L3x0w,1777 +torch/include/ATen/ops/embedding_dense_backward.h,sha256=JSkpNTC999i5IlfNWDtwFFS0ABc1b7Yj1k_BMapVr0c,6005 +torch/include/ATen/ops/embedding_dense_backward_compositeexplicitautograd_dispatch.h,sha256=tq6A9LTD0Kiig8wrCh9tiiSnGPH7J1sYViaDC3p5x4c,1534 +torch/include/ATen/ops/embedding_dense_backward_cpu_dispatch.h,sha256=xflS-vDS_njA_ikBB6utdaTMEEwrXs9kkv3wQnXhRRQ,1029 +torch/include/ATen/ops/embedding_dense_backward_cuda_dispatch.h,sha256=FequpJMa_WaOnF_1PX5qQN4trbOiwDBe_ZqoDndUMQk,1031 +torch/include/ATen/ops/embedding_dense_backward_native.h,sha256=VByjOGjDYb9pBbhX3wxxMRtlHSm6bpLh7kkKRzV6Z6U,1003 +torch/include/ATen/ops/embedding_dense_backward_ops.h,sha256=Tk8MVUeGvXvA2C-W-CS2YBqKm4xwu-UsnoEeeVq0RbU,2418 +torch/include/ATen/ops/embedding_native.h,sha256=woXeblgfaF5EfNwu6Btz7c2y-YkxbgUrZoNggt2d7zI,960 +torch/include/ATen/ops/embedding_ops.h,sha256=nk3ngB_010_nHCBKokhUvjfP8TWgiV-thp_AviE_g0I,2252 +torch/include/ATen/ops/embedding_renorm.h,sha256=ciRbNyGI0CFrwPZPTL1zbf5qsO-xczvskFqp_FVqgW8,1855 +torch/include/ATen/ops/embedding_renorm_compositeexplicitautograd_dispatch.h,sha256=Hk99z9_8zaNCvQpsJA4at3iwE8dSNruNPzMbJ_IRy9Q,1140 +torch/include/ATen/ops/embedding_renorm_cpu_dispatch.h,sha256=T1QIHLFDW8ngs9ywm8fFp1JHzZE_GzlBZfHc-JDjmKo,790 +torch/include/ATen/ops/embedding_renorm_cuda_dispatch.h,sha256=9hv7EzsAbrhN9UKfbqdPAzJ4yHqyoWndeDVBQuEM8bs,792 +torch/include/ATen/ops/embedding_renorm_meta_dispatch.h,sha256=YxzMsc1SvfuUmiH9JV6tZS1tgWYJ-yzPloNfM10S9pE,792 +torch/include/ATen/ops/embedding_renorm_native.h,sha256=t_CA5XsM2kIZ49akWt9h7HAFwwyQRJpzzX--s3o9e_o,968 +torch/include/ATen/ops/embedding_renorm_ops.h,sha256=VSABSWqnupL1SrtQgmKXiMdz5hBSyyKf_BsczniT9ZY,2845 +torch/include/ATen/ops/embedding_sparse_backward.h,sha256=dVFxyqYIReHPyvWryxsssFVaT0IGI4Vg9QSEDJtIvZI,926 +torch/include/ATen/ops/embedding_sparse_backward_compositeimplicitautograd_dispatch.h,sha256=59UmBtuADhejdZEqMfc59TUmjy3d00WJ9AWdpNms-p0,878 +torch/include/ATen/ops/embedding_sparse_backward_native.h,sha256=vAN0SPS0Fw3fmza7H4s1fkyTHbE-2TutShH5c9w-7pY,601 +torch/include/ATen/ops/embedding_sparse_backward_ops.h,sha256=Oe5gVl43EkLIOeFKS1OQeWvrrj2dAQDLlL483Hxj51A,1333 +torch/include/ATen/ops/empty.h,sha256=r6RSbKyZeZEG4LJzVNCJwDNOv3x1-TzOQtkK3q0dwM0,9148 +torch/include/ATen/ops/empty_compositeexplicitautograd_dispatch.h,sha256=Qe4KEQ0_XspqwFTAUIZP692TCsYRJ1D3GJze00vxklY,1492 +torch/include/ATen/ops/empty_compositeimplicitautograd_dispatch.h,sha256=d51XQ3FxktMfQtQKaTjkV0xvtzGesKXvWn7EXEadVTs,1244 +torch/include/ATen/ops/empty_cpu_dispatch.h,sha256=ggP_9TKtQqVuUa6nbKptbcTz2j0tRYZmnUI-0skSrV0,1436 +torch/include/ATen/ops/empty_cuda_dispatch.h,sha256=kD8ExKT8y5wXckBI5cQ5sRkfSEspzwl3Y3PIxY-p6ZM,1438 +torch/include/ATen/ops/empty_like.h,sha256=CFu-6TXxAtg97AU7-168a2mC5dX76R6P2GBRJNHHHjk,2189 +torch/include/ATen/ops/empty_like_compositeexplicitautograd_dispatch.h,sha256=tBUHAI-73PmhZeQB52MA0aNmjDY453ZNQ5sN6gyU2Fk,1372 +torch/include/ATen/ops/empty_like_native.h,sha256=0d5Ingv6Nq8zGHWtMp3Vutml8AF1rzMc7QG2rsOxXss,1936 +torch/include/ATen/ops/empty_like_ops.h,sha256=rInU8JwqmUO99VrYCLopVTPKHrz6z0U1T3fdaIk3fhE,2408 +torch/include/ATen/ops/empty_meta_dispatch.h,sha256=_RwE-yQjUwF7Kh6S9HnmwVdRec2U0Zy0n_mGSyq80FU,1438 +torch/include/ATen/ops/empty_native.h,sha256=yEgIZkcIX6UxO6QUpo63tWkUEEXMACTPuneSe-JMkxI,2910 +torch/include/ATen/ops/empty_ops.h,sha256=gAlD-LHMfpN5Y_V129FzUNosNgb-_d2a0Xc1ZXzlAXU,4640 +torch/include/ATen/ops/empty_permuted.h,sha256=NIvzGhDXUzaPt5FYBdULq4Qhw62JrccaAPNf-zshf_8,6774 +torch/include/ATen/ops/empty_permuted_compositeexplicitautograd_dispatch.h,sha256=2aflpp_5PYUWf8TbBO0kGWWkr92o2dgy74bRd0O1zmM,1922 +torch/include/ATen/ops/empty_permuted_native.h,sha256=c7RNmqVDcLKRpiiiRmz2VCarxBE-bZM35V8dOehR8kc,812 +torch/include/ATen/ops/empty_permuted_ops.h,sha256=68aNtByJJHbPh8WreHwv2VZEhwcOgxvRy13b0ncLJ4s,2332 +torch/include/ATen/ops/empty_quantized.h,sha256=NNDCVPVvLRU3EoEMCmEvVnYjJiuegGbVOVgOPFTLlwE,2450 +torch/include/ATen/ops/empty_quantized_compositeexplicitautograd_dispatch.h,sha256=I76ZutC4dfB3dneKXn611nZg8CoFvP62XWKazf_H1jo,1042 +torch/include/ATen/ops/empty_quantized_native.h,sha256=71TQUY6eFJFHx4NIWfC5tPvxzsel-A8VO-cFQKPTEQA,889 +torch/include/ATen/ops/empty_quantized_ops.h,sha256=6BXYwhzUybYVhtUiiEEJ_e6gRA-AvVHmGkUPWFZYatI,2602 +torch/include/ATen/ops/empty_strided.h,sha256=06FGW6y9nzB8z2rubDrMJFP7zNJFuA0y9ubDLkd_trM,6637 +torch/include/ATen/ops/empty_strided_compositeexplicitautograd_dispatch.h,sha256=9Yx0W23lS5yaKrujxuaO8x3yQMEwplxPJfvN3GAtPTA,1166 +torch/include/ATen/ops/empty_strided_cpu_dispatch.h,sha256=dPUK5jv0LHFkG9yVT4z0-vlgeCBjx07w0Fwr45ti-3Y,1358 +torch/include/ATen/ops/empty_strided_cuda_dispatch.h,sha256=mgIOakp3k6cJjXfsMnOHRahPRJ7XKUl3dv1gujLAOqo,1360 +torch/include/ATen/ops/empty_strided_meta_dispatch.h,sha256=ZxiLnfxexF863QGJsfgRrqRAhBVSCSUgyl0EqeIz9Qw,1360 +torch/include/ATen/ops/empty_strided_native.h,sha256=8VuJ1km6-sFXzmcJS4nsrvP55RPbpAdDMMaMHz-OXow,1525 +torch/include/ATen/ops/empty_strided_ops.h,sha256=Qs5ZQ0Yybhs9jNT-phyRTm4SZLGXESqCDq2pTUECJgk,2302 +torch/include/ATen/ops/eq.h,sha256=GXMZ0K-27vGhDJF2CMD5DeCJ6d3PacynjUwCneroRok,1830 +torch/include/ATen/ops/eq_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KBRnPMNuCIKfzjhAwMFIMu8zPyTBUJclRyW5rJ4s3pM,1034 +torch/include/ATen/ops/eq_cpu_dispatch.h,sha256=dX1UerPELGPV4lzsajFq2BNzJ4U8rteB_iNG6pY9MJI,1366 +torch/include/ATen/ops/eq_cuda_dispatch.h,sha256=D5TAunT-rKbYZugffS42_hxtzXbOG7-6TYZN8kob5fI,1368 +torch/include/ATen/ops/eq_meta.h,sha256=Eoyo6lqd8ozWwRdKvY5GLwnDf8elrWd_2MxGXw5U180,762 +torch/include/ATen/ops/eq_meta_dispatch.h,sha256=LB_A-cJJ9BdJ6XbKFiU-riS2O7XDrXM5M1AL9AU340k,1368 +torch/include/ATen/ops/eq_native.h,sha256=fB8k90lHCqZGXqHKyl_vmqk_Mb2UDnXavC0-Pof28M4,1306 +torch/include/ATen/ops/eq_ops.h,sha256=UzpohP8DOI_2J4dBJr9FFTRAGw_1N4UXPr5T6TUhJhM,4376 +torch/include/ATen/ops/equal.h,sha256=gxTQVVh7tU4VR6Uud2toHWXFycBiodu6u2NEv12YYdI,660 +torch/include/ATen/ops/equal_cpu_dispatch.h,sha256=j5YI9YxgBAETewaOudtFJrDBjlWTdCdgu5JbKAuO3G4,739 +torch/include/ATen/ops/equal_cuda_dispatch.h,sha256=mchBRbi709Z6951APBwwJTDKDAvKDG1mstukVN301iQ,741 +torch/include/ATen/ops/equal_native.h,sha256=ISVLA6uAl7VLBjRX72Yc0VnsV-UJv3LljSg8pFKvYR8,675 +torch/include/ATen/ops/equal_ops.h,sha256=lMNnRNS62M-XQ-fSn30z2OQ1pte6JM3VZLXVqVK2mlc,1030 +torch/include/ATen/ops/erf.h,sha256=-v5urK-s1xGdjdufyLNFOn32pxVPbPSaEEEqSPJRJSA,1118 +torch/include/ATen/ops/erf_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wGh8OQNFw08ICErp-Tc3_W_brhkUYUmKJuLpARD357g,835 +torch/include/ATen/ops/erf_cpu_dispatch.h,sha256=AvAjSKKI1QA5n9miS9De5mCT6BjVMIxeImwH-wHWf-k,916 +torch/include/ATen/ops/erf_cuda_dispatch.h,sha256=GWFJ8FLIUo8rGp7_yO_BRyqAuw76g_VYO_uw50s8OoY,918 +torch/include/ATen/ops/erf_meta.h,sha256=zYB6_L9Bs8BwZG_AkeUlFmaVYX-aF_eYiiCHJr7OgFA,583 +torch/include/ATen/ops/erf_meta_dispatch.h,sha256=-R-SQRDApQ2COAqEA-W7zlEGrIZ1SBlzcQTi82sChNs,918 +torch/include/ATen/ops/erf_native.h,sha256=DyyHjqt7-2cMFAQmtz7uVSEQxiECCmKCmT_guGeaqrs,1000 +torch/include/ATen/ops/erf_ops.h,sha256=hG_7-iUbRkngBasOzzP55Yd6z-QGkMlNDGSRTXOf2Gw,2095 +torch/include/ATen/ops/erfc.h,sha256=3JNjXsxtIOImRn0c8FGKLBAIVqO0JzGh-Znf1VvRvAI,1131 +torch/include/ATen/ops/erfc_compositeexplicitautogradnonfunctional_dispatch.h,sha256=q-k3nbIGUOcOnj5MsWXChdnTMBhn8-5kB8sd5Fb8xas,837 +torch/include/ATen/ops/erfc_cpu_dispatch.h,sha256=hEQv9d-XZkOz2G1sh8F3jnvjT6YJzyq3vw7tDttSjbg,920 +torch/include/ATen/ops/erfc_cuda_dispatch.h,sha256=d72OS5rCSKyaC6Xu_CqyaFFb8tHLu4Qex1YSUW1GpOA,922 +torch/include/ATen/ops/erfc_meta.h,sha256=Ba__FiLoyW3ayjrs2fACPzlrGgkFl5z5ZYvavG1jXig,584 +torch/include/ATen/ops/erfc_meta_dispatch.h,sha256=CJYQDuJ3y2tvJcXtA7MiRjhxM_3TVPmnVuAwc4swutU,922 +torch/include/ATen/ops/erfc_native.h,sha256=TBtbKKXNz4ltpxOFvOVyiKUyRo73nTTyOGwzdZ9rcSw,601 +torch/include/ATen/ops/erfc_ops.h,sha256=H_aU8tbgl7X3vvL39uUdkycnlbpxOs74d5nJbdz8VHM,2104 +torch/include/ATen/ops/erfinv.h,sha256=2WYxHW8YUd4GMTsb78GSvA-Kc_uuiq6npGINrk50LoU,1015 +torch/include/ATen/ops/erfinv_compositeexplicitautogradnonfunctional_dispatch.h,sha256=fUne7QfatltqmYEf3TRh9rhA6Y-RciRnVYL_GASFiC0,841 +torch/include/ATen/ops/erfinv_cpu_dispatch.h,sha256=Ztz4EPsFCKaHv5JTq-fV5OlxVqC2is5dhPrd09k8w7s,928 +torch/include/ATen/ops/erfinv_cuda_dispatch.h,sha256=aY594X9BP_pSYTU5pf-ZV_YpZmtCLig4Ez01-xQZ3R0,930 +torch/include/ATen/ops/erfinv_meta.h,sha256=yGbCSaxzSZbw4aRBXOm0EN-5cC5FxiAuTZrqaRkfHNY,586 +torch/include/ATen/ops/erfinv_meta_dispatch.h,sha256=IB6PXMBYIu_ZPlpUpHwJ0gtZR5cN03-SrfZ9lIdi-ac,930 +torch/include/ATen/ops/erfinv_native.h,sha256=aTcNwr2ESmKu1eFY-24tH3ux7E7HWbY-HbDxHOObNqY,1027 +torch/include/ATen/ops/erfinv_ops.h,sha256=Ofu5H07WDV1OSEwjgQ19PvqiT7o-Ifc4DzjoK2ceUqo,2122 +torch/include/ATen/ops/exp.h,sha256=l-ovHsjFXBfPzjMPcfjqoqx9_kYtsR9_7J0qpGAGQlA,1118 +torch/include/ATen/ops/exp2.h,sha256=VoewfhHs8MGUpH_-wILQWIn1_BuqTFzce_deZ6Mp6_4,1131 +torch/include/ATen/ops/exp2_compositeexplicitautogradnonfunctional_dispatch.h,sha256=0sDVcNT2fsPkoBdF7c2SLkRb8Qu5BC_ZhTYVXCxFTqM,837 +torch/include/ATen/ops/exp2_cpu_dispatch.h,sha256=ChHI9xli18UWhLndDAE-VrZtlBDl609msXhfsomnRT4,920 +torch/include/ATen/ops/exp2_cuda_dispatch.h,sha256=kHFfupmTIOQ3oT8rn6NcF0aEI8wbGtGBjX9Tk-maJ7M,922 +torch/include/ATen/ops/exp2_meta.h,sha256=8YyXwp2iUe9gkIsUdck50UDuVrPrmrRQJmIX86bhGFs,584 +torch/include/ATen/ops/exp2_meta_dispatch.h,sha256=wu8riUDi1xrg5kTk0hr_0c65UIbBLYFFwaJhTSr_fS8,922 +torch/include/ATen/ops/exp2_native.h,sha256=RihrUrh1UZVnNvqeu7ktLnEiEwMK-J62nDVaMXchSGM,601 +torch/include/ATen/ops/exp2_ops.h,sha256=chG265Me1u53Y4PQtdQS20Qes-UlaItIbdrw-NRIuJc,2104 +torch/include/ATen/ops/exp_compositeexplicitautogradnonfunctional_dispatch.h,sha256=2rqohVS0dE2UKHaFzeWd2kxoZGugi7StrreNa1F_gFE,835 +torch/include/ATen/ops/exp_cpu_dispatch.h,sha256=2lTOIfH7qlYfKCswj8TQo6jF6baWXRvXXOSZW6-qs78,916 +torch/include/ATen/ops/exp_cuda_dispatch.h,sha256=MY8adYFNWWvvAhwbmDuDMoWissmDQ7GMZDZTh8zwR0g,918 +torch/include/ATen/ops/exp_meta.h,sha256=cyrFTah7uEcSGmzQpvccxlMoucXhMbp8tYKoMhGnkZw,583 +torch/include/ATen/ops/exp_meta_dispatch.h,sha256=faByptHQZXch-YyobWHQDNAEq9PVfcLYmtDs8XX8jRg,918 +torch/include/ATen/ops/exp_native.h,sha256=GxtYIEj7_1_FNRtQVr4xQTpg3CzquqZkTOi30G8BHVc,598 +torch/include/ATen/ops/exp_ops.h,sha256=bpDlyVLIS-pAUxgcsDdFvSQc016KvaAWVxrcDCRfgxw,2095 +torch/include/ATen/ops/expand.h,sha256=2TBPBfG4Z2vHsVOb5rL-e1yJzKtg_kYxo1SXJ6rs6-Y,1042 +torch/include/ATen/ops/expand_as.h,sha256=StHIIPoOSOe-S9Jbical6kjeET1-akE1AtbNzb9zaDk,494 +torch/include/ATen/ops/expand_as_compositeimplicitautograd_dispatch.h,sha256=cVEtvoJtb283EXs5fSIIfIxBIVYJDQd4ARPpCCyRD0g,793 +torch/include/ATen/ops/expand_as_native.h,sha256=n7E9OHCt0RCEJs7G1wMk2Iiv9q_FxuMfiYf8sL_g2y4,516 +torch/include/ATen/ops/expand_as_ops.h,sha256=jQf0ptthpog-W75Ji874b89x9haQZ8a3wYPvEAwMcr0,1068 +torch/include/ATen/ops/expand_compositeexplicitautograd_dispatch.h,sha256=Qx0mu67trWhHgomTJ65zvGfIkyWratnKpZ8cCcS0Rhw,915 +torch/include/ATen/ops/expand_copy.h,sha256=ZouophU-hhCs9DDceXXzDrjnoon0N7isB2TR1Qd1SO0,4144 +torch/include/ATen/ops/expand_copy_compositeexplicitautograd_dispatch.h,sha256=PxfPj2yE_V2uwySAAggHjWBcQW_hqe2TA8zoYhgz52g,1226 +torch/include/ATen/ops/expand_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=roKXKPuF_RUB9Xj9pbeHE-qMCfmwbEU5uds7m8CcJvQ,951 +torch/include/ATen/ops/expand_copy_native.h,sha256=DU-JMLG0MPdzswgUvvM6nkOPVzSrj-d8f9b0t6jV93E,677 +torch/include/ATen/ops/expand_copy_ops.h,sha256=nPiobJsUk88sSzgGdi0m2JTJDtXLJQtKpl3CIZFg0_4,1913 +torch/include/ATen/ops/expand_native.h,sha256=ubJrYLdQoQEfdzx3OMQxNCrPjH6_ObyUgWCT0imeL1A,530 +torch/include/ATen/ops/expand_ops.h,sha256=M9vN1aIeE8ggWslW2t-YLroxHdVs0-Aph6_srwAR2ZU,1121 +torch/include/ATen/ops/expm1.h,sha256=zMJOjqbzCUNoX0A2P0RuU6NRGqLFPqC79nRNtJp_54k,1144 +torch/include/ATen/ops/expm1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=vYezwxrqAV3EN_qhHxw729lZtQzbNnM3w8ieEuCtH9I,839 +torch/include/ATen/ops/expm1_cpu_dispatch.h,sha256=W0rNlEV4hw3jspSM4-TYpygYaW6JrTwYtG2KuHd0RCU,924 +torch/include/ATen/ops/expm1_cuda_dispatch.h,sha256=kgOBS_KiKvv-5_DCd6iN2G8JXMvGnoEnK8WyzCL7v6E,926 +torch/include/ATen/ops/expm1_meta.h,sha256=7KbLWjevvtyHhkVigBZd9o0Ap1J91gT7dEorI-n0UTY,585 +torch/include/ATen/ops/expm1_meta_dispatch.h,sha256=8ssRg75TMNvGC5FTliSsbT4bmgqr6DAgNPS_hktXrvA,926 +torch/include/ATen/ops/expm1_native.h,sha256=b-MWnxwaXxPRzKA12MxR-MYJgti0T0JmgxF5Io0uTWI,1018 +torch/include/ATen/ops/expm1_ops.h,sha256=o6sHPgbwIL4YyBHT_qMiZrY36ClGHy2qYQQRcWldKhw,2113 +torch/include/ATen/ops/exponential.h,sha256=rG1OXfHklnAXvpO1o32L-PUV-qtyVAPQ-jB9wsu2kCc,1440 +torch/include/ATen/ops/exponential_compositeexplicitautograd_dispatch.h,sha256=_RzACMCxsp04CM_1C9EmTdxUpYz_jGPBOvKy8FyRbgs,1128 +torch/include/ATen/ops/exponential_cpu_dispatch.h,sha256=AchFoRsH16aSFN-nCQFuAGpJvBzmzSNRX67hEYcZLfI,791 +torch/include/ATen/ops/exponential_cuda_dispatch.h,sha256=ID6yuvANBIhUhju-1SgLPOjeA6RuqxcDxnQI4hEsm80,793 +torch/include/ATen/ops/exponential_meta_dispatch.h,sha256=eCceT3BsYvwAbsPBmCLyCl3-NrM7eQJt4WE5zZmK2Lk,793 +torch/include/ATen/ops/exponential_native.h,sha256=xzuZXYZ25EvDmlFSaSA53wQaSW0YaeAdPr7POYbkZ0k,823 +torch/include/ATen/ops/exponential_ops.h,sha256=WivjCuSAPd-dKfViPvGdIi0eY4oiUl_JyJ0JCcVhLTo,2737 +torch/include/ATen/ops/eye.h,sha256=E6MuHaP9EMNbkg2EdvPrMClNh8cvrKgBBvlsS7J1XV4,9631 +torch/include/ATen/ops/eye_compositeexplicitautograd_dispatch.h,sha256=ycldTMxRm6i2qdSza8XKp-ZzvCU7C26U4tdAjtDHq9Q,1770 +torch/include/ATen/ops/eye_cpu_dispatch.h,sha256=WagdK81J4dFGus7FCwq8mk04QHk4watkX2B9KfU4hqw,1254 +torch/include/ATen/ops/eye_cuda_dispatch.h,sha256=fZMjlfp0iFk0bev_thUZx7p9nIENKSuCGO7OzIAGrIM,1256 +torch/include/ATen/ops/eye_meta_dispatch.h,sha256=2LSooSb0RwLAP5uJzCUe_hzKr4ptVi2_XpxzNpCGW70,1256 +torch/include/ATen/ops/eye_native.h,sha256=OhHYytb0r8HoqyDLTFHW56EIwkfmLlP3SekAZ48Cr4E,1100 +torch/include/ATen/ops/eye_ops.h,sha256=BsvfiLzNJzdND-CzEFKzY3adH6qkJdORDm7C2ZaLlDM,3651 +torch/include/ATen/ops/fake_quantize_per_channel_affine.h,sha256=RXa2aLV79HIhH7LJkCFw9dF43F-kzm0sh--OsRac_Kg,958 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask.h,sha256=hAJzgTe7pce9LK7mropUtUi2R-LwllNvgoiMR3txlfM,2281 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_backward.h,sha256=C7VFGQessePfJyogNs5itxbOy8YL9OEUbK3KDbQM3fI,849 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_compositeimplicitautograd_dispatch.h,sha256=JxMXUPjuACR5mmp7VN-Pg2NUmBPWCSm0EWJXrs54vto,834 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_native.h,sha256=ZCOR-66nmxiWxVZm_gPZP47Cu3Dk-jRpjAh3duQCeMc,557 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_ops.h,sha256=0aXSZbw3wAQei4McrkoopnK2zRSOtD9Dq_Tjs17yHbk,1185 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_compositeexplicitautograd_dispatch.h,sha256=ZXMSU5pKcylMlfjAWD6neNwsbZbPKao2K5mEvx4dT5Y,1251 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_cpu_dispatch.h,sha256=jVtpXecxXCFm47C-QGx8SZzCHyLdGaL4PQ4NJwMTQts,890 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_cuda_dispatch.h,sha256=W5X4cgVJWmhcpTyyqsP3cV7X1A7mYOgucyrfRbYUrp8,892 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_native.h,sha256=oT-ZKFLMVtYp3IxUziVTc6X3VX7KE8ueCmFX3hGz6dw,927 +torch/include/ATen/ops/fake_quantize_per_channel_affine_cachemask_ops.h,sha256=yyunkmqPmbwXn9X0fBj2b7N1ic3WUS8M4G128SrUx7E,2786 +torch/include/ATen/ops/fake_quantize_per_channel_affine_compositeimplicitautograd_dispatch.h,sha256=NoDLgqodKweiKMwy428J_3MP4RoT5_zWod6iKVHWsKw,899 +torch/include/ATen/ops/fake_quantize_per_channel_affine_native.h,sha256=HJbOlOs1YZhCwz0XsjSyfpJv7TS1gpnM--ncn2pGaV0,622 +torch/include/ATen/ops/fake_quantize_per_channel_affine_ops.h,sha256=DMPgArn-qJXFboMEtAxekBg16XPeUmR6XsgY7h39GZk,1403 +torch/include/ATen/ops/fake_quantize_per_tensor_affine.h,sha256=V24sC7BWYBjMWVX7bRd9SDKhtslA-XOnDj9cLruofoE,1336 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask.h,sha256=qaz_DC1Pyg8ySUVODuHWWvFqQb121NQTcqGPUKQInUk,2100 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward.h,sha256=Z_Oe6BdgoxIdigDKZ9T66ItnfQhFkyxuABJNC9cXfhQ,845 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_compositeimplicitautograd_dispatch.h,sha256=kgv_kAu6UywN6olqJdChDagPCRRJwjtGMoox6s5AOaA,833 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_native.h,sha256=eQgQOZ19_5vbSDhwqZxJKa6GHLqplgf5hpbkUn2fa9k,556 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_ops.h,sha256=yp2Ddw1xVKxOAHWP2GdhALcWKN3g08IUFlKV1GeEja4,1182 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_compositeexplicitautograd_dispatch.h,sha256=fbadkfIeu7cPKJZ13oVqbDSuZvJn07TygRegim86hRk,1175 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_cpu_dispatch.h,sha256=5_zbe8f0icL81e3zCyenXS5uFjQz8qjbIkFWONtP3dM,852 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_cuda_dispatch.h,sha256=zHXqY_YUz1Qz-NKDPDRfJr5bqx0SwSQ2AuNHcjG1il0,854 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_native.h,sha256=V59n0onJRbuFLh7sq0GftT0eFbKbcOymhLE6XQIRiso,851 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_ops.h,sha256=lWz7yiH2wKg1m4bpqIOqPK8p_pulENAZCfpehrIg3xM,2540 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_compositeimplicitautograd_dispatch.h,sha256=CuUbT204hgwVISgRbz0QceEE_pkHUyBMx8mblUoNBdc,1035 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_native.h,sha256=oYfewc82Vp01Wbm9seNTGXUE31mUhHJyMI1S3zbTx2A,758 +torch/include/ATen/ops/fake_quantize_per_tensor_affine_ops.h,sha256=kxRTM4PR8-lOoucnFvu4-w1XzNnFZoYqxd43rPk7kCw,2243 +torch/include/ATen/ops/fbgemm_linear_fp16_weight.h,sha256=14dlQP08ENGtbZbSMGguYInu6Frk-prTvy2u8G0Tgj4,819 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_compositeimplicitautograd_dispatch.h,sha256=2TIc3R-T-6XY5prv9HM0Xk_v0DnkOs72lpAipZPTMIg,843 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_fp32_activation.h,sha256=Edp5duERDy8_hyG__5VBEP3mVSFn48zJVyU28prgfw4,883 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_compositeimplicitautograd_dispatch.h,sha256=mTUsi4muu5y4oUza740uug5WYOpl3_9TAzZaC4rxWeY,859 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_native.h,sha256=peC96q4HAAtb209Gum5celCZbbp4COUfWNC5YdMdcaA,582 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_ops.h,sha256=3G0KdbtxwYSZgkKsRajf-jglH0GtHF4gPk3OGCBAeGY,1268 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_native.h,sha256=l6G7-5B37teFIt9xveq9Tz449iQpg06X9a4f6CdKl-0,566 +torch/include/ATen/ops/fbgemm_linear_fp16_weight_ops.h,sha256=MGQSTQ6sKt9auskl4TaLD4yh5r6OOVSau90Eg3egLvU,1220 +torch/include/ATen/ops/fbgemm_linear_int8_weight.h,sha256=37cZVvhmZuH5V58FYbyDK9Ato7XWpP9TeznAvZzN-wI,1064 +torch/include/ATen/ops/fbgemm_linear_int8_weight_compositeimplicitautograd_dispatch.h,sha256=VOF4hdnMmoQ5V3QOUBKW6kwK4jRD5YsTtIBkS8WsKnM,966 +torch/include/ATen/ops/fbgemm_linear_int8_weight_fp32_activation.h,sha256=3tuDijysDX0XY4QBUc4jgzpaxpcitSD6Wt6sd6nXWiI,1128 +torch/include/ATen/ops/fbgemm_linear_int8_weight_fp32_activation_compositeimplicitautograd_dispatch.h,sha256=B32qVHSu0izolZAH83PYBxnLvJbCQquD-fdfj8E2c54,982 +torch/include/ATen/ops/fbgemm_linear_int8_weight_fp32_activation_native.h,sha256=71ctAKNuloIdDS-Ffw8r9o9h2W0cIp8xhMUnFJhdtog,705 +torch/include/ATen/ops/fbgemm_linear_int8_weight_fp32_activation_ops.h,sha256=a-l3MvA_fMwqrWDQoHDQ6P0ZvxT4357JH2MioADLmKU,1669 +torch/include/ATen/ops/fbgemm_linear_int8_weight_native.h,sha256=I7houFIX9u-VLsNQY6oAPnxDQyGNBeVK5S5R126Jb5I,689 +torch/include/ATen/ops/fbgemm_linear_int8_weight_ops.h,sha256=zCDFZuL84AOzD2C5Q37s7FPo83WjMTagxxbnVvwk49M,1621 +torch/include/ATen/ops/fbgemm_linear_quantize_weight.h,sha256=4klMa2qVFnwaoajSuC-8yLcWQ2Mn8Jsckqat-KmNlAo,782 +torch/include/ATen/ops/fbgemm_linear_quantize_weight_compositeimplicitautograd_dispatch.h,sha256=0Zti5W1-T7nBUKrbxj2ACecAUbif0Mi1P616rTHAOBQ,828 +torch/include/ATen/ops/fbgemm_linear_quantize_weight_native.h,sha256=3oHpnaXw6v7UHr41Sxb9uCwzrK3GO77SZ5UlsQIj34M,551 +torch/include/ATen/ops/fbgemm_linear_quantize_weight_ops.h,sha256=zUFZFDx07sjQE5edAZy-76tm-3Yx1r0nlEkrXB-yGiI,1181 +torch/include/ATen/ops/fbgemm_pack_gemm_matrix_fp16.h,sha256=BhVq3grIJlpLiQyml1zrOlAwevCVAr-caZ9N6ulDkC8,716 +torch/include/ATen/ops/fbgemm_pack_gemm_matrix_fp16_compositeimplicitautograd_dispatch.h,sha256=Ih5X5QkgaWjElwIZOm_kTdPRVdIJNO_zgwdUCBUd0xA,787 +torch/include/ATen/ops/fbgemm_pack_gemm_matrix_fp16_native.h,sha256=CWKdmQdT4ggaR_d48oKKr4J0sKVCU8N8Q4Kkx2VhZVs,510 +torch/include/ATen/ops/fbgemm_pack_gemm_matrix_fp16_ops.h,sha256=uHnTxyEhzUQVN4gGzbZ9nxHKsc18qxmYip8orHYMtqw,1036 +torch/include/ATen/ops/fbgemm_pack_quantized_matrix.h,sha256=MuVcCO8tqS_s6nk7dhq-Z62I5Ri-IRE3UWSQfOSOWpM,968 +torch/include/ATen/ops/fbgemm_pack_quantized_matrix_compositeimplicitautograd_dispatch.h,sha256=5xbXNBNxNtd1wLmRxo1hwUOVwifhP5jCi7uPgLKYLr8,886 +torch/include/ATen/ops/fbgemm_pack_quantized_matrix_native.h,sha256=0RGUI92pUSbZOhCVsYnngywU1wMy3N0tCvBj8mNJu98,609 +torch/include/ATen/ops/fbgemm_pack_quantized_matrix_ops.h,sha256=LUypTsc9n3vyzyOqA_tj11BKFt-IET73UOVT17GfHck,1722 +torch/include/ATen/ops/feature_alpha_dropout.h,sha256=hC7uqZtaBfEBn02mCfEs1YZPjuEpOo6RaeQgHD6286s,981 +torch/include/ATen/ops/feature_alpha_dropout_compositeimplicitautograd_dispatch.h,sha256=Zh7Rcis7WPpgQySTDIHQCCX1AwNskH1EmBmvLhLYMQo,890 +torch/include/ATen/ops/feature_alpha_dropout_native.h,sha256=PvaBXtj42rw5kZUgyyD9Nvo2NU9RLYDy5YrOm4VesU8,613 +torch/include/ATen/ops/feature_alpha_dropout_ops.h,sha256=v4VRElDt16niN_4AW_n-40hdUKF0scweyOXFlx9Zh0s,1750 +torch/include/ATen/ops/feature_dropout.h,sha256=BIAhn7ApKp2sE2SPI-6FacgvOsHVrPl5Zg_tlxDG4NA,939 +torch/include/ATen/ops/feature_dropout_compositeimplicitautograd_dispatch.h,sha256=wkzqotHqspY7l-2e0WUj3yjHtVDBM9sobxIsjs31qR0,878 +torch/include/ATen/ops/feature_dropout_native.h,sha256=Es0z4dRf1a8mo3LR_b8be2-UoS6J0zgq_XjhDvuBP9o,601 +torch/include/ATen/ops/feature_dropout_ops.h,sha256=eENUR4g9IGXrZknNsXe-ET6qJHiZdQ-sxGQv19n9Iyw,1714 +torch/include/ATen/ops/fft_fft.h,sha256=F4ZLwYH9JvcOF8czX7xVHufAiXt_Tk-h1h8Ymv2J22Y,4936 +torch/include/ATen/ops/fft_fft2.h,sha256=bI3CmycastjT1-UvG0s_1LeHO_DYJ7X4nyu5urGX3Uk,5253 +torch/include/ATen/ops/fft_fft2_compositeimplicitautograd_dispatch.h,sha256=WC5sUaGXyKBDfySJ8aNiFSxvNzTyBEscc5CfqCJz7B0,1826 +torch/include/ATen/ops/fft_fft2_native.h,sha256=3BTu3vXjG1UzjflX28VUoyKQjAnJGs8v-MJC5wAKUtY,795 +torch/include/ATen/ops/fft_fft2_ops.h,sha256=4gx_04QabBzIUH5FuAgAQNPSy9rLnUHQ6ejbNY6ZESc,2224 +torch/include/ATen/ops/fft_fft_compositeimplicitautograd_dispatch.h,sha256=SVYeYdbBfq3eONr8tQ00osThdFCPqihk6qyUY2In17k,1749 +torch/include/ATen/ops/fft_fft_native.h,sha256=caHUNFfIed__8Y6ZcaC2mHLoQiTIBdg8-Ay5UFDnIRI,772 +torch/include/ATen/ops/fft_fft_ops.h,sha256=yfsuWW6tY7a-J6eE3m7kNZLzvM0WLB9tdcFosw2oXEs,2148 +torch/include/ATen/ops/fft_fftfreq.h,sha256=EZagnkdhTbKa6L8ALhrEnAvkZ7MTI2LSXQ0niq9nMcw,1744 +torch/include/ATen/ops/fft_fftfreq_compositeexplicitautograd_dispatch.h,sha256=LkotQz4XY0M9uU7VnGYFHEqXkdEeHTD4qYi8QCfeekA,1154 +torch/include/ATen/ops/fft_fftfreq_native.h,sha256=MA_ViMTQ5di4lgwOtfoOstiXSXQ0kDyP_2W1JxeXjFY,720 +torch/include/ATen/ops/fft_fftfreq_ops.h,sha256=g_SRKId26ZchhLpCDv3dqGIX62HzQ8kDNiiB_GigJ-w,2084 +torch/include/ATen/ops/fft_fftn.h,sha256=nka-9cR9p0VKlXVMkYDMwdC9wvXQ6ZMFRizXm8Yhtk4,5377 +torch/include/ATen/ops/fft_fftn_compositeimplicitautograd_dispatch.h,sha256=Ajw7ud6tkutJ9DGq3ENaaeXvf6jojoKtNPQm6r8PBwE,1894 +torch/include/ATen/ops/fft_fftn_native.h,sha256=Uz62mQFTDDSR70SXOw_RMG3kEbfiIP339FHTmoGupmI,816 +torch/include/ATen/ops/fft_fftn_ops.h,sha256=odjDkpNwDKwJivm3EcN3qZEcfslinUoYiPeMmVKJllw,2268 +torch/include/ATen/ops/fft_fftshift.h,sha256=DTaV9u2rvp78i3j8PyZ5nBfMz8hQ0YOoxyRODS0T2dc,714 +torch/include/ATen/ops/fft_fftshift_compositeimplicitautograd_dispatch.h,sha256=9uppe9qNoIcfzdEikWi-NBMjMbFmr9KcioxhEDzff24,812 +torch/include/ATen/ops/fft_fftshift_native.h,sha256=05hRiDKapxXQjZFDCHkyeh_nUKGJQ90KpBHObfDqhOI,535 +torch/include/ATen/ops/fft_fftshift_ops.h,sha256=G5LiZIENrC6FLTPZDGg9vdp-wrrBdX4Uutj0vJG1Vf0,1086 +torch/include/ATen/ops/fft_hfft.h,sha256=3sGSHgdzGKXlJR7SPhXPabmzsbNrlAAlnIyyVQYO6b4,4967 +torch/include/ATen/ops/fft_hfft2.h,sha256=DkPLPmW7iYYwbIZW5NEGT43kPb5twyZ4vCjVFs-kHgQ,5380 +torch/include/ATen/ops/fft_hfft2_compositeimplicitautograd_dispatch.h,sha256=xouMFswxRv28mZoWY_RCZ7KwPgcuq9bT4ANfSIeWSHY,1880 +torch/include/ATen/ops/fft_hfft2_native.h,sha256=oR64tLw5aOSWv9MZlMUF1iJOAHAdoqD5AuFwvGoeIS4,809 +torch/include/ATen/ops/fft_hfft2_ops.h,sha256=46GuOnC4qDEHsBp_w-x2k_IVxc2KeCtXmHBzXUndOEk,2266 +torch/include/ATen/ops/fft_hfft_compositeimplicitautograd_dispatch.h,sha256=9ILE6B3taz75XVxz6JVB5XOpbuSHLsih42yTWo8c-Mg,1755 +torch/include/ATen/ops/fft_hfft_native.h,sha256=-3t2X_z7BRHytNZlCNZdP63pjOTgFRvusorBFKlR_cA,774 +torch/include/ATen/ops/fft_hfft_ops.h,sha256=BB4S6lMPVEq-BiuREr37qIfd16GZ0jvXr5bfkiNCAMg,2154 +torch/include/ATen/ops/fft_hfftn.h,sha256=LXJWJEkByd7cd04C5TJjEREhYe9NRkUU_TnRLfdqL6o,5504 +torch/include/ATen/ops/fft_hfftn_compositeimplicitautograd_dispatch.h,sha256=NSTp031q0kq-VwLY5fcXmCMWYYwbJ4TCgTsNyZBQrNo,1948 +torch/include/ATen/ops/fft_hfftn_native.h,sha256=zUGVKaWIALae4z5dbqKQZ3QzGOskuNxUY7HkkCC0BVo,830 +torch/include/ATen/ops/fft_hfftn_ops.h,sha256=Uxi2mH3X9UOnTAm5S5iadz9pL13G2Q1UJs2yA17f4YI,2310 +torch/include/ATen/ops/fft_ifft.h,sha256=2UE20t6RilIe3-Dlrsx2-hquKUHHol2nL-CpRGpfi2c,4967 +torch/include/ATen/ops/fft_ifft2.h,sha256=bmUnwWywyZdfILrkQjILZr_IoR-iEu7KMEa0Hy-o_iY,5284 +torch/include/ATen/ops/fft_ifft2_compositeimplicitautograd_dispatch.h,sha256=ImaLX0LGkJ_XnD3L0Jh9r9bA6rHW3PXiLg9osbL3hsc,1832 +torch/include/ATen/ops/fft_ifft2_native.h,sha256=pS0yIq0ZPPeJplomAQFZpJCzWNEvhjMcFdfIEF9fj58,797 +torch/include/ATen/ops/fft_ifft2_ops.h,sha256=CJk99Jp99DKX5eH9zvWsgjD5GNTaGO8cMfzV7vHqp5k,2230 +torch/include/ATen/ops/fft_ifft_compositeimplicitautograd_dispatch.h,sha256=ZKDrqaWJV_CQu_g6nlizyOStX65JBYCBi_oExxko4Fk,1755 +torch/include/ATen/ops/fft_ifft_native.h,sha256=tejNE-7YL1pdSP4thEQKI5hOaWmXQ_7eQRfmRB66AWg,774 +torch/include/ATen/ops/fft_ifft_ops.h,sha256=LVaXavIXEgdCEbC9CZ8f3DMrU_VEAfGyOVyIzOHf4gY,2154 +torch/include/ATen/ops/fft_ifftn.h,sha256=qtQY2Nl7ybrj7EMDXhw5iYysyA3a3sOZeEBOst2Ng3Y,5408 +torch/include/ATen/ops/fft_ifftn_compositeimplicitautograd_dispatch.h,sha256=WZS7CWwOO2IC-HSuQp5e8C7cdjkQYPNBon2naFqW7NM,1900 +torch/include/ATen/ops/fft_ifftn_native.h,sha256=UvQCmu9BIfFkBCT9s7Ji7dfz_uzLRwxMBvFLMV9UiT8,818 +torch/include/ATen/ops/fft_ifftn_ops.h,sha256=C5wGYrpMr57LssD1SvVE8GgG-jBVmAjdZoJ-LHSW-EI,2274 +torch/include/ATen/ops/fft_ifftshift.h,sha256=feecGiti54RQACk29MDW4Ta_dwOKTuxvxQwfKODsS5A,718 +torch/include/ATen/ops/fft_ifftshift_compositeimplicitautograd_dispatch.h,sha256=oOue9wuxsVY_7jpkgXmHfArRmOOvDP5dFsp4C7hpNbg,813 +torch/include/ATen/ops/fft_ifftshift_native.h,sha256=3uDMvWtswieUF6AexMqguuO7qMhBfHkgzZSUUWzk8f8,536 +torch/include/ATen/ops/fft_ifftshift_ops.h,sha256=_SuUBjaxmGlTcm_1J3VbmlaqRHNxoPY2mhp7kUBAhek,1089 +torch/include/ATen/ops/fft_ihfft.h,sha256=sjNG4gD_hQUDvKC6d7Y6UlFYuzPHHNEwb0qbIj1vukY,4998 +torch/include/ATen/ops/fft_ihfft2.h,sha256=gMDiIbvasyuOcrb7g0xDOUUrDqLcDpxnYBpnhctGess,5411 +torch/include/ATen/ops/fft_ihfft2_compositeimplicitautograd_dispatch.h,sha256=WiTPMvS17N4YIi56FU0hFniv5WAr0aGFRjmIbhxeN9g,1886 +torch/include/ATen/ops/fft_ihfft2_native.h,sha256=f-8TgReJopy4R7MiymV0QKg52qxl1w-v0cXflfDtnEw,811 +torch/include/ATen/ops/fft_ihfft2_ops.h,sha256=hJ9jSotMDq6NR20D067d14qAT5U0oZ3pmz3eW_NBfuY,2272 +torch/include/ATen/ops/fft_ihfft_compositeimplicitautograd_dispatch.h,sha256=S-TTGfzeKgmHiD5y4Rd8lqoQjFn7ED8ECZzPiEiSK-I,1761 +torch/include/ATen/ops/fft_ihfft_native.h,sha256=sSiGVMyu076wWnSdjAxNciCHG0kRMDVmQKEAo5-ThIQ,776 +torch/include/ATen/ops/fft_ihfft_ops.h,sha256=-pmD4NlK125LPHW_C_GLaJU5pAf5Kyln1DpKplVqQiM,2160 +torch/include/ATen/ops/fft_ihfftn.h,sha256=1O6TcjFAMwZdiN5YN2j-qg4NhN3VZhI1F5-pGQrr0hg,5535 +torch/include/ATen/ops/fft_ihfftn_compositeimplicitautograd_dispatch.h,sha256=9iyQcp2i3KxpzaCjYD52et_kib3b5pKcl6o6XvFaucQ,1954 +torch/include/ATen/ops/fft_ihfftn_native.h,sha256=FaAOT1LVhicKNFMBPPPaW90AuOs0C4l7W6jNdM1mtBs,832 +torch/include/ATen/ops/fft_ihfftn_ops.h,sha256=lo694QHFMmxhdiRnGqs5uFIrCweLxXnezmjd5D9KHvo,2316 +torch/include/ATen/ops/fft_irfft.h,sha256=WnkH8pKR_NR8qxchpkBPaT8OF3nmxGHcqC_tW9ZoK3g,4998 +torch/include/ATen/ops/fft_irfft2.h,sha256=Puwi00bsjoPyEXVe4Q3LHB5RUDgTACITXUsfuEsWphI,5315 +torch/include/ATen/ops/fft_irfft2_compositeimplicitautograd_dispatch.h,sha256=31CpheL-pWmYfAkq_-Xpcy3jA3UmJI-nJsBhX-pfICc,1838 +torch/include/ATen/ops/fft_irfft2_native.h,sha256=P6HV3OagQjSEq4qLr5n5GxK9pKg-n9z_XQdxvwjyw8s,799 +torch/include/ATen/ops/fft_irfft2_ops.h,sha256=RrA2Q1kxz8nFjjXVEY9Ti6rzuChod1G7aOd66USvye4,2236 +torch/include/ATen/ops/fft_irfft_compositeimplicitautograd_dispatch.h,sha256=qz0GsiH7b6sBjrINgP2LMAR0ak6MkzADM_EIba26JsE,1761 +torch/include/ATen/ops/fft_irfft_native.h,sha256=7Rz5j_w4PNzd9qz2gSmBRYCVrZSdmZYlP-DZvNKpWiQ,776 +torch/include/ATen/ops/fft_irfft_ops.h,sha256=DQ8EyPKMWRSXmtlVDpvYijm4J9cXK-iDEBYHrB-TztM,2160 +torch/include/ATen/ops/fft_irfftn.h,sha256=ZkpPZTRNFVUF3RHiy9YEkjDFjenrmBLhDzQt2pEqke8,5439 +torch/include/ATen/ops/fft_irfftn_compositeimplicitautograd_dispatch.h,sha256=Uf2hVCiOvbWL3kKvXbsB4Gy4cKrchck968oBRWel_GQ,1906 +torch/include/ATen/ops/fft_irfftn_native.h,sha256=sds96I2AbqhWbLUOBUx0m5ZKWnmAFzk20j0CJTeuW7E,820 +torch/include/ATen/ops/fft_irfftn_ops.h,sha256=Y1TzGDF3fAr6bLln6q_o69XifUM0457H8niFll-Hsy8,2280 +torch/include/ATen/ops/fft_rfft.h,sha256=N1W-0NPqJM8ZJOwEmnmMGFknORWke1-X80jTPqcwDkQ,4967 +torch/include/ATen/ops/fft_rfft2.h,sha256=VrMpdNCBZFBCGXK4HYG54IsqG2-eER14az2n3CjEXAI,5284 +torch/include/ATen/ops/fft_rfft2_compositeimplicitautograd_dispatch.h,sha256=aeW2pMaLk2oeukEVyP4N1bcaywRroTrFwOe20kBReS8,1832 +torch/include/ATen/ops/fft_rfft2_native.h,sha256=qUhM4H0Qdx-FL1RdbqSq5Y2rFtEu-av9pVRZ3PRyufE,797 +torch/include/ATen/ops/fft_rfft2_ops.h,sha256=1S78iO00yRMQOqPR4yI2zizXJTIBo-ikYCqCAHKrmfs,2230 +torch/include/ATen/ops/fft_rfft_compositeimplicitautograd_dispatch.h,sha256=lfY5UYdM4FUngLgrlue2WMcttPlnjFktyvyc2Ir-ByE,1755 +torch/include/ATen/ops/fft_rfft_native.h,sha256=bwTbPGLk6EftIOPHyd74lnQQIc-jOlBrk17g2s2f__w,774 +torch/include/ATen/ops/fft_rfft_ops.h,sha256=ZMCI9vfq63KihX--u4PuCOsx1CnrK_5AJa-6XGVgr60,2154 +torch/include/ATen/ops/fft_rfftfreq.h,sha256=pP5_lcUlHiKP964Zuu9NvujnhEsCJmX1AWFnDLZpFmY,1757 +torch/include/ATen/ops/fft_rfftfreq_compositeexplicitautograd_dispatch.h,sha256=ddwWr_UXzszpC9HyuhS3viZela1QcjbytUctpzXQWOA,1158 +torch/include/ATen/ops/fft_rfftfreq_native.h,sha256=y9ZrRgq__vWkT3-1IkuGE9fZkQ90TmgYDdoiZF8rZYo,722 +torch/include/ATen/ops/fft_rfftfreq_ops.h,sha256=50GdBqHHVYgNPgiclgIqr8_crRuHl7PTOBGHgWoeSs4,2090 +torch/include/ATen/ops/fft_rfftn.h,sha256=BDt0s08glQa4lG95NAWOkpmV5z7Ies29oNSWWNXgDo8,5408 +torch/include/ATen/ops/fft_rfftn_compositeimplicitautograd_dispatch.h,sha256=W_-_xLqhq7RHqCjIjdjimRX9qPclE_-LVrYVF66V3nc,1900 +torch/include/ATen/ops/fft_rfftn_native.h,sha256=sUUiIT4VeeODpa1duXFyPqfGwYM7XpTO-beTBPSb-0o,818 +torch/include/ATen/ops/fft_rfftn_ops.h,sha256=kxTkDXDOVWA4SagLyVKZBGa_0wSvZzGM6ZFDccUbDMA,2274 +torch/include/ATen/ops/fill.h,sha256=3AbtoR-4xHvhkbKrRXi-T195XPZfySmzToMvKyZLTe8,2262 +torch/include/ATen/ops/fill_compositeexplicitautograd_dispatch.h,sha256=eeuep9t-XE5g9z8ucNeM8xG-hMLfQENipkzrpSfpbVU,1276 +torch/include/ATen/ops/fill_cpu_dispatch.h,sha256=OgPpV9sOfxOj71SpumrO9Yf_J8orp491V9q4mKuANlA,816 +torch/include/ATen/ops/fill_cuda_dispatch.h,sha256=GIEBMjK-q5Z3YlI48yA8Sn5WVL_tJiEcS7QfnWgTGLI,818 +torch/include/ATen/ops/fill_diagonal.h,sha256=WGV4xHfiQtwrhe2fkTCOvVUTXCyh_udliJYdPSgesy0,498 +torch/include/ATen/ops/fill_diagonal_compositeimplicitautograd_dispatch.h,sha256=IC_PggetcV9GrhMDYpV67jcqVCbgOJUrY3rWlBAvbDA,816 +torch/include/ATen/ops/fill_diagonal_native.h,sha256=nXiN_XRSMLsbIyLo2HaMr44-RkM5c5kIMKQG8PiA86w,539 +torch/include/ATen/ops/fill_diagonal_ops.h,sha256=SAs8QTwZ0z9GAs_MAeBJD_0FSbz8VfK9mA9FRmEVPwI,1133 +torch/include/ATen/ops/fill_meta_dispatch.h,sha256=PulYSplLtOtLRK9kRr8EoAnppi9xv_1qUW7YmR98Oyg,818 +torch/include/ATen/ops/fill_native.h,sha256=QoVIxmXzizUXFn9XYjxZONTBVZbxwKpSADHIjslvoDk,1537 +torch/include/ATen/ops/fill_ops.h,sha256=AjIKTBH9ovot4q726ucTKou1y1Os8GXtGVpzaVcte1c,4412 +torch/include/ATen/ops/fix.h,sha256=xb-fJEU7fZfz19RHWF8AqDUnfwSlXDJt7SjcbCR-FBM,1118 +torch/include/ATen/ops/fix_compositeimplicitautograd_dispatch.h,sha256=1rAxNUzvAbucElQo95oHWe1wygZVKF-WEyl_Pj12c-Q,960 +torch/include/ATen/ops/fix_native.h,sha256=HaI-xJtH4Y3tbgeacvCqjuSdre7OQ4BflMIrAB0GSmM,607 +torch/include/ATen/ops/fix_ops.h,sha256=lCmpWYwGNLDF4l7pqtDyxkO9Gtk0_hSCN1Z1YBYMgRc,2095 +torch/include/ATen/ops/flatten.h,sha256=hTd4I5F6zzdr2Nky0ARdifgf-lzXH8cF2ppEdIE0GGE,1628 +torch/include/ATen/ops/flatten_compositeimplicitautograd_dispatch.h,sha256=rm0Uvy4fOf8eOGuu-oQHmobX2FZOwNqV79yT4vUfVek,1136 +torch/include/ATen/ops/flatten_dense_tensors.h,sha256=ybiSEnQA9pNU269CBRgeelqLVcW3yzEmQAooevs3n0A,692 +torch/include/ATen/ops/flatten_dense_tensors_compositeimplicitautograd_dispatch.h,sha256=0lIlNllTecb53AhiJcPd97M7aH8sir5Y4rIEYtfZs7I,778 +torch/include/ATen/ops/flatten_dense_tensors_native.h,sha256=xQx8vXLXSG7h2WHmMx1PfSasdCkYDzpUbiL3w6bqK7E,501 +torch/include/ATen/ops/flatten_dense_tensors_ops.h,sha256=F0Bewv2ki-z6zI1VibH3U9HX49IaFq-kqTPu3QXtLR8,1011 +torch/include/ATen/ops/flatten_native.h,sha256=ByjDqnQTJzJEwuWmg6FOJY6DMveuDh9kzvPxhaseJdQ,859 +torch/include/ATen/ops/flatten_ops.h,sha256=PQrBHQVW921UmWGQ7N4494NXmxYbu6kmzU5l1Cn77BU,3429 +torch/include/ATen/ops/flip.h,sha256=HfPXPXoHoV1cvX-6DG8FzaBZwPZ9SKXwriUc6hQa5LE,1115 +torch/include/ATen/ops/flip_compositeexplicitautograd_dispatch.h,sha256=-r_AVB4zpyiBpa71S-Hbhx4tKU98SysKQpsHszhozP0,907 +torch/include/ATen/ops/flip_cpu_dispatch.h,sha256=lL16AEyy7O39BJk2Gq0UlEvRDYU97F-RfJRMQc0upa8,740 +torch/include/ATen/ops/flip_cuda_dispatch.h,sha256=WhurYoQcJKvC2LwKjm7EpRRo3WxRGSd2K7s8um6BNLc,742 +torch/include/ATen/ops/flip_native.h,sha256=REoMYghV0u5XHAofZ05fBeKhrTiJvHVyR4OlQMWg5tk,605 +torch/include/ATen/ops/flip_ops.h,sha256=cEM7ct1DHXkklKTn11nwEwkCteDx7ciCK8CbTIHt7qA,1724 +torch/include/ATen/ops/fliplr.h,sha256=sFeZSSwE8Ii3g47g91wd7bM-3pVGEo9igGwoBBwQJLI,625 +torch/include/ATen/ops/fliplr_compositeimplicitautograd_dispatch.h,sha256=9XV_gwYUMMmToJ3jz7Xt17O1Rq9U_ms2846qAHuoPOQ,764 +torch/include/ATen/ops/fliplr_native.h,sha256=2a8oQf47gFOCwYfd-55FVqJjVn6wByKlsBd7uE_LSbM,487 +torch/include/ATen/ops/fliplr_ops.h,sha256=PtMIEuYnpg-8O3a5I7WmsMue4vFjNi5H8txZ5CGCA74,967 +torch/include/ATen/ops/flipud.h,sha256=S4QMPSfyi1hR7r_LqM49Zobq8g-zrZoJ1odVGiV0IFI,625 +torch/include/ATen/ops/flipud_compositeimplicitautograd_dispatch.h,sha256=mbHibeplISZiLHUH_R0-CtytsxvIvnb4VoU4Lw1w7c0,764 +torch/include/ATen/ops/flipud_native.h,sha256=1TCIBL5W0nlVY8b6ycFroHroWGrZKYRCh9HEp-CwZMY,487 +torch/include/ATen/ops/flipud_ops.h,sha256=0AEMwOx3jDxlgizGygdHUlGRVCF8RMZ5j7urURRUbvU,967 +torch/include/ATen/ops/float_power.h,sha256=KQqMJSyjtjJbVDGVwZuZ59n2KMdKr2JqMJx1Hu25lLI,2919 +torch/include/ATen/ops/float_power_compositeimplicitautograd_dispatch.h,sha256=xMb7SNBUrwOKBn-DJ28syR1Vq7tEon-BaC-QtFAJO-g,1819 +torch/include/ATen/ops/float_power_native.h,sha256=4NaUgFb6OLXB7vvzkVmFfezlcoZfQaVN9z_Z1Tdqng8,1203 +torch/include/ATen/ops/float_power_ops.h,sha256=RBT5aLwP2qDm7UBlhu_KEJzKDI-vBEMaRLEzqBCNaPw,6093 +torch/include/ATen/ops/floor.h,sha256=ELZCjVIh50oZqL5AUdMCSJHI0GNK8nWNMGDe190eteY,1144 +torch/include/ATen/ops/floor_compositeexplicitautogradnonfunctional_dispatch.h,sha256=FSIm3qQRi1-5baZ2ID70SgUY0jQLlg2n2Iuz0erAj8k,839 +torch/include/ATen/ops/floor_cpu_dispatch.h,sha256=1HJEpSrpqg8gZcfcCCNZVhMiHclY0Zd5ihTTmGW6l6s,924 +torch/include/ATen/ops/floor_cuda_dispatch.h,sha256=ra0_yJwg-XznM-CY2zHiClZO4rosku8k3tZt62VEqh4,926 +torch/include/ATen/ops/floor_divide.h,sha256=L24NP8dQucGmKzK9fFyiiSXy7dEG87Gaz87N4v_xucE,1978 +torch/include/ATen/ops/floor_divide_compositeexplicitautograd_dispatch.h,sha256=v4JOo2ZeNw04rzype5BbY67n3Y4dVqvrlBUK8ZQLCDE,1100 +torch/include/ATen/ops/floor_divide_cpu_dispatch.h,sha256=Z3r0UdfFs-NFum3XuxIZ57rJCzG9LSPwJkzmla3p9tY,1056 +torch/include/ATen/ops/floor_divide_cuda_dispatch.h,sha256=4QOyX8Rh04IPkn6gYnB2fiTA_6OFMkjQ6XGkEBYXoe0,1058 +torch/include/ATen/ops/floor_divide_meta_dispatch.h,sha256=QilrJ8wT4vLGLraRxa7tU_j8fHqFZklIW2_3Vpa9u98,751 +torch/include/ATen/ops/floor_divide_native.h,sha256=PyKzdLMFxYgaL2Fb88HURcTqM0mM22mRTQNKuRT3swM,1306 +torch/include/ATen/ops/floor_divide_ops.h,sha256=qMuqqKKDDAJXi2VS8Sbjo-pBxOJBXasjN4-eQ9vJIKQ,4515 +torch/include/ATen/ops/floor_meta.h,sha256=G2Et1ZjIgDk12SiHgifEKUiJmjDcD361x9vSsyaniuw,585 +torch/include/ATen/ops/floor_meta_dispatch.h,sha256=Q0VTkuZDFb8pqAhmn8SrBhdf9wNGXhRyilLcb7nsZzo,926 +torch/include/ATen/ops/floor_native.h,sha256=Ofr7JeEojXDCWM-L0JLw9jL4ZgpysNH7OtUN0S9AIB4,1018 +torch/include/ATen/ops/floor_ops.h,sha256=XHBI3mxNLkfYTqoZqXt0g6Dy5uCFR3T76eigYDQqC_4,2113 +torch/include/ATen/ops/fmax.h,sha256=DOZntVVNdkyaq8NOG5FMV5uCXOMO5dq3NmmMPgc12VI,1136 +torch/include/ATen/ops/fmax_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rYm_4zVW5tkQ6Z4ASegs8oV0rPCn9UmldA4B_EQpPDI,814 +torch/include/ATen/ops/fmax_cpu_dispatch.h,sha256=xC9MR5ByoXgZ9Od6ubz4U2UknfEudbmvsL_kYAgtKmY,949 +torch/include/ATen/ops/fmax_cuda_dispatch.h,sha256=Aqz3snnSr8Yc1S67AXDpNwR-bHePeaXWgH6tEHOV_Hk,951 +torch/include/ATen/ops/fmax_meta.h,sha256=3wMUSlYZQIczOIq77In26AV29BkVZThBgJg7zFEJ9SU,610 +torch/include/ATen/ops/fmax_meta_dispatch.h,sha256=DAKrhaUAbCZkXv5I4QfIZny8ccrC6ZR5EjPGgz1Ft1o,951 +torch/include/ATen/ops/fmax_native.h,sha256=C9Z49dIf8_7tdjEkOGfvQQk9TO6GOQlvPaokJt_CFCE,627 +torch/include/ATen/ops/fmax_ops.h,sha256=O8VSpLQgambLeo_QjsXQfHMs7ZSgOVxSHYjPtIPDPfI,1750 +torch/include/ATen/ops/fmin.h,sha256=BE0gH38me3n8pVpefiH_-WqmGuYuLieTmKST9yvv5aE,1136 +torch/include/ATen/ops/fmin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=tghe8Z72h6NhcS1me_RIjXKsmXBh3xa4auY1hON-pLM,814 +torch/include/ATen/ops/fmin_cpu_dispatch.h,sha256=guGGZ-3PCXFQGd8jZ2P0giHgurCwJSWt6A1IhExwtYQ,949 +torch/include/ATen/ops/fmin_cuda_dispatch.h,sha256=Sbk0kGzsBHYoI3fprtA29pCk3H4-bA9CfFSFPBhErlk,951 +torch/include/ATen/ops/fmin_meta.h,sha256=lDcujGjuiQIuafeeXiYf_k1xayRoEmtnjdsAhZGXsFY,610 +torch/include/ATen/ops/fmin_meta_dispatch.h,sha256=G0x71CFiMKa5IQL_XM0aUvTvchZ33rpbqP5GUVbk-Ws,951 +torch/include/ATen/ops/fmin_native.h,sha256=lQrdW0kAOfRmxfnNnlx7ppIMNvNFMdEHbtrVoaiiFKk,627 +torch/include/ATen/ops/fmin_ops.h,sha256=wSZRYUccj_OmgrHhQQsVfxsoFXJ4JZW1KFyVjIxtGMQ,1750 +torch/include/ATen/ops/fmod.h,sha256=1Kt7QbfHQmGxYWRzLWT9JPBR2zi-GaZnpxM4_1xc-Ik,1868 +torch/include/ATen/ops/fmod_compositeexplicitautograd_dispatch.h,sha256=251IW6ZRK6qalybZGy_y90lhXwb0S9bM-7ftj3eU_-s,1068 +torch/include/ATen/ops/fmod_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5F5_7nBrp4Uz4mC5vP3MU7of7dy7rr0ZQWpJinlSHVI,889 +torch/include/ATen/ops/fmod_cpu_dispatch.h,sha256=pJsiXx87F2cIOTeJXt52oXY3Fst3qiPrwcs5dHUKYvw,1024 +torch/include/ATen/ops/fmod_cuda_dispatch.h,sha256=E8aPSaegD2ja82Mani5LuyyjBuFdtv23eb9xN9cIu_A,1026 +torch/include/ATen/ops/fmod_meta.h,sha256=Wuc7ME6GaNMjoEGX7jSjmIdKYfwR_2zC9n4zAZ-hR6w,617 +torch/include/ATen/ops/fmod_meta_dispatch.h,sha256=4kze2hOScbx16l4wxC4VIjGlH9wsDVGIIzquxpzlrP0,1026 +torch/include/ATen/ops/fmod_native.h,sha256=tzuwt7QPzFR4Pyhcc2KDdGtaiddNN5w7tkfjZ72d4q4,889 +torch/include/ATen/ops/fmod_ops.h,sha256=mYp3x0sUoKSO3S-HC6mfl0ZREOVgWkZPuc0N4LMM1EA,4412 +torch/include/ATen/ops/frac.h,sha256=_qI7sNB2vScIEMC1LTQVZci2oMFnT5YGHvBeXQkpH9c,1131 +torch/include/ATen/ops/frac_compositeexplicitautogradnonfunctional_dispatch.h,sha256=W2V1FuAyQb8zcEn4avkmF3ud0GpTANgaosSqk8cio3Y,837 +torch/include/ATen/ops/frac_cpu_dispatch.h,sha256=gNULicNZORnxMkYnnGxYwWLv1rrk61j5eFx1bn171MQ,920 +torch/include/ATen/ops/frac_cuda_dispatch.h,sha256=19Mv27gfEZmjJfOyGx7Kx01XrKVwHGjcEfK0jUCbAWc,922 +torch/include/ATen/ops/frac_meta.h,sha256=jrVoCHhcTSx81IJ2IREPfwUgg3TrfJq2j4EksbAk2E4,584 +torch/include/ATen/ops/frac_meta_dispatch.h,sha256=qqFSiVycZ_nbQw2XZ1o01fXIVG-JvTS39K7YJN197fo,922 +torch/include/ATen/ops/frac_native.h,sha256=B84gFQbQyY_a-_YBeUtGSMi_WT2N18y3I3JdFGzUx4U,1009 +torch/include/ATen/ops/frac_ops.h,sha256=t28YiOy2C-VCJDBWRri3bSViyNt7Q80l9KlUk1X72wI,2104 +torch/include/ATen/ops/fractional_max_pool2d.h,sha256=ljv3F1IsKVitk2g3pf8PkCZo1YDalGWkR5QEuIRYVbw,2008 +torch/include/ATen/ops/fractional_max_pool2d_backward.h,sha256=m7u_rn9xOHWqNJj7ZbuSROZTNUKXuo6GtrcuiWu0CNc,2051 +torch/include/ATen/ops/fractional_max_pool2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=D7Fq_HvtOmaZNO-JmS8zMAaKmGTg-nhPE_QATnmy4BY,932 +torch/include/ATen/ops/fractional_max_pool2d_backward_cpu_dispatch.h,sha256=F8V1UiuYn8eLLp8-Z4VqUXkgy7ZP7fhNUKK3iDijiDg,1317 +torch/include/ATen/ops/fractional_max_pool2d_backward_cuda_dispatch.h,sha256=z4iHw57ZlWA8l44p9B0z2g2Msyofddy2TOW5mf3NnDo,1319 +torch/include/ATen/ops/fractional_max_pool2d_backward_meta.h,sha256=m4bLB0nrKPB4EezYeVRxL4us2oemIdLTHiCaz7q0vho,728 +torch/include/ATen/ops/fractional_max_pool2d_backward_meta_dispatch.h,sha256=Mx_5XZRVJ1m5StO2p5rVK9D_zyprPb2OC8m2qlr6428,1319 +torch/include/ATen/ops/fractional_max_pool2d_backward_native.h,sha256=GIzmrrMww3r9zN_fnO0MlCXRNiqDLBSIuxYKo7nLcmU,1119 +torch/include/ATen/ops/fractional_max_pool2d_backward_ops.h,sha256=Ht1qL5r-i0FliHmA7jtPYgtMqRHUxqzY7EyQJx7FSKY,2548 +torch/include/ATen/ops/fractional_max_pool2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=iRQhoaCx7-QyzYW6Lv93EwBwVEDmqxNEd33AEWlCe9s,923 +torch/include/ATen/ops/fractional_max_pool2d_cpu_dispatch.h,sha256=YPDvgDmFvmY7yrfo7zqELDAWB5j5rnlXisfSn2pNj4E,1330 +torch/include/ATen/ops/fractional_max_pool2d_cuda_dispatch.h,sha256=lDcDU4Bj8JkJF8aIYbYMWR8koVjxWVulMtlWFaEMxX4,1332 +torch/include/ATen/ops/fractional_max_pool2d_meta.h,sha256=_eMRcos1mAJrgJaWkbQCz_mCOeCMOlGjkfdwzYiI3Cs,694 +torch/include/ATen/ops/fractional_max_pool2d_meta_dispatch.h,sha256=958iJSudzKBpARsyJZ2Sdpiv3ckBa-cwGu39qcMyxFU,1332 +torch/include/ATen/ops/fractional_max_pool2d_native.h,sha256=VpXIGc44kux4X-bBLKLDsHkpbc0_07YnoYPmfpqE4b4,1080 +torch/include/ATen/ops/fractional_max_pool2d_ops.h,sha256=-6NSekqohHDEBj3E2vMa8Tdlg39ALvIHQ1jsk8uKCac,2562 +torch/include/ATen/ops/fractional_max_pool3d.h,sha256=5ryoM8srsrbwqfLgKkCB347i7n8hP5I5s21Tn45CiiU,2008 +torch/include/ATen/ops/fractional_max_pool3d_backward.h,sha256=pk3UhEOyj6ySbenymHEADp9pzsC8K2b8hAwEqUd_XPI,2051 +torch/include/ATen/ops/fractional_max_pool3d_backward_cpu_dispatch.h,sha256=DzmYqWlyLGQ56bt6q1LB0gu7UUVOM4I6_fMT5ZxZjqw,1317 +torch/include/ATen/ops/fractional_max_pool3d_backward_cuda_dispatch.h,sha256=YWehyENpjOCpl53WCN_LQ2tefhMdNYnCkqnpL9kXFyg,1319 +torch/include/ATen/ops/fractional_max_pool3d_backward_native.h,sha256=fCF4EsBu0XsiNvCPNybROrONqf4kV3lPF9NIP5TaSu8,1297 +torch/include/ATen/ops/fractional_max_pool3d_backward_ops.h,sha256=3PLVYp2ZAvfFTcKOSZmD1liq767msfIFOlI14P2Cglw,2548 +torch/include/ATen/ops/fractional_max_pool3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Df3mXbR3ZSkyBn_po-aw0S_klTBtq6W6cL7XuQsjO10,923 +torch/include/ATen/ops/fractional_max_pool3d_cpu_dispatch.h,sha256=5XSp9ULXOMzUcXdZhognO_kylqK4rJ7uqLqoO0JTrgA,1330 +torch/include/ATen/ops/fractional_max_pool3d_cuda_dispatch.h,sha256=XF2IigJH3aePEw4MLmQvrel4zghnJc52O-F5lZZxi-E,1332 +torch/include/ATen/ops/fractional_max_pool3d_meta.h,sha256=-yxPj2ortCd21r4iC3PF-gbfZ2lH3WoGzT78aktOmnk,9818 +torch/include/ATen/ops/fractional_max_pool3d_meta_dispatch.h,sha256=_AlLnae2SvCij3j5DPZQ0a3_GuxGh_BtKrr4bVBtaxs,1332 +torch/include/ATen/ops/fractional_max_pool3d_native.h,sha256=IHxpU_w66ypzvThzOjfEy0Z8Tn6f94i3hLvh8btuID8,1350 +torch/include/ATen/ops/fractional_max_pool3d_ops.h,sha256=zpgaUGkcDQ6kxduMN2knZc-AHsCRfJcYmKccjFAKi2g,2562 +torch/include/ATen/ops/frexp.h,sha256=s__5IoEYNDbbJqzLi9atKF9KFFZvRey2PvWzYLJPD2Y,1356 +torch/include/ATen/ops/frexp_compositeexplicitautograd_dispatch.h,sha256=C5T-EyKRo4gmsuvd-iuV2vgx9Ja-Y_aE_Csd5VE5m4k,788 +torch/include/ATen/ops/frexp_cpu_dispatch.h,sha256=AgQXoTT3yVNRYAFBAT62HBou_K9BHfutH_1lVLkGvmk,931 +torch/include/ATen/ops/frexp_cuda_dispatch.h,sha256=8St131-MWHi5P3PMunUH2wXjpgCEbcawIzPduqZvQYs,933 +torch/include/ATen/ops/frexp_native.h,sha256=tS-OEBJ1ahLhx6j08yxIUqL_ep3KNyXQkfx53HeuE3o,643 +torch/include/ATen/ops/frexp_ops.h,sha256=ALC97KfwOW9vdr95BLjCPxzO3QjcEq2CvJC0v1fRtmQ,1937 +torch/include/ATen/ops/frobenius_norm.h,sha256=bSjI4gW_4IXLHnM2Qi2YGsgJzeYoFxm3xjhwlDX2p0M,1358 +torch/include/ATen/ops/frobenius_norm_compositeimplicitautograd_dispatch.h,sha256=Vplafky-TGtQHN_wEUvSKvkm-kTjOI8s7J07QLQHaDQ,1062 +torch/include/ATen/ops/frobenius_norm_native.h,sha256=ybeNTzSZPVAr--clyv_mn_mcOLQweQGyjLYf4-8thpI,657 +torch/include/ATen/ops/frobenius_norm_ops.h,sha256=AvnFASOYEQJoqNmYP64uS5WKe0Q9iIlydEG5YOXmTAE,1899 +torch/include/ATen/ops/from_blob.h,sha256=w39xnTIgeWMbGfbIbMffWwYkpWg-VEQauHliuz2D6w4,4163 +torch/include/ATen/ops/from_file.h,sha256=HNf1G7kNCFLA0Z1oa7GlGQusAfM4edlK4a7Xwx35Geg,2168 +torch/include/ATen/ops/from_file_compositeexplicitautograd_dispatch.h,sha256=m_-WbV5WEBZkkSfz66_xRsOgl75KvfFJYoBnOgXitUk,1006 +torch/include/ATen/ops/from_file_cpu_dispatch.h,sha256=PvHaFacUDyxQ4PfHMzgp2KvWK7E0JKwXVNT8CZB0tLM,1080 +torch/include/ATen/ops/from_file_native.h,sha256=O4wOPXND0xbCBcn7qFeroa-kG-mLj1r6qCJcds84t2I,853 +torch/include/ATen/ops/from_file_ops.h,sha256=gZtrR_scmAZuvwMZd1VZIzY84QFWUlzmRXjLjKyOacE,2468 +torch/include/ATen/ops/full.h,sha256=t3YDs_GsxThwTq21OyUS1QBV5R9CHL3Pno29Ga3wYDU,7897 +torch/include/ATen/ops/full_compositeexplicitautograd_dispatch.h,sha256=lJ9FN6kr7Wd3FpeOQO_Pgn8fzYk2EdvUL5TnpfqHJ7E,2514 +torch/include/ATen/ops/full_like.h,sha256=UFWrEjvrSl_fwNx9LBloOlrQbsc-vi0bdfQbI5sKQTk,2424 +torch/include/ATen/ops/full_like_compositeexplicitautograd_dispatch.h,sha256=k3PmuJhDVD0RZg3sHdGIgolZeCIv8i8xWl7X8E5dsXY,1492 +torch/include/ATen/ops/full_like_native.h,sha256=A-WFqr08X6ZlArtqAx96_cIMuSSsjhjqHNba9aBDTXk,889 +torch/include/ATen/ops/full_like_ops.h,sha256=6MfKUg6-qKnw4LhMnk7A2rBsBk1_CJ1OsjCGciowvX4,2604 +torch/include/ATen/ops/full_native.h,sha256=g6P3JwfIzJvO_zhuiRf5EeFb4D1AokJIhuIB7bk3UTU,1181 +torch/include/ATen/ops/full_ops.h,sha256=tXQgFxLCNA4l-ArVsYmyrhLgIRnPrdfCH56ou7rWVHk,4347 +torch/include/ATen/ops/fused_moving_avg_obs_fake_quant.h,sha256=glU4sLkVuBun_sJ8czFdehDWKjB-_huOH4GMg4Fs-l8,1440 +torch/include/ATen/ops/fused_moving_avg_obs_fake_quant_compositeimplicitautograd_dispatch.h,sha256=XFqA-I8sGlLALfDNmDK3A2M13mx729qZA-RwCh95_Lo,1090 +torch/include/ATen/ops/fused_moving_avg_obs_fake_quant_native.h,sha256=2n2PxRP1iq9ti4TXHHjwt3dQRCtAim06Yw4lpBxVdIU,813 +torch/include/ATen/ops/fused_moving_avg_obs_fake_quant_ops.h,sha256=BakBxOPq2_b-wDUWfhA0ZPrVewSgjNxhkdHD5rxBbeY,2019 +torch/include/ATen/ops/gather.h,sha256=rtGeeWU__CxEcn2nmbHt8Req-EM6R0qGYV_rwWYUc-o,2416 +torch/include/ATen/ops/gather_backward.h,sha256=0LLlJH6doW61iwDPzjTGl_yQ1ccgSDr6lvqoYqQ4Otc,828 +torch/include/ATen/ops/gather_backward_compositeimplicitautograd_dispatch.h,sha256=RgBHAj_gl1r5mQeI7NFnyIVpwmngidmOrXQVqm9dTxM,855 +torch/include/ATen/ops/gather_backward_native.h,sha256=RxqQsbg33rrlJXaiBMbwlLogCa5QuUgo3PrKA7M2O1o,578 +torch/include/ATen/ops/gather_backward_ops.h,sha256=LswmtEQfl8ilD3cq0p-bjkev30T6mg2iFi0SCOVugw0,1267 +torch/include/ATen/ops/gather_compositeexplicitautogradnonfunctional_dispatch.h,sha256=-ErXazNAujTIXpCCEuJwv92j1FwaEo1Inge9rqAP5O8,853 +torch/include/ATen/ops/gather_compositeimplicitautograd_dispatch.h,sha256=3xQOOuztKR3h5rAEFkB2__OoIHwIsEQWU24eAwOhoS4,1116 +torch/include/ATen/ops/gather_cpu_dispatch.h,sha256=iktZfREucwqpg7QzlrKHc3qnrccMdxt9Vz7lU_X90Ao,1060 +torch/include/ATen/ops/gather_cuda_dispatch.h,sha256=8ZAxgji8Dnl1NvdRxbs_HZnwFrkAG6LuZc4Qs1nrWD4,1062 +torch/include/ATen/ops/gather_meta.h,sha256=FDjUgAjpgJpgEnDUVAz32x-0oKIlUGxcPOLvjwnDLZI,643 +torch/include/ATen/ops/gather_meta_dispatch.h,sha256=UrzpQw1xHVUL8caKQVTHH1RB25UTWqhFipEDQ3_kqKQ,1062 +torch/include/ATen/ops/gather_native.h,sha256=6dRaq_gGi7u_PZVsA1GH4QfsCXvUE0HQpNQuzvCYo-g,924 +torch/include/ATen/ops/gather_ops.h,sha256=EdGa_OY3Q7WqxtCkyxtStjVcNd0cloomyvqsoTxb88A,3615 +torch/include/ATen/ops/gcd.h,sha256=5o4uFWk_sp3YqOLQNH3K_M7oxkFKWSdkmkSCIY79DJk,1306 +torch/include/ATen/ops/gcd_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oYwr05ANpnT363tYor-dPh5OFXFoUrSiDAV91MAtGIA,887 +torch/include/ATen/ops/gcd_cpu_dispatch.h,sha256=l4YAY3lA9xO4eVQeROYHO8xm4Z6hnzi38B6ij_lj-tU,1020 +torch/include/ATen/ops/gcd_cuda_dispatch.h,sha256=zjshszA5noT6rIeVL_-kYsFT02KiQbBIfJ4nMykq6c8,1022 +torch/include/ATen/ops/gcd_meta.h,sha256=Pyhmz4r9F99tGaplVAHbnrHqQ6_s3rUE6Hz6dMyHq9A,609 +torch/include/ATen/ops/gcd_meta_dispatch.h,sha256=9kvofJJIPymWLcuVdyQTph15kr7Xcf0EBojR-aivgCg,1022 +torch/include/ATen/ops/gcd_native.h,sha256=5QrOeiMr5NVUu9b6qDz54Op2uFLjSkDTK-irOBmslmg,624 +torch/include/ATen/ops/gcd_ops.h,sha256=cjMxuU45a20Ugxq2FPKawzxkCRpStfc4tFNu_Lw8GdM,2353 +torch/include/ATen/ops/ge.h,sha256=qBF0uMpkPE2oa7_eOe7IQHsU-mXnkPZI_XwIxcUmLts,1830 +torch/include/ATen/ops/ge_compositeexplicitautogradnonfunctional_dispatch.h,sha256=cjmE8YjUbKJr2qoetaOOZa-m5kl9obt-pNmJdmaIm28,1034 +torch/include/ATen/ops/ge_cpu_dispatch.h,sha256=tRMpQFauiFzmEMU_eyMXuxGSyQGdwmcd_ciWApQZMnQ,1366 +torch/include/ATen/ops/ge_cuda_dispatch.h,sha256=WpJp8XvQMVCmi0C-V_gLxRGkKfFfqW4ff8CAJkc19Ok,1368 +torch/include/ATen/ops/ge_meta.h,sha256=AxAz0gU1CxuHk1L92BzziVs53B0l1nlRtDJm4EVZzw4,762 +torch/include/ATen/ops/ge_meta_dispatch.h,sha256=CvQK0S14D2zdUH7i4-fsQiOrIYFUcG2Hs6xrjzfDSLs,1368 +torch/include/ATen/ops/ge_native.h,sha256=bHGLMRE9dhe3shNQ5sZwjVWU-EsrPYnGejCwqDAi3ZI,1306 +torch/include/ATen/ops/ge_ops.h,sha256=jZNR4gkcrVjJCGC8vDbj32EiR26frKmIlGbxGjg9sq4,4376 +torch/include/ATen/ops/gelu.h,sha256=o_PfwT3X96pxz4E1Snflw58SBCZNHP34Ey1bP9I_P3A,1426 +torch/include/ATen/ops/gelu_backward.h,sha256=_FlEGY1Bt0-CZVYWaJ6g8krJozTWLHc1JeXKhSGqCKc,1568 +torch/include/ATen/ops/gelu_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=LidVJsBV89MRQr3-axMjIZsLSlqtgRZAHntThFq8Q3g,866 +torch/include/ATen/ops/gelu_backward_cpu_dispatch.h,sha256=s3vhJTpyR2vxSRSiTK_Rm7UP9PFMP0P_6_OBimi3WW0,1112 +torch/include/ATen/ops/gelu_backward_cuda_dispatch.h,sha256=k_NUWbnYLchjNuqtoG2Sfp3nQztbT7vc3SosGypmcG0,1114 +torch/include/ATen/ops/gelu_backward_meta.h,sha256=jdOvRDCPTOeYMIUyJXhkyKAGfMd-a96PSCwASiPD7sM,655 +torch/include/ATen/ops/gelu_backward_meta_dispatch.h,sha256=85Piox3vP6LC_9ZdrLu9ZNBC77VqyBE2gYi3IQ8Z7E4,1114 +torch/include/ATen/ops/gelu_backward_native.h,sha256=rpkNTKtqa9LSLHlLkTPL0EZhJiA6g1kvIqBpn2yUt4U,1205 +torch/include/ATen/ops/gelu_backward_ops.h,sha256=TkSG-ntI2ddeVEZ5zxDLf-ECmlUORpxS2u8m3DyUfFw,2089 +torch/include/ATen/ops/gelu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=eLvTVbIYed1-qTh8AdWPZ96wGZRm-sWy3zmc_BRBx0c,911 +torch/include/ATen/ops/gelu_cpu_dispatch.h,sha256=FZXTnR5XNKvMoV-RDTWezdASU2cKU2z4w7DEhy8S9qQ,1061 +torch/include/ATen/ops/gelu_cuda_dispatch.h,sha256=AZmXiQ0RjUhtnv_KIoDA1DKqh8kEy3BOCblP73l09_c,1063 +torch/include/ATen/ops/gelu_meta.h,sha256=HLKy7OtQkPm4YxHDO0sVsD3NCiAWLGUTreDsxnXdsbI,614 +torch/include/ATen/ops/gelu_meta_dispatch.h,sha256=JFOhpdjAQkT_e7FEnHbujceWux7UHLHPuMA8H3ue83A,1063 +torch/include/ATen/ops/gelu_native.h,sha256=FBDuyYE7UIMp2u1HKsWfVXYFOIoh9geuGd1Wiius5gE,1411 +torch/include/ATen/ops/gelu_ops.h,sha256=jcv8wIbypkRCALP6kBMEXrE1xF-E7M2oFKahCrC_63o,2416 +torch/include/ATen/ops/geometric.h,sha256=oKMZ6DLGzT-peJCz28tBwmr0OxLl-Jx56utAdRklSlk,1374 +torch/include/ATen/ops/geometric_compositeexplicitautograd_dispatch.h,sha256=LAMCdh3tayskneSjtzuMnn9dOP60ITlF79-fGmlnRwM,1106 +torch/include/ATen/ops/geometric_cpu_dispatch.h,sha256=Z8K3c2XaKRpGUi4O56fqJVzMewMxZ0_49kat0ont5OI,783 +torch/include/ATen/ops/geometric_cuda_dispatch.h,sha256=eO-ra0e8vT27M_ikL-S19kqlKRk9qAxRuhKVhC5gTAc,785 +torch/include/ATen/ops/geometric_meta_dispatch.h,sha256=b1fjiEI4CiJzOdjtwVrwCO_0VmXqoWMwmj-Igu1RZwg,785 +torch/include/ATen/ops/geometric_native.h,sha256=EDDwWauLAz3mX-ZVLb8_qcOmkufnOehyuTXJXXAV2tA,801 +torch/include/ATen/ops/geometric_ops.h,sha256=Sr53kn_VWl_Ek82_kuTSKVVunqmkhBp2-IXEOH_EJUU,2677 +torch/include/ATen/ops/geqrf.h,sha256=KNOGNwvu1p2baivRbldQKIK-gKWTqLqDh8OZixM1Ax4,1198 +torch/include/ATen/ops/geqrf_cpu_dispatch.h,sha256=MnTJuO9R1jrWbFLy79DU4MIAXQXgFvmr8cSHQWsoNkQ,985 +torch/include/ATen/ops/geqrf_cuda_dispatch.h,sha256=WQip14-Uo9guM7oBv7vdJsptgdJ1nbf99KMgo07ItYU,987 +torch/include/ATen/ops/geqrf_native.h,sha256=vMc_ZdQSL20pniiisAgir5qL17FNzaeYwNkD57gm5tU,631 +torch/include/ATen/ops/geqrf_ops.h,sha256=pM37zThjjJLd7PMfwuzvx9nKUNeEXPSoDB62-K6sET0,1830 +torch/include/ATen/ops/ger.h,sha256=AxZD9ZTsrn2P1X-rPrDKPvW-HRuy03IxmAsFC7YMnr4,1117 +torch/include/ATen/ops/ger_compositeimplicitautograd_dispatch.h,sha256=y2TnESZk-XQq0Puu_XfqIxCW8LQ8T0yZor9bL-vYC3E,987 +torch/include/ATen/ops/ger_native.h,sha256=e42lXzzHG9k4irOznudfFb20VbLbcVQJ5IVxVHS0emA,609 +torch/include/ATen/ops/ger_ops.h,sha256=JiSjkYG7eqLEvo5RtLTENFaVoq3yI51tzOJLxswMJrA,1738 +torch/include/ATen/ops/glu.h,sha256=5m7FaJs9Ms9IjGPKYfKpZ_l18NPgT3pukwBprRYSYjc,1081 +torch/include/ATen/ops/glu_backward.h,sha256=6dPSW1ei0AAl2jI7fIxtfugH72glsFnxAmOTTKIxO7k,1421 +torch/include/ATen/ops/glu_backward_cpu_dispatch.h,sha256=lQ4iPRYT1IvRyy_f06PnowzyH8oqxKhgyBPFO-AWGjo,1044 +torch/include/ATen/ops/glu_backward_cuda_dispatch.h,sha256=ElFssOj8pVG168yy0E8uiyTUFDWI9hGuWIk9koiH1AE,1046 +torch/include/ATen/ops/glu_backward_jvp.h,sha256=YhvquPF2S9JTIqYCZchXHSrtirgpU90eBeGu7jQU_bY,1778 +torch/include/ATen/ops/glu_backward_jvp_compositeexplicitautograd_dispatch.h,sha256=YarW-uwH0b0Ejr6MYuGMQVRgvg92VO0Y2cuFeCr-oWE,1125 +torch/include/ATen/ops/glu_backward_jvp_cpu_dispatch.h,sha256=Uo4n8sIPyTkP1BABdijnJXlCIkixZlS90aeVg9lYGyE,849 +torch/include/ATen/ops/glu_backward_jvp_cuda_dispatch.h,sha256=kTS7w4HjDPgtHfCRyPae5Bas41-DCaQ40XQsYt2k5Io,851 +torch/include/ATen/ops/glu_backward_jvp_native.h,sha256=yTE3dHdzoWpcXOKysWpbWZj1cQy38XUw6GL-KXLAsWI,823 +torch/include/ATen/ops/glu_backward_jvp_ops.h,sha256=78VafEYwVaCZQSn7Ru3yc1oUbkuubAHvuAgU5UQurps,2438 +torch/include/ATen/ops/glu_backward_native.h,sha256=a31uCulmt2euBrwUkgX7_VT2orGeyDovNSnsJHxs4bQ,933 +torch/include/ATen/ops/glu_backward_ops.h,sha256=XG0-W9vZqA6XHuGLOjahZB0ux9GLStEE9OM1fFr_pYs,1964 +torch/include/ATen/ops/glu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=uYoGBVMBtBeSUbmPmOaInltz-sUUTCkVJAOK0u56tC0,803 +torch/include/ATen/ops/glu_cpu_dispatch.h,sha256=crP-5fbYrSPl3-M_poyyfcflvxmAHKYvAv21WZoDSLc,913 +torch/include/ATen/ops/glu_cuda_dispatch.h,sha256=l1TPcyaWIMpbNf8mPbeATW_FComn246sWixL6Fal-YE,915 +torch/include/ATen/ops/glu_jvp.h,sha256=wy0KOIDQFk58Do2nAXXaeWYLS0PmfQYXA3hz24h86hM,1316 +torch/include/ATen/ops/glu_jvp_compositeexplicitautograd_dispatch.h,sha256=k_lw9-e2cU3fU2gtT7T6Ks1ICKswtwxGlnAd0fRCdLc,983 +torch/include/ATen/ops/glu_jvp_cpu_dispatch.h,sha256=CNgzSjRKNFmB-qot4tuHWPzgzv-NPDmHh5EncwoQCmY,778 +torch/include/ATen/ops/glu_jvp_cuda_dispatch.h,sha256=E3eGmMAoXJBHHQM9R6O-i5mJxfvTmVsFQ2yRQobwv-g,780 +torch/include/ATen/ops/glu_jvp_native.h,sha256=D6MUD5GvRXfNs5fRUnEDP7y8UfnFtHJfOS8EYeWrH5Q,681 +torch/include/ATen/ops/glu_jvp_ops.h,sha256=lBK0hhzYwIM8w22sr2s5KNseYwG0aQNvPcn1vd6lH3A,1980 +torch/include/ATen/ops/glu_meta.h,sha256=9JcmH5oo0MrMcfJZn4Y03rkI1f-oxXBIzGldVMPHkT8,596 +torch/include/ATen/ops/glu_meta_dispatch.h,sha256=Xwf774Ourowh70eqFz9gBQP0VdSoCJ4xAG5OYR1VqOM,915 +torch/include/ATen/ops/glu_native.h,sha256=-8LxErNztAcsitB71eRgIa2BrSUnpIoqI27WuCY5d1Y,611 +torch/include/ATen/ops/glu_ops.h,sha256=fYbX9FWhQenJNLIBMFkQ1K2uEVtnQrg7LjmYFB-LEGs,1666 +torch/include/ATen/ops/gradient.h,sha256=F3YnsSSCSOP24ykfQowApYVSpzDbHZE0lHlzPTNF2QA,2844 +torch/include/ATen/ops/gradient_compositeimplicitautograd_dispatch.h,sha256=JA31DwgVLXRiobvy6e8eE_MCVIdV8tv6jEsCvAdH7vY,1768 +torch/include/ATen/ops/gradient_native.h,sha256=qOevmTtJPWODbm2YZ3WWkoa7UYi7ixOOcJs7d66-EIc,1491 +torch/include/ATen/ops/gradient_ops.h,sha256=rGMwYjejtCT9gennPIYm1xwP42-HRo5EEfS-2mtNIEI,6456 +torch/include/ATen/ops/greater.h,sha256=giYL0CSsI32g8n8JzNm_yAc_IFtZCkgYMQ9l4emJJWg,1925 +torch/include/ATen/ops/greater_compositeimplicitautograd_dispatch.h,sha256=lbKvwzKcV77BSoYL8-6um4kdEKKIRWCAWz7fK4PWVjs,1450 +torch/include/ATen/ops/greater_equal.h,sha256=OBcwAiuMx49_5_92P1GXHmTzGz7PvKEGRplFryB8AaU,2039 +torch/include/ATen/ops/greater_equal_compositeimplicitautograd_dispatch.h,sha256=5PVSe4ZwHrBnH65M_m1MlSlnfQ4tb5uGqajsmHOoQn8,1498 +torch/include/ATen/ops/greater_equal_native.h,sha256=IIuQIg1zgWB2CAJVMfltjA2lhLoqw1VbOFpT7aSr2lk,997 +torch/include/ATen/ops/greater_equal_ops.h,sha256=v9zJcRoXdyHo1cdB_KhlgDOGshqCzjjZNWRur0mTFB8,4574 +torch/include/ATen/ops/greater_native.h,sha256=w_E1ehCVbHNHgL6h1dMehZLk2Ofy9kIF_DF-KVsP5uk,961 +torch/include/ATen/ops/greater_ops.h,sha256=9mop-4kYGEcn7VQ2QwZ6ApMSHNQBANgxZTQt33UBT6k,4466 +torch/include/ATen/ops/grid_sampler.h,sha256=RTgMWZ5-mmAYikL9q5BG-j-slf1RsrBpu8ltzC9EL70,877 +torch/include/ATen/ops/grid_sampler_2d.h,sha256=_uwLPcPMNu7WXDV6yEULwIspYszepzOU688HF9uxBPo,1789 +torch/include/ATen/ops/grid_sampler_2d_backward.h,sha256=0xRLk1BQLhJctkz9Y0imxTPImgwNtNmm5SSD9-dPe0o,2485 +torch/include/ATen/ops/grid_sampler_2d_backward_compositeexplicitautograd_dispatch.h,sha256=WF_mk4Q5ON0IqLSvXq5i8grWGrU1gJt_mFZKGfz_foY,1321 +torch/include/ATen/ops/grid_sampler_2d_backward_cpu_dispatch.h,sha256=rRMAfwtGcudMQ-ggTVDQk3XfT9Arxb01xT2zT3OpvsI,925 +torch/include/ATen/ops/grid_sampler_2d_backward_cuda_dispatch.h,sha256=ie6KxsszaVT2Rl1w38llNRmByVIIV8_jAHNiQxVlqL0,927 +torch/include/ATen/ops/grid_sampler_2d_backward_native.h,sha256=iyd8lRwjvUvgoXyGTk6YlK7ct5j9hlf4Lwi69Nw66_E,1265 +torch/include/ATen/ops/grid_sampler_2d_backward_ops.h,sha256=fpGfE_u9yyOkhN_uYCtsRqoY7qC8QKsfIbRaDHN95LM,3004 +torch/include/ATen/ops/grid_sampler_2d_compositeexplicitautograd_dispatch.h,sha256=DdZ_puSwkm2nGBdv1fUrqB5c3kLMdkfzJTChUl1WNpc,1077 +torch/include/ATen/ops/grid_sampler_2d_cpu_dispatch.h,sha256=2Y4cKMMiJkyxfCNkyuIdVnWRDeoQtmvZ-fdIBKIDZlw,825 +torch/include/ATen/ops/grid_sampler_2d_cuda_dispatch.h,sha256=tnSJZgv6YQ2THedSiB7MDkgF3eh9xBKPDQaSCicxupk,827 +torch/include/ATen/ops/grid_sampler_2d_native.h,sha256=I30SS9lHH4z2DjOtDCtTonZPO0ZT0qvdD_crA8dI4tI,943 +torch/include/ATen/ops/grid_sampler_2d_ops.h,sha256=0p9hEWk1UgijXQrY4_hPQVjAYlPkS1z82y4qxcdeHLw,2268 +torch/include/ATen/ops/grid_sampler_3d.h,sha256=6nHli5ddTm5VN11jqdD7sDtnvVtlCWdDGSC4gQRgctc,1789 +torch/include/ATen/ops/grid_sampler_3d_backward.h,sha256=S_rIfNpDK0CG2pvZd3Ossp1qHT7KhCtp_kKB3uVVw2A,2485 +torch/include/ATen/ops/grid_sampler_3d_backward_compositeexplicitautograd_dispatch.h,sha256=ZbI7r9KSyNaoT6U4fM6FjD2x1id-RThaVn02AXYMIz4,1321 +torch/include/ATen/ops/grid_sampler_3d_backward_cpu_dispatch.h,sha256=kD7aG-f4_nkVLdoP8XpzU8isEZkvEOlF8kaWy7L7OYA,925 +torch/include/ATen/ops/grid_sampler_3d_backward_cuda_dispatch.h,sha256=gKxrdwb-2IT51ijl8PXANrELMJgsmkeTifAxivYBGHU,927 +torch/include/ATen/ops/grid_sampler_3d_backward_native.h,sha256=5pn1GO4v1zr6b_bIxXFMEK_X4UjAyHa_YKh16N8w1Gc,1265 +torch/include/ATen/ops/grid_sampler_3d_backward_ops.h,sha256=Bhxg0yA_Qe1t2KEdmVEW2N1bmE7VZR6SNzEVVNUFuu0,3004 +torch/include/ATen/ops/grid_sampler_3d_compositeexplicitautograd_dispatch.h,sha256=iYQyA7rCoJ94mqtNvDWElBk1cVQahmB2pX6HCkjKGbU,1077 +torch/include/ATen/ops/grid_sampler_3d_cpu_dispatch.h,sha256=hH2MXILS_78WmrIAiejNC2j3qreFWT9fGlCuWY5uFwA,825 +torch/include/ATen/ops/grid_sampler_3d_cuda_dispatch.h,sha256=u4IULs0PcIya_JzRwIKmqp0axB2qsIqJkrIH8eRWR54,827 +torch/include/ATen/ops/grid_sampler_3d_native.h,sha256=HhK46FD7o7694rYiZsQIzDARggYYQQh_rxxvt12qhYc,943 +torch/include/ATen/ops/grid_sampler_3d_ops.h,sha256=YOJhka4TZVz9tRmPeFEODmHgIAh2P3BGh-c9pr2sut4,2268 +torch/include/ATen/ops/grid_sampler_compositeimplicitautograd_dispatch.h,sha256=4lhrlXaY14QaSNZOXYJ-5TlDARdmL0V780NgdiQngDE,866 +torch/include/ATen/ops/grid_sampler_native.h,sha256=B-O1H-G7iyki3Ye_nJYVSkwYFEjhoRcw0IjC9eHCedY,589 +torch/include/ATen/ops/grid_sampler_ops.h,sha256=Ef3IvwsM168R5yAFTqdoX5JWZcPBwKfkFyl4gj65V7w,1297 +torch/include/ATen/ops/group_norm.h,sha256=dAxxSIG2uvSNxqZ9BdDJ4XlfYoE98XJomoZZrLv7AFg,939 +torch/include/ATen/ops/group_norm_compositeimplicitautograd_dispatch.h,sha256=uxl8MIt9AUXjbw_KbV4r5inBPqVyFiKdGavuoInUBLw,920 +torch/include/ATen/ops/group_norm_native.h,sha256=7el8Z9ycPGZv3N-9HkuHRwczpSoR4-8oIBsfVEEpB2Q,643 +torch/include/ATen/ops/group_norm_ops.h,sha256=sOSwbd6XnVXfqQiY-JVBN0lIpmyeRHkv7AstTn1qANQ,1441 +torch/include/ATen/ops/gru.h,sha256=9GtJYe7qMyah6hHtPD3XExKoB-Pa-DP0Dd_fCx4RWvo,1560 +torch/include/ATen/ops/gru_cell.h,sha256=SKKR4CoazV-KBpHYRfnOcke2l_y4uJ93EUMWegFNFLs,898 +torch/include/ATen/ops/gru_cell_compositeimplicitautograd_dispatch.h,sha256=lwqvaEk1Otp5ydSn8yAYZKNHFlky6aPXbwhClxFBbOY,926 +torch/include/ATen/ops/gru_cell_native.h,sha256=0uuDV_FMrFjVaI8bUx3HvnWkVeynANJZNHgA4FiH9Kw,649 +torch/include/ATen/ops/gru_cell_ops.h,sha256=K-hcXOO1ubnpFfYt3EVC_-jYM_FtMkkqBoJIQ__Uj4I,1487 +torch/include/ATen/ops/gru_compositeimplicitautograd_dispatch.h,sha256=xe0XpYVnxpc-1irRWnb_RBp7aHTIc6TB5_310usWhW8,1175 +torch/include/ATen/ops/gru_native.h,sha256=VeiH1Z8-LzrRy5hdlCLxzXBm7BNVFnBVvm82EinpefU,898 +torch/include/ATen/ops/gru_ops.h,sha256=VpqIa6ZCY-a314jkKdYZH21JrrS5-Z2_D20_rtb_zcY,2732 +torch/include/ATen/ops/gt.h,sha256=bwELFL2hwhiwcbx27TpAEUTC1i5oO7oCag-jG4wboRE,1830 +torch/include/ATen/ops/gt_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Z2sQFPwBYrYYaz7bYFG7f1Rbyc0lzuLB6j0FmZdm_e4,1034 +torch/include/ATen/ops/gt_cpu_dispatch.h,sha256=KvaYtu_1mtuxBINrePTunv1ibkZ9j5jbvDQKH55X8Zg,1366 +torch/include/ATen/ops/gt_cuda_dispatch.h,sha256=22MIm_dB38x-ppbu4fTD2OFy4SCwOKR8aQrdqh5dKVY,1368 +torch/include/ATen/ops/gt_meta.h,sha256=XLrkF6aPk1XbVnnpXz31mL6Zp1A1FHI0yjOIwx6k_DM,762 +torch/include/ATen/ops/gt_meta_dispatch.h,sha256=1PUK0yKZPj9DMvmkqw0uyxD2HqpSBrnVh2r-4Joyw-4,1368 +torch/include/ATen/ops/gt_native.h,sha256=OHirF20pLeqaDphZMvYQmDVQ2mYUY6jkXKLag4G89d0,1306 +torch/include/ATen/ops/gt_ops.h,sha256=OLFyTV7TwK5E1ThATW9B8JfHibINNwRbLfRCc7k-8Oc,4376 +torch/include/ATen/ops/hamming_window.h,sha256=ThTW-uChLX_6hGm8Hxy9aeh1ycIcFA-DmZwaHZyIrSA,6994 +torch/include/ATen/ops/hamming_window_compositeexplicitautograd_dispatch.h,sha256=n9RJ-g5xg_ZJl7-c3TG4VT4BItR3MPNDCBywQNi548I,2878 +torch/include/ATen/ops/hamming_window_native.h,sha256=Et6cj2f1d3Tb0DQLvHmMdXqzOm6bR3wS24Yr1qgYHA0,1821 +torch/include/ATen/ops/hamming_window_ops.h,sha256=lW8IWLwGacy7rVVJ77qle8vmLqLrrvg0bKajbCn8Hu8,7921 +torch/include/ATen/ops/hann_window.h,sha256=yRYolhtHGNYKKzo_n9wHqBqvanbn1eX8kwcQLa-n22Y,3289 +torch/include/ATen/ops/hann_window_compositeexplicitautograd_dispatch.h,sha256=DCFSNg084xIU9_9Jaj2OYbbZtLheCvCNAv5J0W0Oz74,1658 +torch/include/ATen/ops/hann_window_native.h,sha256=4_u3wfuDdzwokE_YTq2VbdPyj2umqxGfeGMFULJopWA,1046 +torch/include/ATen/ops/hann_window_ops.h,sha256=KPRdpLRgVDtOzUJFXfdv0E6HhHptvWBcwr8FWimod2g,3869 +torch/include/ATen/ops/hardshrink.h,sha256=9UvG5v7JsDImkgW5SDYuj-_6ZWu96tuMo9dsKoTmJ9s,1216 +torch/include/ATen/ops/hardshrink_backward.h,sha256=p0bx0k9QfpNce9xevGo1ZePFEOTBbm_5NcoVyl51dIs,1524 +torch/include/ATen/ops/hardshrink_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=T97Gh9wvV3lqj-8FMqWKimFZCd1BDLJhaIGjh_oWe-E,858 +torch/include/ATen/ops/hardshrink_backward_cpu_dispatch.h,sha256=R6_yNVq93aeFWmIJQwtUvpO7ZWcNeFPiRQvJb3eZ0yM,1095 +torch/include/ATen/ops/hardshrink_backward_cuda_dispatch.h,sha256=FIxyjseyeGX2SM1DHrf3X1B0fniRAlp1C2-kyZh_vvw,1097 +torch/include/ATen/ops/hardshrink_backward_meta.h,sha256=jJFW_Mp_m58wtrST6Q2XQh1ZPHqVpXFyTIG8IvR5jk4,654 +torch/include/ATen/ops/hardshrink_backward_meta_dispatch.h,sha256=N4bTge3dwG34fwY83eeqGt-tC70WprBB5R25iPgkMB4,1097 +torch/include/ATen/ops/hardshrink_backward_native.h,sha256=JlmxV9IWduBeBzHSf2zbzRNRqIFiUHDnwugKfgQhlGs,708 +torch/include/ATen/ops/hardshrink_backward_ops.h,sha256=n3HibVd1chiWVLvnD_fnA9NbJ5x6YY4qhvFgkIze0K4,2072 +torch/include/ATen/ops/hardshrink_compositeexplicitautogradnonfunctional_dispatch.h,sha256=BEljD7K-wbeB9zh-lTiXgJoHXH4E68zTp2V9R1hGbC0,824 +torch/include/ATen/ops/hardshrink_cpu_dispatch.h,sha256=5br9nPVtUGtCf2nHZ0HOmQDi1Q2D9ZBhbhadwBIayas,975 +torch/include/ATen/ops/hardshrink_cuda_dispatch.h,sha256=tSLTM6Ml5Sl89xFsFfxdEqr62V8QIc85fFqEj7AFIDE,977 +torch/include/ATen/ops/hardshrink_meta.h,sha256=8oFsf8IVNTBwJxVg4uzYR1OW_N3EA1N2OtaH5cxVtMA,616 +torch/include/ATen/ops/hardshrink_meta_dispatch.h,sha256=rzvVtNptBs_NW14dR1Y2efGfTJGzMzanxGYHSM25--s,977 +torch/include/ATen/ops/hardshrink_native.h,sha256=ffUxSRn6fjHNQm9C5WL7_jH7vCklBnR4kzdArr4MDxo,645 +torch/include/ATen/ops/hardshrink_ops.h,sha256=re3NgmdlL7PmiOlhySkwbIrggNLOqM9NPn3njOXD64s,1794 +torch/include/ATen/ops/hardsigmoid.h,sha256=6s-Puvs3aSWXvtNN23t-fxZzFz3vkWzAloqn3HZftUE,1222 +torch/include/ATen/ops/hardsigmoid_backward.h,sha256=VnHvY9yEenYd5DmQ1E8K3yocY7tkXKLMyRVyBHWFKQ8,1420 +torch/include/ATen/ops/hardsigmoid_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=2mr7MsdmJNhyb9nJ09L7eGAk2AHhQUP2FvUUF0z_LMM,836 +torch/include/ATen/ops/hardsigmoid_backward_cpu_dispatch.h,sha256=f-SY4XsJM2VoT_mdgI-0Y6Lv5Qtxlyah1N61MT0DjZE,1029 +torch/include/ATen/ops/hardsigmoid_backward_cuda_dispatch.h,sha256=V-FVIqG8zbPeVBh4CbZlQQymph4aWIfXTm-Vq0Nx_GQ,1031 +torch/include/ATen/ops/hardsigmoid_backward_meta.h,sha256=NX0P0x6hMnGz44aS_4fGDk87HgjXPdAUxL8LFBXk4Dk,632 +torch/include/ATen/ops/hardsigmoid_backward_meta_dispatch.h,sha256=bwhCBuN0XZfiladaNyJqcpMITZEtxEk_jaix3YI9vRU,1031 +torch/include/ATen/ops/hardsigmoid_backward_native.h,sha256=LdUM_J9-7oVQvDCIqm5f-xYm_85G6YndrB2d2LTkBas,688 +torch/include/ATen/ops/hardsigmoid_backward_ops.h,sha256=_ovJBRMzNPbfhKk18r3dfn1xeO1Tv09sbs8MgDnB0no,1924 +torch/include/ATen/ops/hardsigmoid_compositeexplicitautogradnonfunctional_dispatch.h,sha256=xhn5O2eYc0MdXm5NeL1kFCAzwmdAuZFSog28gALPnks,851 +torch/include/ATen/ops/hardsigmoid_cpu_dispatch.h,sha256=q53Nkv8F3mXxfv4NiRwzv2UbcI3w4zvBD5vIFSjcFtI,948 +torch/include/ATen/ops/hardsigmoid_cuda_dispatch.h,sha256=NxtvQvKoB4EGWbZChNDnwU49Wk6UZBqTjb-h7ZDC17Q,950 +torch/include/ATen/ops/hardsigmoid_meta.h,sha256=IGl1CK_S0ZL1QQWmFxiK_JNb2aZsuUJ2agGKqT6UB-g,591 +torch/include/ATen/ops/hardsigmoid_meta_dispatch.h,sha256=hH-nL7cRx3mPwN60hn3aPB5HjzCz5Ttn3OfhodRCeEI,950 +torch/include/ATen/ops/hardsigmoid_native.h,sha256=LpNzfVC9aOb7pl3MZ35WmoXVj1qdJt2zB3Vvgj9vOtM,792 +torch/include/ATen/ops/hardsigmoid_ops.h,sha256=Q7Lcqp8k1e39Tx2nNrY0lr3luTi73ckXDBXLXYkXxik,2167 +torch/include/ATen/ops/hardswish.h,sha256=r-cH6XpX7eiK3xhG2PcPivkvmpspfU9Gc-VhxA4Gal0,1196 +torch/include/ATen/ops/hardswish_backward.h,sha256=dE2_bxfy4hYuVCPBPKh-B7bhD3Se_UHvvBxsWmDOP_k,1330 +torch/include/ATen/ops/hardswish_backward_compositeexplicitautograd_dispatch.h,sha256=rTgzA7AqtQGOeR4PK7ZDMgfqW8SDY5gY53CVc3yjoY0,955 +torch/include/ATen/ops/hardswish_backward_cpu_dispatch.h,sha256=HMty385lv2s0mC6Qj-c4UJAatCRzLrPOKwSV3JjjN2Y,764 +torch/include/ATen/ops/hardswish_backward_cuda_dispatch.h,sha256=PyhZciayHwqkWVRVM-51kiDfHh953Y9wBjCRckH1S_k,766 +torch/include/ATen/ops/hardswish_backward_native.h,sha256=hYEuBJz1E9L2swLGI4OpH4kDTo7AvfV3gsaSJx5tQn0,653 +torch/include/ATen/ops/hardswish_backward_ops.h,sha256=x4LL9nUk4zn-3vFUJ35kp8xG7yIJRzC8Lpr9ENXlR_c,1870 +torch/include/ATen/ops/hardswish_cpu_dispatch.h,sha256=kBXk20TCrpj5cd2PEP3wqVuQp_fzOZKFo5l5KxtyjSU,940 +torch/include/ATen/ops/hardswish_cuda_dispatch.h,sha256=jhpVRHRjJIK75jVRIdaMuAe40RtUFSC9FJjJHZdca1w,942 +torch/include/ATen/ops/hardswish_meta_dispatch.h,sha256=u0i5X_UvWqpMAbS2rrq8pQ1ZL7nAbaGZc6ZNqpK4eEs,722 +torch/include/ATen/ops/hardswish_native.h,sha256=3VT_TXckY1AWcbVRrsehRbjq-h17SpEhLwxzIM9d2zw,625 +torch/include/ATen/ops/hardswish_ops.h,sha256=xX0OSIUyE_WcPaWylVAt_gFoGWuIlisT3Fmux5saIw4,2149 +torch/include/ATen/ops/hardtanh.h,sha256=k8U2NS2JBQJOFABm4bY9Cdhq3RUCRgZUDbcKD9ShXDg,1642 +torch/include/ATen/ops/hardtanh_backward.h,sha256=okY18kvDaGNtW45Ve9vXgEHX8uwR9QshwE8-0ysLFfA,1708 +torch/include/ATen/ops/hardtanh_backward_cpu_dispatch.h,sha256=55Pc5PGjsQV609SFGDkUWnRUI5IdZdxWz-imeAfqqQo,1188 +torch/include/ATen/ops/hardtanh_backward_cuda_dispatch.h,sha256=cF7u7AY9huzUCIkXagwnALAjDoDGRYQDd0lulmCa1AQ,1190 +torch/include/ATen/ops/hardtanh_backward_native.h,sha256=r5IMNHApEKwFoS9dI4zBRbhCdgCeMx7V96nAcePXE14,770 +torch/include/ATen/ops/hardtanh_backward_ops.h,sha256=NYpcsVaOMf68JeE0LQC8HdGU8yB756FAj1ZtwWhy5dM,2274 +torch/include/ATen/ops/hardtanh_cpu_dispatch.h,sha256=8W-va7CImYRRCHdu0YuvCWFmw1grgFK-KXl_x9BGCtE,1175 +torch/include/ATen/ops/hardtanh_cuda_dispatch.h,sha256=XF5uz9yI7n4I-ynsUPla4agbeJmbbrnqazzLO8PtR3o,1177 +torch/include/ATen/ops/hardtanh_meta_dispatch.h,sha256=k8nJkKne2QxLnQ8MQPKQYC6av_dpoCGzEtzx4331vvA,782 +torch/include/ATen/ops/hardtanh_native.h,sha256=IOPXsd_nnyVY4wvsNlPEIj2VVgB6XeeoHn_rq0siy7s,1209 +torch/include/ATen/ops/hardtanh_ops.h,sha256=zwr6I51K7So9OsNqp3PRGeFq9qBeCqqbNK84ksIYOiQ,2707 +torch/include/ATen/ops/heaviside.h,sha256=RBBVsqhddfM36gb8zzO_EoHHslzbWRjjgieEYS7K0eM,1195 +torch/include/ATen/ops/heaviside_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rY-l1c0Jc7NU52e_G7kjORTH1MJviPxztOjWnHlp6J8,901 +torch/include/ATen/ops/heaviside_cpu_dispatch.h,sha256=5E2gw7PJtq3v7vSLkmeWtg0JsWNG0oxrhlbAMaFSKkg,1048 +torch/include/ATen/ops/heaviside_cuda_dispatch.h,sha256=vTspqK5PZ2b0wB2ehC_ykhevPvzkZBqO6bM3mEQWmws,1050 +torch/include/ATen/ops/heaviside_meta.h,sha256=9lGFa_kIGlucyEQvQWNLD2ZweAwzTaxPH1e4mFfDj8Y,616 +torch/include/ATen/ops/heaviside_meta_dispatch.h,sha256=VzCDZYncqqHuScrY6tURCAgJMHwBKXnLW-fgjakdeWY,1050 +torch/include/ATen/ops/heaviside_native.h,sha256=ciKiuT20YBvHfv00hog_rYPTSDZaoeLwC1s0lXRWkvk,643 +torch/include/ATen/ops/heaviside_ops.h,sha256=w9NuGJLGaXv39W8D9C9RRsAkhbDxRrtLESfmWXGNp48,2416 +torch/include/ATen/ops/hinge_embedding_loss.h,sha256=yXYUGU-DAOGBIdlQfQshVFIFwMIQL8uC-0AmrWWQpyk,846 +torch/include/ATen/ops/hinge_embedding_loss_compositeimplicitautograd_dispatch.h,sha256=4OceJCjlx2p7D1zTgc_DqrX6lU1epB_nwcQogI_bVAM,863 +torch/include/ATen/ops/hinge_embedding_loss_native.h,sha256=EFdAC1GfVEpp3UbjlSJzYANCF9SHmzXnMSoOckjjpfA,586 +torch/include/ATen/ops/hinge_embedding_loss_ops.h,sha256=tDiCV1-rvy9wAsxUxtmnhO0whDjHeipb4-PFLfPkPLM,1221 +torch/include/ATen/ops/histc.h,sha256=CODy3VX8Zw2hF3ws26eK_kiNRnbsDh-AYGTYbSKXXL8,1381 +torch/include/ATen/ops/histc_cpu_dispatch.h,sha256=C0qiQXah9GCe-_OjxI_I4qnHg7dwPTIiQ-f4n5f0sws,1076 +torch/include/ATen/ops/histc_cuda_dispatch.h,sha256=J8Sh6wmvB60gW73XplingglyU2cNEbAGXvQ1EnNEgiU,1078 +torch/include/ATen/ops/histc_native.h,sha256=9RKkT2ZJLYyqPBJY2lZL7A-0RU021sJH5VZoQ32Etu0,989 +torch/include/ATen/ops/histc_ops.h,sha256=WM2ZHpRou6rquRVaHc0fVQpfAstuCg7Y4wshgYFXLfE,2014 +torch/include/ATen/ops/histogram.h,sha256=X28XbnzKnTkiadcJWFzt4UQmmnw3HqMq2-1xeiAXVDM,3482 +torch/include/ATen/ops/histogram_cpu_dispatch.h,sha256=imJw42oXsnMIM1eN6j1-9TDRfH4e7M8h_7HXN_h2kQ4,2016 +torch/include/ATen/ops/histogram_native.h,sha256=1SEyfVunIkKacjFtSjtLl7xvt8sAXlY_LuDGZnBBmc0,1286 +torch/include/ATen/ops/histogram_ops.h,sha256=YVaIF8CuBps6emH-6bSINfcsryVK2AFO5N4yHfOAoVY,4826 +torch/include/ATen/ops/histogramdd.h,sha256=QWRkcUSl9tU9jDSIZX82xiH71donBkvs-mKpbHjhQ5w,1929 +torch/include/ATen/ops/histogramdd_compositeimplicitautograd_dispatch.h,sha256=Wr3EbRp4w9l2LzKzkWmsJ6JL1QLskBf0hc0KpNgU5Pw,1427 +torch/include/ATen/ops/histogramdd_native.h,sha256=QlZj_V2MHfZNB5tuCnJZIqEhNOyImoQImdHYcRnX1JA,1150 +torch/include/ATen/ops/histogramdd_ops.h,sha256=Be2WjispCp9nIgkiTu-nafbWXujwlOWEbT0Iraq_xJk,3799 +torch/include/ATen/ops/hsplit.h,sha256=o48tduV14cDbos6du1FVNCxG_Agh7ozWRf9uV4CUWmE,927 +torch/include/ATen/ops/hsplit_compositeimplicitautograd_dispatch.h,sha256=VGu6nNlhjaBO0amvWPtO6gVWRbPoVnDUsA_C5U-BXGI,891 +torch/include/ATen/ops/hsplit_native.h,sha256=8Xy5LIrXwJabzTCQmKtBIK7Yt2F3d9kTV5ITa4dKl_0,614 +torch/include/ATen/ops/hsplit_ops.h,sha256=9zOHA_V6PbTjyq3y72I4axN1onGHnj9RqBvlOP2FzoI,1785 +torch/include/ATen/ops/hspmm.h,sha256=6YD55TxetAKHJxJiJ1erza4qsnMRkku3JhJMJEZ-hHM,1137 +torch/include/ATen/ops/hspmm_native.h,sha256=1RhEnTyOdJIHwlZe0FwsGt29_JlA4M1vgLIqrQU_-VU,839 +torch/include/ATen/ops/hspmm_ops.h,sha256=9z96VsjXVVeCFDtrcenbgdspZ83G5gAVj_LzMdtvbmE,1750 +torch/include/ATen/ops/hstack.h,sha256=SWRUv464mwFxZj6jLWwtFyCsvh_unuGEKCcp1envdb0,1036 +torch/include/ATen/ops/hstack_compositeimplicitautograd_dispatch.h,sha256=Zn5t1UPVI6QLC_chOuedSWl1gKC5V8PpacMcdmMvG4k,918 +torch/include/ATen/ops/hstack_native.h,sha256=X_cl73g7b2UI05S8jGsr04Onbne5e3Zt8bs_LcAEu-I,563 +torch/include/ATen/ops/hstack_ops.h,sha256=wSgDh8XOCLWaIAB-ql9KnCXbub5hcbyTGyQQRh22ALg,1588 +torch/include/ATen/ops/huber_loss.h,sha256=-NC5oSg99IyWrdonO4r5SA7d7Vpp6ETtlSQE73xEjq4,1517 +torch/include/ATen/ops/huber_loss_backward.h,sha256=xlMyV0chnFhlzhD1VCcU6uKZEUZZ3i2Bwoj2fDbLiy8,1769 +torch/include/ATen/ops/huber_loss_backward_compositeexplicitautograd_dispatch.h,sha256=oWwfQloaCaNs6W0cTMNX28N8m7s0paHjgD1xj-O45hg,869 +torch/include/ATen/ops/huber_loss_backward_cpu_dispatch.h,sha256=TUPK4NLqHjEZjCwAnV4RIqgmrQh6Dd_KpeYiv75xsDI,1047 +torch/include/ATen/ops/huber_loss_backward_cuda_dispatch.h,sha256=h0wjUErNkhjGs1lOtM8ZTlB4EQaWLXjOTVTutbS8vbs,1049 +torch/include/ATen/ops/huber_loss_backward_native.h,sha256=vhYubiwxs4Zc-AThn2OhPrHvBpc-0AnuP2AxA-M9-x8,782 +torch/include/ATen/ops/huber_loss_backward_ops.h,sha256=eRHzUZIa-uxRx5tyR9yCGWCoYgBYzAzsOhZJm3ukOog,2297 +torch/include/ATen/ops/huber_loss_cpu_dispatch.h,sha256=dD7sZyQq99M_2dm3ierMP0aEgJci-9KjsWlXJLxBhh4,1117 +torch/include/ATen/ops/huber_loss_cuda_dispatch.h,sha256=zSvgocqIkQGHSS_gTNWi5VOLpcdP3BLQPV69OQ8nQD4,1119 +torch/include/ATen/ops/huber_loss_native.h,sha256=61Vy2gt-_iPCN_EccXUQ7Hka0jKhVGe7XsG7QOHL6ow,717 +torch/include/ATen/ops/huber_loss_ops.h,sha256=1rTsrW6m1-Fb_0G3gDYV-Enm0HtZ2jGxUTROUHLBokc,2032 +torch/include/ATen/ops/hypot.h,sha256=Loadhpx2KbXyYFZYFMUaXI8qydasoYJ35GPqSiRJxmg,1146 +torch/include/ATen/ops/hypot_compositeexplicitautogradnonfunctional_dispatch.h,sha256=4mC-9q67le8qKcTvaUL5G0gqCimjGu6tcAR1tet5NoY,891 +torch/include/ATen/ops/hypot_cpu_dispatch.h,sha256=D-Oigt-GgAUHAFbSGynUZBAuWcGbJTDuIcOsMMkCH1o,1028 +torch/include/ATen/ops/hypot_cuda_dispatch.h,sha256=rp74Dn1pEKpjHS9GKzfg4vfIMKZ5h2SzkLG2nD1Q3BQ,1030 +torch/include/ATen/ops/hypot_meta.h,sha256=aR29X2_hAqAwlyh0rSu5GR58jR7MvJhLXyTmht3_EUk,611 +torch/include/ATen/ops/hypot_meta_dispatch.h,sha256=a3w2-mTk6qmemOtv4oLln2txtIRa0vM928tLSmdPySQ,1030 +torch/include/ATen/ops/hypot_native.h,sha256=ivLB8takVj-tNKRrcfebu7gU6jXhpX2EW20ScV2VdDo,630 +torch/include/ATen/ops/hypot_ops.h,sha256=ZXHdP2reacVZgN6lqYsxiU-ejwLLmh_mUNX22OLw8HY,2371 +torch/include/ATen/ops/i0.h,sha256=X8l3r_adpx54nvjHRjRHaM2fIW609lwyVCo_YFj_x4Q,1105 +torch/include/ATen/ops/i0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=TQVvSjHcOOwAB94DWCS8hAYR2Kp41H_y4-U1g1ADRjA,833 +torch/include/ATen/ops/i0_cpu_dispatch.h,sha256=6d_rlXT__vLzsO6Au-vcwQ0l7Wwrc8ce34VvENBsPKk,912 +torch/include/ATen/ops/i0_cuda_dispatch.h,sha256=KYkT6YopLjQE5A7YALQxaPV6LhpXvsg9QKVYHUahJU8,914 +torch/include/ATen/ops/i0_meta.h,sha256=Qg8FUgk0tp7YYFMUS83tUSNeHaKExlKBkvEHr7lRZnQ,582 +torch/include/ATen/ops/i0_meta_dispatch.h,sha256=-99oCMwLHT1cQ90-qkJP6wGMakMhrwaLrlhlttJN1dw,914 +torch/include/ATen/ops/i0_native.h,sha256=WOFD-JEhf2KwteSudsG8-xcmP_wJHsCIukFDRy2SdHw,595 +torch/include/ATen/ops/i0_ops.h,sha256=ICJNo1uFbXm-1LVvruLsV6pK4J1L_rnWb3nW22vdccE,2086 +torch/include/ATen/ops/igamma.h,sha256=Nhfo9sXR1IO6cxCP8Z5BpB9IL40bJ8pMynvs201xkxI,1156 +torch/include/ATen/ops/igamma_compositeexplicitautogradnonfunctional_dispatch.h,sha256=RXQ2KFbVDx_ojy1P6X5UJe23uev5w89sYC7Co1s4Cmk,893 +torch/include/ATen/ops/igamma_cpu_dispatch.h,sha256=Fb5tOPCCrdyNgaD1UEbVKTFfKz04oFA1LQPI00gQNj4,1032 +torch/include/ATen/ops/igamma_cuda_dispatch.h,sha256=jLdlickXI6czL8mPlP6703L8rswUST7f8ijnM-MfcDM,1034 +torch/include/ATen/ops/igamma_meta.h,sha256=eESpb9Omh6tocWQN7K5472G3vZsy9ytbWEDnpHWlBBw,612 +torch/include/ATen/ops/igamma_meta_dispatch.h,sha256=6J4N1rvt0ej8pgVYhR6toFZ0xZzw6T9rPN1YxxLeMpo,1034 +torch/include/ATen/ops/igamma_native.h,sha256=VEf3cesvU90SkYajoO278MZ43jydOvYMvwpHf3o9HvI,633 +torch/include/ATen/ops/igamma_ops.h,sha256=Cp_tw9o4drAq0PBvfuGzVF7r3fljdOn-pgvwZYs0L6o,2380 +torch/include/ATen/ops/igammac.h,sha256=Z6hoXeevL2rjPy47dBmWhvDPf94mQ2vj-J1LlfLJC1U,1166 +torch/include/ATen/ops/igammac_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rBlRimdNlBbYDlff1U8EpRMpzxNpxqpRW4F7Emy-I0k,895 +torch/include/ATen/ops/igammac_cpu_dispatch.h,sha256=ntIbXmvldHTviroBpPKuymzsrKL4Xml71CRXEuY1Ehw,1036 +torch/include/ATen/ops/igammac_cuda_dispatch.h,sha256=j92eayh8eWXGNxH_ETekv00BrtA3hKP2ODLhC2Hglvo,1038 +torch/include/ATen/ops/igammac_meta.h,sha256=ADoyvRiJd18cdAXS0Bze9STr4H5DR_zV3YugCZIOpig,613 +torch/include/ATen/ops/igammac_meta_dispatch.h,sha256=rE8v-jskpM9Mwjaxwbl7sWZjMZnxdBUv-AptmJlwU9M,1038 +torch/include/ATen/ops/igammac_native.h,sha256=R_u19bzzzCBJ656BNyntY5Nrh5clzuQbQjW3z0EGzGg,636 +torch/include/ATen/ops/igammac_ops.h,sha256=spGsIBBWFELZzx_lsi3Jhrm0ZI0QWZ2o1xrOpXapxCY,2389 +torch/include/ATen/ops/im2col.h,sha256=Yp_ZSa8JyYkdEoLMulG0VZWdUdaN5HT5a2Odr3n5VHc,1651 +torch/include/ATen/ops/im2col_cpu_dispatch.h,sha256=_jvIGHMby1azb2qp6vPKYQpvoWHBe9TwqWy_a0IKDVs,1189 +torch/include/ATen/ops/im2col_cuda_dispatch.h,sha256=hkQedhLXBQWIE7xSjgA6OqvEsg17-6HALcK1kMCPmws,1191 +torch/include/ATen/ops/im2col_native.h,sha256=sxnP22YE6193g-wYB6x-sVkcwku7W481dXi39Cgnwrw,1131 +torch/include/ATen/ops/im2col_ops.h,sha256=WTwpjFdGVc3XBfrJMh5SbclhsB_L7Wf0xEh7Kd8h3Zg,2278 +torch/include/ATen/ops/imag.h,sha256=q9wcx55tEfYLi3WwlTYTW1cUcdM1Hudcx-w3EMSs5HQ,623 +torch/include/ATen/ops/imag_compositeimplicitautograd_dispatch.h,sha256=k6fCdg6zHmwu0bceT5Z6Ojtpvc1Z4JEivk1aSSLa7Fg,762 +torch/include/ATen/ops/imag_native.h,sha256=Nmki94OCHq_v12FiKeLnj9PEbictN8zHicyTFo7Mrs0,485 +torch/include/ATen/ops/imag_ops.h,sha256=3Ud3uPJoIpoR5kfAUtVz2Z_S2fvkEa8RaF_uju5hojc,967 +torch/include/ATen/ops/index.h,sha256=Iz5Thz6lVZr6nUi8AjiqkydsorgTHlWnEySZnNMaZuE,1293 +torch/include/ATen/ops/index_add.h,sha256=4mHhWekmkbSspz9p7-0If__ii9kdsvK8VPGoPx_frN0,1917 +torch/include/ATen/ops/index_add_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jhkdb2fsCe29JTQ5J4K--HmYuspCmSa2JbZci2xBbxg,1035 +torch/include/ATen/ops/index_add_compositeimplicitautograd_dispatch.h,sha256=nIxcakQ_ZpfTNGdZS1L9dCgNGn6HVznqPm-eaCgBKk4,865 +torch/include/ATen/ops/index_add_cpu_dispatch.h,sha256=6Zm_b36B8uOa8RsK9oXnaz-jhAHU5gifS5XyEY66piU,1314 +torch/include/ATen/ops/index_add_cuda_dispatch.h,sha256=n7CoAI4atRcUGe0SydjiDDZGdiOT4tUyqVNkIdj9unE,1316 +torch/include/ATen/ops/index_add_meta.h,sha256=iKViqOrPxYOj4x66lJMrplp8Ry8fFU1Euo03irxA_FY,1155 +torch/include/ATen/ops/index_add_meta_dispatch.h,sha256=t5CO3gH4JaqR1iQSTHNvy88tA-r2yP6D_LvyaK-wNIM,1316 +torch/include/ATen/ops/index_add_native.h,sha256=RiDajMnZhitkut0OA5ixZrJiadceOiRJQIhJjoE_k7o,1111 +torch/include/ATen/ops/index_add_ops.h,sha256=CfW0biWusdOtMCMD8KF_gRmkcu05AS7CWJBJ5KeovXw,3967 +torch/include/ATen/ops/index_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XSOK0cC8ixsg0FxuUyNfIF9bNvHI7jZoqsgClDeVzTU,843 +torch/include/ATen/ops/index_copy.h,sha256=eL1jbBLEpCYlBOydbe5zmw3eEAjY9vAXqe0rtovA7pA,1722 +torch/include/ATen/ops/index_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ISW5J3en26MzCOfMFHTZe_N86uljfTObV34QLSBnVqo,981 +torch/include/ATen/ops/index_copy_compositeimplicitautograd_dispatch.h,sha256=qjT-iZD3PVfjtbgtGiYU_k-jkH8vsLT0Kp1sw1be1Uk,963 +torch/include/ATen/ops/index_copy_cpu_dispatch.h,sha256=CTfro6ukWFyG7DDYZFC2uA3pMzxr5A_asVDws8Y5-Bs,1208 +torch/include/ATen/ops/index_copy_cuda_dispatch.h,sha256=IigJtGqwuYS8OiEzXKcWQa-MjtqX8z7pm_jXGH6_RlM,1210 +torch/include/ATen/ops/index_copy_meta.h,sha256=N5eukO7RbJU76G6CwLssA2vNIdQ_v63feXCGU4k4hT0,1130 +torch/include/ATen/ops/index_copy_meta_dispatch.h,sha256=YGC5re08ZphuUm9unU6INs8CPExCTxRf8ADh8OLBMwo,1210 +torch/include/ATen/ops/index_copy_native.h,sha256=fwCGPQr4Qt3Mm1LD6_VeJxZrScE84UM9uzzPJIfpNd4,938 +torch/include/ATen/ops/index_copy_ops.h,sha256=xnlIDBkwgSfaIrYYUSrLs48RpaZHHde9lTjuQmstxhA,4420 +torch/include/ATen/ops/index_cpu_dispatch.h,sha256=J1YAQeib_CdMzAoN8WlXh8Mu1ZtTMS85OwT4OSbX39g,1036 +torch/include/ATen/ops/index_cuda_dispatch.h,sha256=YB5VaLSOmt7HLfXYnjuzu2hbH2m1KAPc5V0W8_qibLU,1038 +torch/include/ATen/ops/index_fill.h,sha256=-64PAEjuB8FN9X56ER5F0h1gysXg0F-pGhr9KjK5Krw,3086 +torch/include/ATen/ops/index_fill_compositeexplicitautograd_dispatch.h,sha256=NblXRgpfk8q9MDoExCKsyZqDFE2AnHDq8sIDuldcOvo,1546 +torch/include/ATen/ops/index_fill_compositeimplicitautograd_dispatch.h,sha256=Sn3-N4_ga-20Tz3pLU2xtbQ1Qwr4AabBL_YTp4XqWmk,1212 +torch/include/ATen/ops/index_fill_cpu_dispatch.h,sha256=h5A-lEM80B5lglKP_IZeGcdBvk_IcN0-I06A3ea6aaI,906 +torch/include/ATen/ops/index_fill_cuda_dispatch.h,sha256=jGuEpQzxFEbpk2b_U0L2Z0OSxx6W5iJ490S-gWbK12w,908 +torch/include/ATen/ops/index_fill_meta_dispatch.h,sha256=EZVJfy7fgCF9nUsh4e6rzOx6yfDQ9vX_aNnkwInYTOw,908 +torch/include/ATen/ops/index_fill_native.h,sha256=VOu69b7fk5nA3K9MdW9NwVi9MpqDC-ZXHfsXyCFrdIo,1737 +torch/include/ATen/ops/index_fill_ops.h,sha256=yByjn0cRk3xp9vitTfGmD2VbGGzJ83zqZcXiW5zZyOQ,8654 +torch/include/ATen/ops/index_meta.h,sha256=-W_3OUoSrTtSxGSrmJCJbZJd8rvEvOfinlOzgtLOeHs,1537 +torch/include/ATen/ops/index_meta_dispatch.h,sha256=ZlmkAAR_IG7xZPgqZlmB1R9z_aFJrGJAR53b3Re2CRI,1038 +torch/include/ATen/ops/index_native.h,sha256=kDJHnDzHzEer4qaaHWRVgWnDe5Dw6yjeXwH58fw7ua8,772 +torch/include/ATen/ops/index_ops.h,sha256=BN9IkmsV0Wha2ucfJBZC9qxX_19CyYDPWyeD_zrEKgM,1971 +torch/include/ATen/ops/index_put.h,sha256=P4I4MG_AI5JmeYA2vYwyOjPcgPs0mYsEqCPu4YAjyME,1950 +torch/include/ATen/ops/index_put_compositeexplicitautograd_dispatch.h,sha256=J0nCLUuJy_50j8k2UM3YgXMF3FputqYkP5LaX1TRgNs,1394 +torch/include/ATen/ops/index_put_native.h,sha256=dpDNW3wl90NWlGbSRjRsaMA1ZuuBjyiqa7FvMA3h47U,931 +torch/include/ATen/ops/index_put_ops.h,sha256=mnpYEkzQrFAKNszpvljzqKIp0mUI_MB7mAObog_UE-c,3124 +torch/include/ATen/ops/index_reduce.h,sha256=Yl3gfaZAcMIKHAvMYsQwbQK8iMx0WZAh8TiQyYv_sCQ,1766 +torch/include/ATen/ops/index_reduce_compositeexplicitautogradnonfunctional_dispatch.h,sha256=R6N_xWY56S2n5BDeYZ4fTsl-Rj418YWb1lzPhnsH2kg,1083 +torch/include/ATen/ops/index_reduce_cpu_dispatch.h,sha256=kRvYVrYZRoeG2YrCNUe00SmO8GcqiAvPuLYl8tMZJcE,1407 +torch/include/ATen/ops/index_reduce_cuda_dispatch.h,sha256=NfFethrIFpZiwBOceL7Ek0PsMGFSXH4o-5fGa4Kvd4w,1409 +torch/include/ATen/ops/index_reduce_meta.h,sha256=hysvkQPZDTwy-2xJ-s55wuES23-to5S4OvM9HTGZ92Y,1176 +torch/include/ATen/ops/index_reduce_meta_dispatch.h,sha256=Rzw9n8_oqGUMr0r2kJhQeoxk3cg0lL9o1K3lGD6O8wo,1409 +torch/include/ATen/ops/index_reduce_native.h,sha256=xWleWairXyw1n-kgMo5_7qni-WcVtA3bp7KsmWSH-2Y,1007 +torch/include/ATen/ops/index_reduce_ops.h,sha256=gbWY4RLWuvE0rqUnnp7dWYOS3Yg1oOOK_-YXNh8Goys,3283 +torch/include/ATen/ops/index_select.h,sha256=31WTyGVzW0Iy8NNPXGD6R66GDBid3MZBFsZpYNurhbs,2170 +torch/include/ATen/ops/index_select_backward.h,sha256=S2LNFlQi0DtvX8zi6HiKJABmV4QfiY8ZDtvuH6oD-38,1846 +torch/include/ATen/ops/index_select_backward_compositeimplicitautograd_dispatch.h,sha256=o9hT6T-ge8JSAEMeGj4p5NzH8U4zMpm5oyH7eG1Lhd0,993 +torch/include/ATen/ops/index_select_backward_native.h,sha256=YgYGobr6rWzUh0a1LcEhJhndGRS83SZwUtbvw58ysDg,580 +torch/include/ATen/ops/index_select_backward_ops.h,sha256=8OpwCOw_gqct9SchZ5R4YD_sUxWARkWfvBkq2J7uFyU,1248 +torch/include/ATen/ops/index_select_compositeimplicitautograd_dispatch.h,sha256=8f4FLKtwe-5DE8GYDoaNPjVtCl6od4KdpapNNtch7Jk,1068 +torch/include/ATen/ops/index_select_cpu_dispatch.h,sha256=1MbvSC-blT9bwOJEXpzUiFT73qsz5N-NBWlJDG1gMDI,1012 +torch/include/ATen/ops/index_select_cuda_dispatch.h,sha256=sCuNKKjpbY8aplDqQ9DyM1b-tdg-eGCjN4iTYyJLWzI,1014 +torch/include/ATen/ops/index_select_native.h,sha256=8bGD1Px0YHJFd9LE4EKNtqBZLpm7C9oCHugGl0HFIPg,1576 +torch/include/ATen/ops/index_select_ops.h,sha256=eJNuV_CGbj-AwqjrGurpfI6YinkLsMfMcuQdpGQxdic,3417 +torch/include/ATen/ops/indices.h,sha256=w7mjMPZoxQTySbbfAkp52kaSlvGCIb4O-BThQFoh1CE,492 +torch/include/ATen/ops/indices_compositeexplicitautograd_dispatch.h,sha256=NtptpbmpDMRQhc9OKENcOkIerT-wV-uREe6T_8m-dfI,765 +torch/include/ATen/ops/indices_copy.h,sha256=NNaEAPjqyz0WeWWegXRT7pGquAq9N6Sc_NEZvPGBJ6A,1075 +torch/include/ATen/ops/indices_copy_compositeexplicitautograd_dispatch.h,sha256=C1pzb113Xh0GV7J5_wlGtrScbU25Y_pohFE5ynQBWsI,879 +torch/include/ATen/ops/indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=VIAEOpaWRV3GAQSCzjzommNlXXMWShHj9-z7J3okeJM,796 +torch/include/ATen/ops/indices_copy_native.h,sha256=XZF0VZ5QOwjhgWQ2319dsjROR7p8UuG5dA5rMtMe8Xw,577 +torch/include/ATen/ops/indices_copy_ops.h,sha256=ANJAk6WdDSGIvLlvmpnvN-halWJks2M4FIicxNFQddE,1626 +torch/include/ATen/ops/indices_native.h,sha256=bDBIuN5wrkpqnt1HGFs4tBYlY4wznm4OZhyc_dyUwNk,558 +torch/include/ATen/ops/indices_ops.h,sha256=lJS2_JNDMvfCXJuSN78FBLOORIMGcvUDinX29Ei8azE,976 +torch/include/ATen/ops/infinitely_differentiable_gelu_backward.h,sha256=kBs27LuLrjOU1M6q0hyv_8WB4ZgWNdK5qtOq431u_FQ,801 +torch/include/ATen/ops/infinitely_differentiable_gelu_backward_compositeimplicitautograd_dispatch.h,sha256=wm77Mxn6ul99VKoUWmCB3rkiqW7zMOv2KJyfSfOKyNc,822 +torch/include/ATen/ops/infinitely_differentiable_gelu_backward_native.h,sha256=aM-OBXAgehQ0-TGd_oQy7yTqXQ4vxvYn1i22gb1H_5I,545 +torch/include/ATen/ops/infinitely_differentiable_gelu_backward_ops.h,sha256=mZbajlTnGhoVc3sSYSdPLHPPa7PhYoA4Amsn1Yd-XJY,1149 +torch/include/ATen/ops/inner.h,sha256=Y-TXNMTjjx05GKo2DHp9rw4tJQiusk5Kl2DQkaf9hUM,1146 +torch/include/ATen/ops/inner_compositeimplicitautograd_dispatch.h,sha256=rGTQcl54_ubMF-wFN4RU1uZoxnBlVVOG1lG0Pl5lgFk,996 +torch/include/ATen/ops/inner_native.h,sha256=7PMf1z47AVkuHSZUCGboxVAnGuBxjV2K14JcmGTYT64,615 +torch/include/ATen/ops/inner_ops.h,sha256=ZJxXvVhOttMXPIx4U5b0TKEkOsu3RzDzewact0PVmd4,1756 +torch/include/ATen/ops/instance_norm.h,sha256=6ehJVBuRfus-gH2W5fuViKiuBuWIW85jlRIwGkzQuNU,1134 +torch/include/ATen/ops/instance_norm_compositeimplicitautograd_dispatch.h,sha256=4rBD4qFFUySM8TtFk07J1HGpRZNhOfmQbuMxIr3uVcw,1020 +torch/include/ATen/ops/instance_norm_native.h,sha256=iQ9PrZ_7H-hw_vzSBJRI7-6YRx4TWWKmr_c_Cj0BDc4,743 +torch/include/ATen/ops/instance_norm_ops.h,sha256=Yv7F-crKRS0uqhWBue-6Lp4tWFOWiseyIXRJut-JaFs,1797 +torch/include/ATen/ops/int_repr.h,sha256=tnc5tlI5dFmK6e15AOlSLcFiHCCSGUTOwpjuR5TLXdg,1035 +torch/include/ATen/ops/int_repr_compositeexplicitautograd_dispatch.h,sha256=N3eNdxRpL51j-SjJYR1v-_CqBZm5jKDtxN97k-xRFPs,871 +torch/include/ATen/ops/int_repr_native.h,sha256=AnsnTry865_x1Cw_6UyjaKLjTZCgGKXV223XbMjac_g,654 +torch/include/ATen/ops/int_repr_ops.h,sha256=bTs-WKFKly1AyI8zfmmLi-wm77pds4g3UmCXU6uO1iU,1602 +torch/include/ATen/ops/inverse.h,sha256=so8FTr0yYQ3gsye60Qu4hmuh7GdSPZbXx1gEQX8qJd8,1025 +torch/include/ATen/ops/inverse_compositeimplicitautograd_dispatch.h,sha256=3hZZTApRJteFgetCKmFy3PcEGPweUE4OCTHURXkKLOw,924 +torch/include/ATen/ops/inverse_native.h,sha256=5YjwYAX_3IZHa9yRfUW-AswGj9N-ufx7mhkG9dcje3g,567 +torch/include/ATen/ops/inverse_ops.h,sha256=NBMK2F6D1sXeYhN9uX5vn08mmb-NAfY26x04sRgziEM,1596 +torch/include/ATen/ops/is_coalesced.h,sha256=siZrCZ_uO9PcUcFc3EUziV9uJPyoqwH0GoNwGESBBZg,497 +torch/include/ATen/ops/is_coalesced_compositeexplicitautograd_dispatch.h,sha256=yC3pLDFtapo3PUsZdMjxINh25AJ9Oz0vSb1vAp0A_TM,764 +torch/include/ATen/ops/is_coalesced_native.h,sha256=cFwve4t9XlV79Ep89OhHLodXJALFfl6jzhwrzXPQDHc,556 +torch/include/ATen/ops/is_coalesced_ops.h,sha256=aD-TB4D0oes9jyEeASkl7asj5ud0NWztAdLgc9uuHDs,965 +torch/include/ATen/ops/is_complex.h,sha256=AgGryeMgvwojRTWCWBlxsL9PgmqR5M0eCxKD3f4hS_c,644 +torch/include/ATen/ops/is_complex_compositeimplicitautograd_dispatch.h,sha256=PM7uB6Z8ulJJUs-Q9Hkl7Ji_kWrQZb_PJr-8YDSieZw,762 +torch/include/ATen/ops/is_complex_native.h,sha256=It8w9qzZTxy9H7r-8repiLELVEvnjejQ2brKaf5lJWs,485 +torch/include/ATen/ops/is_complex_ops.h,sha256=ujLm7lyRUosIzAAtacPYmvOTM37pa4o1RJHH3kMughQ,959 +torch/include/ATen/ops/is_conj.h,sha256=RbxcIJUYje-KRqF5Y1kZVidZKyHbRWuFcSBQ5IPnx_o,632 +torch/include/ATen/ops/is_conj_compositeimplicitautograd_dispatch.h,sha256=6OF4Lw27SN7l5Gm1nWaZLYM32fjNnV1sgzw1ECfHe4s,759 +torch/include/ATen/ops/is_conj_native.h,sha256=YRcOliz3YV1z54WPXa20NS2sNP2-vB9sADF9samyXTg,482 +torch/include/ATen/ops/is_conj_ops.h,sha256=tKDoZ6nd7mjhmNcLb4gz283MYr6pUB0MurYZGFfsMJM,950 +torch/include/ATen/ops/is_distributed.h,sha256=oZX3BzaeERHCTRWfLutTRz9CNGzkSwy1BgkBRTnO4qY,649 +torch/include/ATen/ops/is_distributed_compositeimplicitautograd_dispatch.h,sha256=OPotyIqyIDnxX7pfFj1_Jd0iAajLgscjZNtEkAWNvNA,766 +torch/include/ATen/ops/is_distributed_native.h,sha256=wXQlMiYTYZPo6KMd3qnsmoV8ItuEUoVQVb0HCRNW5fg,489 +torch/include/ATen/ops/is_distributed_ops.h,sha256=cwKWAUNHt5Yh3dUEbFa8U9u4QPemwUzc97-7BuohCr0,971 +torch/include/ATen/ops/is_floating_point.h,sha256=016WIIf-ytgwVk8LryakZ9Qe1ndIl-UMFmYTms2DY1s,672 +torch/include/ATen/ops/is_floating_point_compositeimplicitautograd_dispatch.h,sha256=A06RbWpiRJ4J4i5_SmDn8j8mWdPdGioKZSH1QNYj2fA,769 +torch/include/ATen/ops/is_floating_point_native.h,sha256=U6_WKPHabB1A5G4r_Lr5KlQ1kEdm4UpDXUuLowtIQ8A,492 +torch/include/ATen/ops/is_floating_point_ops.h,sha256=zXJYb69e6U5kF5UTexO_xdRazgbw9UvWyNeVcxi8_6w,980 +torch/include/ATen/ops/is_inference.h,sha256=w0r9wWrAIaQyOYoMaZNUoNyRB9RuVsrln6qsVk9FzRg,652 +torch/include/ATen/ops/is_inference_compositeimplicitautograd_dispatch.h,sha256=ec1er2INXV2_SN0Toc4IbcmTida63Ef-Z9l20OaopPU,764 +torch/include/ATen/ops/is_inference_native.h,sha256=MfFr_vkBWNE9T8JJ6DRZFloe2riSc4QTQ9YTsFcXKcI,487 +torch/include/ATen/ops/is_inference_ops.h,sha256=7YvphPoFxkffFMcDG6v7b2Q9oxVUYJRVeIiLjf6sLwE,965 +torch/include/ATen/ops/is_leaf.h,sha256=O27KCBpTXjj4poWFtGAvBTmxh8QcXUsJwQzCj9w59m4,492 +torch/include/ATen/ops/is_leaf_compositeimplicitautograd_dispatch.h,sha256=8YSwdYkXAlqtNyy6vzoHCZrf9kg3igxbHG8bKoTQOPE,759 +torch/include/ATen/ops/is_leaf_native.h,sha256=O3qeaZB4ahO5JK96MZFX-6mCqRt2Fd4XRKOxUDZh4X4,482 +torch/include/ATen/ops/is_leaf_ops.h,sha256=BipxhqWZzNhxup7JKX45vzkDoMJX5lIl1VybDWI1Egg,950 +torch/include/ATen/ops/is_neg.h,sha256=lqo9FNpRAxeBPw4ni38ywEoOHKiUFwWlR2kJdmtBpUU,628 +torch/include/ATen/ops/is_neg_compositeimplicitautograd_dispatch.h,sha256=e5vmOK96ljDoaD1ZEQPEQ8zxrLyJ-8JTIeMgKSSJI4w,758 +torch/include/ATen/ops/is_neg_native.h,sha256=0bMXmhijWkepq0Hk_m1Pyv1Oq45ME7SKz7PJCMgYJHk,481 +torch/include/ATen/ops/is_neg_ops.h,sha256=vRHRHduzeGHFRhP4doAsY4Dn7lvSC_rYcUYdfRlcLSM,947 +torch/include/ATen/ops/is_nonzero.h,sha256=upSBZ44-TBS7qg4x8JcJwjQjSepn0MzVsTUxdgEJ5iY,633 +torch/include/ATen/ops/is_nonzero_compositeimplicitautograd_dispatch.h,sha256=OQaAY2in-cvFGggANfAfZKV3BDAtaQCHqIyGSbD5vlE,762 +torch/include/ATen/ops/is_nonzero_native.h,sha256=5DG2_aq9lveWwihGVMjWaFsi7IL9sHEF104-J9rLZmE,485 +torch/include/ATen/ops/is_nonzero_ops.h,sha256=fAQ2qCOyJj-hNSLQFrY0CDLCVxupRoBfRCbuKUPeDd4,959 +torch/include/ATen/ops/is_pinned.h,sha256=lScZAZP9DUo6UNHy4nwxRp4sZ8LFT5xoThhPhyoz3Ls,494 +torch/include/ATen/ops/is_pinned_compositeexplicitautograd_dispatch.h,sha256=s-GjbMYc_PVs99PqUYH4258s1EbslWN0f14_I_lei4U,808 +torch/include/ATen/ops/is_pinned_cuda_dispatch.h,sha256=okG_0xu4JfuAUpcE_6WO90NuwW-V2yA1ZJoOfnJMHbQ,766 +torch/include/ATen/ops/is_pinned_native.h,sha256=fdeu3b1bTyLvKooqy516aIT1Lc93B_7SLCbzszTbjxk,642 +torch/include/ATen/ops/is_pinned_ops.h,sha256=bEaV6ovN4Kg_DHangmAm1pP4_a4kAV7jtN9ctxmBz-E,1072 +torch/include/ATen/ops/is_same_size.h,sha256=yFEvT8v8yr-FPH9wMKlnHPwOZ3lYGC17fSS40-FVU8s,688 +torch/include/ATen/ops/is_same_size_compositeexplicitautograd_dispatch.h,sha256=wAeTAaogkdseFll4Dul7AntZUVKfJbPlw09vsWq51A8,790 +torch/include/ATen/ops/is_same_size_native.h,sha256=EkBdiYwflxKSVVEc-Mp0dkokoNlttlJlJIZQcvTilLw,600 +torch/include/ATen/ops/is_same_size_ops.h,sha256=s2fL7HmsXz4FGSeOm47ngHotFzoLhGW6s7_G8MvkFhQ,1051 +torch/include/ATen/ops/is_set_to.h,sha256=YCobocZeT_m8HGIQ3ZCfw8v5gAWv-M7h08lFljiNLg4,494 +torch/include/ATen/ops/is_set_to_cpu_dispatch.h,sha256=C44peVDc8STgF5TlW3naz32pjtVhxvXWuSwDqg_Yge0,744 +torch/include/ATen/ops/is_set_to_cuda_dispatch.h,sha256=7uE-ZcNeaYWMlZ21ayYc144zs83lk03eFWl0wrh-kCw,746 +torch/include/ATen/ops/is_set_to_native.h,sha256=BqdtrRdwKrKX6jVd846w1E-XB6xKDo0Ocyke5qpKs68,511 +torch/include/ATen/ops/is_set_to_ops.h,sha256=7lrPVDJna5KMr3bM8NUbbrysfe5dqgf-1P1LFDceEBM,1045 +torch/include/ATen/ops/is_signed.h,sha256=Fxi5jOHRb-qw_ps6j_WeZnQGX72Px8mxqypu1iveDQg,640 +torch/include/ATen/ops/is_signed_compositeimplicitautograd_dispatch.h,sha256=u884jU4_OTpQKNfWKRugrlpuLGpQacdZSKNz7saFGHQ,761 +torch/include/ATen/ops/is_signed_native.h,sha256=h492bHN4u5GmDPwUwruDsWSRKmu64rAIXw7nA9BdTPo,484 +torch/include/ATen/ops/is_signed_ops.h,sha256=HSULAHgCggTv4luaAD5bZShR_iKDxADMLYLgSgnc4JA,956 +torch/include/ATen/ops/is_vulkan_available.h,sha256=Cs0oRN18KVruskdhb6JuDaP472b-0Fw2s3RtisxbwEY,631 +torch/include/ATen/ops/is_vulkan_available_compositeimplicitautograd_dispatch.h,sha256=HHFOPI52jZvU2ZZz2YXIVJucZIy6qadOfvDePH-_jgI,748 +torch/include/ATen/ops/is_vulkan_available_native.h,sha256=DaMlNMHEYJq5eBkkBet3OiBiH2P-jTgZWA1KnWREBpc,471 +torch/include/ATen/ops/is_vulkan_available_ops.h,sha256=pmwy91MGQmC4edHZPQ8LZg8Xm6XxFUkA8Cilal0c3IU,909 +torch/include/ATen/ops/isclose.h,sha256=HEAepcQ1KKn7GMi0F7YqZJ--L7Y7F7mRnUbp56mqGwI,817 +torch/include/ATen/ops/isclose_compositeimplicitautograd_dispatch.h,sha256=2sPLXHrcWuqvEkhLXP_wSFANpRyDt6VpH5IVoYDmyFU,851 +torch/include/ATen/ops/isclose_native.h,sha256=2sWKRXg-i9lw4zYK3jw58JEi2GooorrAilg2m5MgVZU,574 +torch/include/ATen/ops/isclose_ops.h,sha256=VwCkK9U3O1iITrdxaLca5wez0fBmCtWUE72lAAepFEk,1220 +torch/include/ATen/ops/isfinite.h,sha256=cJxz_yuFPzqDCPmMPbSKg3-I8xWhpek6B0yCa3HF_Nk,633 +torch/include/ATen/ops/isfinite_compositeimplicitautograd_dispatch.h,sha256=6gIF-qr537lG4VF_zaUN8eX6t1JmilAHpTwSK2etg_Q,766 +torch/include/ATen/ops/isfinite_native.h,sha256=JYP5t-WkgdGH_ieuI7H3Wj_cMcLGGGhUOk8zoMFUCkk,489 +torch/include/ATen/ops/isfinite_ops.h,sha256=bYX8MffWS3zGN1sfD-e7rVSX4OeYPgSuWA2fRlmmqBo,973 +torch/include/ATen/ops/isin.h,sha256=jzUTgnb6n6UqQQMuXB_kkZQX0kL7955esd1c6k4DzJI,3980 +torch/include/ATen/ops/isin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=DbQSEtmQVYZYcTzdmbToOsTaJkczCnWxrgAOR1Y54kg,1139 +torch/include/ATen/ops/isin_cpu_dispatch.h,sha256=PIGEL0_12S73-xp3zUZjWt87LY15lu5yHfma-r8-E14,1986 +torch/include/ATen/ops/isin_cuda_dispatch.h,sha256=lnkeCo5IIHaxVBka7jb0rG0N96Z7hfYd4Y9na0VPrHA,1988 +torch/include/ATen/ops/isin_meta.h,sha256=6vnEA-mtStR0-tj80l0H9PkrIYjp-43cYTA-iXxf3Ys,1069 +torch/include/ATen/ops/isin_meta_dispatch.h,sha256=r9pisiDzRKbOg2rHU-hd5srMZDR_hU4cfq6-RtDn5gc,1988 +torch/include/ATen/ops/isin_native.h,sha256=8HaKJBH6BRMQ6dNzveMsnCwVB2b6nOMfHNxRvoUpHfY,1170 +torch/include/ATen/ops/isin_ops.h,sha256=MSs1WGYIsmyYnYsU9gRfG2gw-DzFLiLwAz_Wph5cH8s,5582 +torch/include/ATen/ops/isinf.h,sha256=Tr9YQ3ImBR6oqGLlecMXI7ZfClHauq7M2fI1V4ut2z8,1005 +torch/include/ATen/ops/isinf_compositeexplicitautograd_dispatch.h,sha256=2vxqvNiqAMknXD2tgc0XI0XPhKho-_3QdmaQ9uz9zDg,918 +torch/include/ATen/ops/isinf_native.h,sha256=3MGemUmd5naePrkYeizOxfs_OJuwk6isCfXKbwai3eQ,752 +torch/include/ATen/ops/isinf_ops.h,sha256=y1mrl42kXgHRiK-gNFYv-Rti4SPHNaIEtA6PTM1qMVU,1584 +torch/include/ATen/ops/isnan.h,sha256=JsHdU8jZl9yRQVJR6QLHt9l46tq0WWrDS-w8d5_nQgM,1005 +torch/include/ATen/ops/isnan_compositeexplicitautograd_dispatch.h,sha256=0rerY-imE2tu_5ntwS1WYzpWFc_nfMmllp7BPHauBuE,865 +torch/include/ATen/ops/isnan_cpu_dispatch.h,sha256=RvGBhKcczUpWPCaNlnHs4yLGfy-9uJCZqPB_YMx5pkU,719 +torch/include/ATen/ops/isnan_cuda_dispatch.h,sha256=yeJ84r1Mf9u_6eB7k1NxWC--OHmdv1MGg9_Liiw3jfc,721 +torch/include/ATen/ops/isnan_native.h,sha256=PtIkzMuxehtt2jUvMjay0suCo-i7PH21VOEyUa-vFnA,687 +torch/include/ATen/ops/isnan_ops.h,sha256=Fsfl-GYZBdY1iLEwqY9PbsGu1KW_lvwLciR2O8pqTe8,1584 +torch/include/ATen/ops/isneginf.h,sha256=jl548WsjXxiyNCSXZWnc-7umKLN5agMDfudw3NkFOTk,1035 +torch/include/ATen/ops/isneginf_compositeexplicitautogradnonfunctional_dispatch.h,sha256=na5G02vfqv_qZ06ZhunIX4FVd2OzbGBEJ8EKgcRYnx4,792 +torch/include/ATen/ops/isneginf_cpu_dispatch.h,sha256=_6-kZGLygWlMHzQNvQtJFcSDe4TsEr7fxpTgoW53y60,883 +torch/include/ATen/ops/isneginf_cuda_dispatch.h,sha256=-kgtLYxzmPSPTNUXJR7bX0iXrO9iSxmhJL-vEDidgzo,885 +torch/include/ATen/ops/isneginf_meta.h,sha256=lutNGvey8wQN4SayR_4viMzQuPoVebM0Kym8-bo1s9I,588 +torch/include/ATen/ops/isneginf_meta_dispatch.h,sha256=hApmHsMa8d_yZiCwzPRYeuqB_6XSISXrAAVguQ7_Lcg,885 +torch/include/ATen/ops/isneginf_native.h,sha256=KHpZr_OHtPXoV1QgcxxOq87XhqjX-m0dBgLfq3jliIo,921 +torch/include/ATen/ops/isneginf_ops.h,sha256=1t_cOZEy9aJjuj1DezuqdsEls8sL4l-qQ7AJ2snqGjA,1602 +torch/include/ATen/ops/isposinf.h,sha256=Kd_FIKBWXHM-zguP2e5ilMYTORH8j7oc-nYR1eejpKk,1035 +torch/include/ATen/ops/isposinf_compositeexplicitautogradnonfunctional_dispatch.h,sha256=bkhRb_WOB7xTExZM9-UtXhWQ4GxJMVXHphjl119uNBI,792 +torch/include/ATen/ops/isposinf_cpu_dispatch.h,sha256=qwFtIg51JGhSsvkKHaVUSaocwRxmwEmVTlkygP8yfWk,883 +torch/include/ATen/ops/isposinf_cuda_dispatch.h,sha256=dUqldPPiINjCj26On1xOF9Xh-xfK5EekKc0zSFYzmSs,885 +torch/include/ATen/ops/isposinf_meta.h,sha256=jKApVqS3K9lpXXHVA8Sjh65pRVJ9mKZz1zM5NI7sQwA,588 +torch/include/ATen/ops/isposinf_meta_dispatch.h,sha256=AwDhbHfTlqRygBVDMdrZn6dQ3likrfN9GnG27sEYFn0,885 +torch/include/ATen/ops/isposinf_native.h,sha256=P5kVC_yykWM3bSZ1Zip9bTX2iALVYcDjfuHd84fV4vs,921 +torch/include/ATen/ops/isposinf_ops.h,sha256=imsB-x0YEpksrLSzL2ZY02fQCSA1CzWDB1BERIfibrY,1602 +torch/include/ATen/ops/isreal.h,sha256=h3QpNkuqJwsblhZnvsTrhnkmBjusruONs8-8SpUnAkE,625 +torch/include/ATen/ops/isreal_compositeimplicitautograd_dispatch.h,sha256=wssOt2_7Jl_wPKpeF8gBgvZigg7_2r8N1YK5V9G5Xyc,764 +torch/include/ATen/ops/isreal_native.h,sha256=cQ9NrL_AT1te7mL5z_LWronW7RqYNvxNrOiB8MWaV6Y,487 +torch/include/ATen/ops/isreal_ops.h,sha256=xd8nb3gOx5lStloL-l7xyPZmHAPf9VQCDk4UOLMOYHE,967 +torch/include/ATen/ops/istft.h,sha256=CDhTtmCeHmCbSm7ReCceyS9z2EGivfbs_pBbNL4E67I,1208 +torch/include/ATen/ops/istft_compositeimplicitautograd_dispatch.h,sha256=WQ_vuAclb7KcZACPgmIaZI6oWwPWDfKm-8VkdIK7svU,1074 +torch/include/ATen/ops/istft_native.h,sha256=PaxZSXXN08B-M-BLQlxH5O9Z8I29SwoPyLEx6eKvB0c,797 +torch/include/ATen/ops/istft_ops.h,sha256=_tAFqbUWtNRi1SFhJMxmrSYc4QBWX-uA_j3Iz_tRr_E,1780 +torch/include/ATen/ops/item.h,sha256=cBUeSvTKuuAai3mIRwoycGrZE8EOO9Aobd19yzQBQSU,489 +torch/include/ATen/ops/item_compositeimplicitautograd_dispatch.h,sha256=ZlQsPmxfYxn7eSvY3f1D_S6fYZrRSSveSxKGU6OrXA0,762 +torch/include/ATen/ops/item_native.h,sha256=oBwqDUIj2AeXXBQx9SOBIgsLMKPf4kfQuOhS69Wy4YU,485 +torch/include/ATen/ops/item_ops.h,sha256=58ljbr2AU3IXw3QxjTycL2fZr80hPTwC8N9n5n9nL3g,961 +torch/include/ATen/ops/kaiser_window.h,sha256=gHJM5H384Wvk6oGBsVHS8OQREofPVVjqzFE7rlLqdIU,4968 +torch/include/ATen/ops/kaiser_window_compositeexplicitautograd_dispatch.h,sha256=NWc7OTvDdAN44QXzOQUt_1J3MfRFPEJbpWAAfM1Ybrs,2238 +torch/include/ATen/ops/kaiser_window_native.h,sha256=heA3yZKkP56YalRRrD_HwBtNH0UDoGlXVzmQLPnt0xg,1406 +torch/include/ATen/ops/kaiser_window_ops.h,sha256=Fcc77PFz5L6fDn4tSYZPs9MdEywbznQNLTw_KW0h0UQ,5768 +torch/include/ATen/ops/kl_div.h,sha256=BuXuz6sCN9Ta7UlWRBzjx4dtDpbddI3jjKu8xOpDDwQ,806 +torch/include/ATen/ops/kl_div_compositeimplicitautograd_dispatch.h,sha256=cEFMesvwyJaiJr3hpFfTrd231Z6ZnUXKVb5vbOXWXNU,853 +torch/include/ATen/ops/kl_div_native.h,sha256=Ts0dSAZHFFlVNKoSN7QjbHrhzuqk2vwoapUu2gj5LXE,576 +torch/include/ATen/ops/kl_div_ops.h,sha256=YhE6RDkgFtmmudDi4R5t52NWSL7XEXl6xUK4hPl1n1U,1189 +torch/include/ATen/ops/kron.h,sha256=Vgb5TDxSHFeLjPStObgwePf-tyHbPdiQxca9o8m_dug,1136 +torch/include/ATen/ops/kron_compositeimplicitautograd_dispatch.h,sha256=M4rrYdqvzM-H0qSdsO59O-lkY57No4I6ENSI9Mkm-L4,993 +torch/include/ATen/ops/kron_native.h,sha256=SyvImcxev1j6TbkTEPPfqFqhMcmctXnQZ1Jlgq786OU,613 +torch/include/ATen/ops/kron_ops.h,sha256=fTTMYcrNXDfUT27iNi9LU4YlN0BClLg0DNZy7JjQbFw,1750 +torch/include/ATen/ops/kthvalue.h,sha256=3Nhqvjua3qvFPdi59gJ0NKYcAyVAVBm51XVmidOdk4c,2811 +torch/include/ATen/ops/kthvalue_compositeexplicitautograd_dispatch.h,sha256=IMuzI1cKCxbkJ_JSpH1XfTSrU8L55kuen2Knwbg3YhE,838 +torch/include/ATen/ops/kthvalue_compositeimplicitautograd_dispatch.h,sha256=7eSi75LeTWUpcsSWQ0inYryRG1oURls7RcHp-4_4Y8w,1194 +torch/include/ATen/ops/kthvalue_cpu_dispatch.h,sha256=NiFRB46RuO_2NaGAbSZVzzcYxKOPPgR0kJaN_17OTEg,1016 +torch/include/ATen/ops/kthvalue_cuda_dispatch.h,sha256=LxDzYMfSWFkv9FVF4e6y1tn7h4LpJ60a2KMFxiCwUdk,1018 +torch/include/ATen/ops/kthvalue_native.h,sha256=QShWPUI29coJhu6pDz_a20gU-B9mLj4bqHut0rE6v_U,1213 +torch/include/ATen/ops/kthvalue_ops.h,sha256=LABuJlUEtsijE4g6C4SAPEYzFYg9V0TRniXUhz9lyNc,4002 +torch/include/ATen/ops/l1_loss.h,sha256=0p5sissDSFixZeY59NasAgH6wANZKq7E7_rH5CyYfyI,749 +torch/include/ATen/ops/l1_loss_compositeimplicitautograd_dispatch.h,sha256=DdwctjgHfcBJpq3IbK6ZSJlfoCeId2T4SJoq0F_Fs0U,831 +torch/include/ATen/ops/l1_loss_native.h,sha256=Jg7QRMt7uskzT6D5rX3m9yzlyj2awDARQNwTPnRik9E,554 +torch/include/ATen/ops/l1_loss_ops.h,sha256=t0gDnTTg4VP7Emu45tcv_kjjGn7wYak8TDa9te95kWc,1126 +torch/include/ATen/ops/layer_norm.h,sha256=mEIQ9o60XE9LGQGdvDTGgsDT49L6TMkD_NecxtXpZfY,2359 +torch/include/ATen/ops/layer_norm_compositeimplicitautograd_dispatch.h,sha256=uBmUcyyHJ_KZ3H1mm2yxAIUakQ72BRseuqdGObuc1QE,1167 +torch/include/ATen/ops/layer_norm_native.h,sha256=PHhEuDKlI-9-zkplWkj114cTrIoaJEZRbfjaiF_RkbU,667 +torch/include/ATen/ops/layer_norm_ops.h,sha256=mur9TpOd3D27QSMrIJAhmtpdiY-QWWAaNNuqgDJEa30,1497 +torch/include/ATen/ops/lcm.h,sha256=G7KQydvbxgiClz1rfhtBmgMMu3E2Qf1Ndy2NoS97MO4,1306 +torch/include/ATen/ops/lcm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=cAGOr3tQDesg_kq6DxPStJVQjiQ_JZ1LnoT2_XLXxt8,887 +torch/include/ATen/ops/lcm_cpu_dispatch.h,sha256=EIqGnY-65IygmauP0_oPS_0Noeo7DtQE-qpapsaV-cw,1020 +torch/include/ATen/ops/lcm_cuda_dispatch.h,sha256=mH-0ksfTKxqtai8mGEwjGto_Z0weRSjShnJilzbFEyU,1022 +torch/include/ATen/ops/lcm_meta.h,sha256=z9k-UKYXJwRcTa4kx3JKXOSvTd5iSTzQWkiRuQWlONg,609 +torch/include/ATen/ops/lcm_meta_dispatch.h,sha256=WZ8--OWURo4XcQEyY_OT0uBGK3s1AKvgYO_aRDcx1Ac,1022 +torch/include/ATen/ops/lcm_native.h,sha256=RnMFfka8rKGvL1PJ-U2y7zJ4Dbd56K89GzknmGIvDRA,624 +torch/include/ATen/ops/lcm_ops.h,sha256=6FVe64z4a9eJa4KTJVwgiif4_tkL11X5_t1wpxbE5Z0,2353 +torch/include/ATen/ops/ldexp.h,sha256=1Uu4GFwHuhCOOYAvETDaonfvkpNerDyZ5PwPz-XPZ9U,1346 +torch/include/ATen/ops/ldexp_compositeimplicitautograd_dispatch.h,sha256=aAt401aajRcGOgUSHa2dWY4Y4UHJ2IJ_8k89TR0TuaY,1072 +torch/include/ATen/ops/ldexp_native.h,sha256=KOkRskDN4-5demkp2CWuEFgyfGxZhgt9_eC3z_YJ1DA,691 +torch/include/ATen/ops/ldexp_ops.h,sha256=m2M-LWql2APRm7CZ3oFj97SUCKG_rqP-Pn1RnhXdqAg,2391 +torch/include/ATen/ops/le.h,sha256=vMAOyN47eNd5xFLcOUfdaz1s6Jy5ZhCGSCntZbyBCsM,1830 +torch/include/ATen/ops/le_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nAFDacOx2DNEjeHaEtA44QHZSX5W4MlwF1YcJgvWt-c,1034 +torch/include/ATen/ops/le_cpu_dispatch.h,sha256=uhlqk131ERYt8VmsnuqP2p_91C3jOVHkcijSPAqQIKA,1366 +torch/include/ATen/ops/le_cuda_dispatch.h,sha256=fV_zhFJUL2NzCHJgbyLnKKPOiG3SPXxnyqTRCwl16Y8,1368 +torch/include/ATen/ops/le_meta.h,sha256=lhxN7wQ-cOIcedtn_chq4GXMwgnSkv07CGZmCMCNjuw,762 +torch/include/ATen/ops/le_meta_dispatch.h,sha256=9ZuWvTOL5uQ9PO0A1yj_64Bh0uf3tVFGJrX6gWq2JFs,1368 +torch/include/ATen/ops/le_native.h,sha256=BME4o_ymmb8tcmUUaTzZi10xDjh2FlRwRIb2feCQyB8,1216 +torch/include/ATen/ops/le_ops.h,sha256=X1HCyn6xXonUOGGfQvzp7K-aaQNcPxk4AZ0KRXAEcTQ,4376 +torch/include/ATen/ops/leaky_relu.h,sha256=gAWTrPJKwthgrnshlocx4MOSlaml89VXZDlqQoEbwsY,1540 +torch/include/ATen/ops/leaky_relu_backward.h,sha256=_UuYip1r71f-2xxtDn7x2bL0uE2O3b6MI2z7gguSaB0,1806 +torch/include/ATen/ops/leaky_relu_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=JlDYL89-QIouDMoca884wLPQYT8XApBSRAbQ4ry3z6c,891 +torch/include/ATen/ops/leaky_relu_backward_cpu_dispatch.h,sha256=qnwO7C80nvREYGs3FpBFFyfRPOSTZMBXZ_faT7ZajB8,1194 +torch/include/ATen/ops/leaky_relu_backward_cuda_dispatch.h,sha256=7nXYkqzamWEWSL25DLwqZjClrHSdBAJAm950XI4ILwo,1196 +torch/include/ATen/ops/leaky_relu_backward_meta.h,sha256=0geKet73rP7_Zx1j9hdqPZdydXEo-OII3FtuITA1k8A,687 +torch/include/ATen/ops/leaky_relu_backward_meta_dispatch.h,sha256=DTbDlJU99_xlks6iXwUEBc6RDnhOMwwz8XxeZvD7ZL0,1196 +torch/include/ATen/ops/leaky_relu_backward_native.h,sha256=lDdD-8MVmg5k-Ubq2KNu9qebbwWGPEdO94def4Jnxv4,741 +torch/include/ATen/ops/leaky_relu_backward_ops.h,sha256=heuAzp6cEPownUHWC52GdRRrVQj03gF2CGpXSB22CNg,2282 +torch/include/ATen/ops/leaky_relu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=45bX3czHACelwUcKfixLNRmJ2GZ7gaBLWUHTgduZ3Wk,929 +torch/include/ATen/ops/leaky_relu_cpu_dispatch.h,sha256=MNnw9gneQFVevSNjYrd-zPmFWcW_64NhwWUAAVvHIP4,1099 +torch/include/ATen/ops/leaky_relu_cuda_dispatch.h,sha256=YpnBgBpwRy_wRWLjQaA3NcCz8DX-7oP3J57iqJksCEY,1101 +torch/include/ATen/ops/leaky_relu_meta.h,sha256=YwzjvVb1zrTRwVq2hr7Gfkiw_clIsirue-1A4XsV7i8,625 +torch/include/ATen/ops/leaky_relu_meta_dispatch.h,sha256=UgSbPrZcazh0-M1-FTSRT6tstp6kmhSzck7iGWx-ulE,1101 +torch/include/ATen/ops/leaky_relu_native.h,sha256=oU6v39PQhPay1hY9xIzI9Y0FyL2vIVwpBIdRKcCJZWI,1006 +torch/include/ATen/ops/leaky_relu_ops.h,sha256=J6xZJuU5N5niXGOeSt6tMQ0UzAFFVBNrC0SdHxsAdLI,2512 +torch/include/ATen/ops/lerp.h,sha256=5M3JRv3oqR0bP9HNn48JmtUsfB7fY0Wkek5r3LGYyVc,2132 +torch/include/ATen/ops/lerp_compositeexplicitautogradnonfunctional_dispatch.h,sha256=k8mmxOxkIwdeJXsVaq8Ch5J7nps_YfZLW0UfXivqMC0,1142 +torch/include/ATen/ops/lerp_cpu_dispatch.h,sha256=cGDE7_7aMW-bmQ50UQnPdxFlmcmu19N2FvcdSU6oY-U,1582 +torch/include/ATen/ops/lerp_cuda_dispatch.h,sha256=46PgRppUorrhLx3oOHc3HLEg_f5fA4jkIw_wrMLTJ50,1584 +torch/include/ATen/ops/lerp_meta.h,sha256=1aaMbxOF8LAHapbUc4cLLUV8LGzzFZ6A5yYC53IF0qA,816 +torch/include/ATen/ops/lerp_meta_dispatch.h,sha256=OAvSXM5utS3BzjkCyCRIj3OZMS0im-iHoX2YVs29Gpg,1584 +torch/include/ATen/ops/lerp_native.h,sha256=gqOVrXLmNjiakkGCDE4dQjrW_FF79xDJFF93Zh3Ec4A,860 +torch/include/ATen/ops/lerp_ops.h,sha256=qr9urGJU5te0s_cOIVv0Lvq_PSyOb38Ax6mqg8UiJkQ,4910 +torch/include/ATen/ops/less.h,sha256=ZOsgSMadm3fFynW7MZaxCHYdgQzGLfROANscig7af4A,1868 +torch/include/ATen/ops/less_compositeimplicitautograd_dispatch.h,sha256=h8_iLv2NZ_vWcXEJ2kE0oqxPktH5kRQxzaLZb5u7lAg,1426 +torch/include/ATen/ops/less_equal.h,sha256=sByiEjLvrMDJo2Ly29QpL77zLp0Z7KOLwD0Rh2WB1js,1982 +torch/include/ATen/ops/less_equal_compositeimplicitautograd_dispatch.h,sha256=HldrZ7I4qFiLblsbZpNUp09lYq00e5bQXDatHI6DhKc,1474 +torch/include/ATen/ops/less_equal_native.h,sha256=5nXepScBMcM0e_n_iL72-vGqzYtJOIS8Fy3AOMTQSRo,979 +torch/include/ATen/ops/less_equal_ops.h,sha256=_MOb2B-FrN5uscp4UDKyvGnW_KBwlHnhyH8SaolaOAM,4520 +torch/include/ATen/ops/less_native.h,sha256=pwqblzk5etREZLoKnraVMHGzGpQQor9oy2YLkTrA1wc,943 +torch/include/ATen/ops/less_ops.h,sha256=2mvp0zDOTz6k7UCRhBCOT_lLK-8-uNl1Pb51-0yhEpY,4412 +torch/include/ATen/ops/lgamma.h,sha256=XM7ZQeCOD67_p3IhfEs9qJ7NIL6zZkmCeYoswIiUoq0,1015 +torch/include/ATen/ops/lgamma_compositeexplicitautogradnonfunctional_dispatch.h,sha256=rZqhFXhcU-nmbZ2wOuD-u8KHNdgYMpRYQt-BzoxS8mw,841 +torch/include/ATen/ops/lgamma_cpu_dispatch.h,sha256=T8tQq41Ao_PKjQaKTYXKQJ03d9wMAtr9NEFUsgpJpS8,928 +torch/include/ATen/ops/lgamma_cuda_dispatch.h,sha256=MtY18bz8r_yeUjUFbl03hUIQGT8lhbqYbcBxrZu_FAU,930 +torch/include/ATen/ops/lgamma_meta.h,sha256=mVcNa3SJV_u2Dt_N1lYzcQiCZVLZOOiv0u1LvZuilJU,586 +torch/include/ATen/ops/lgamma_meta_dispatch.h,sha256=URa2AhwDKi5HIkPzGTb8jyjdf3PbplyHKUY8boVYgio,930 +torch/include/ATen/ops/lgamma_native.h,sha256=wmy1y41Weh5niuS6kMLFTZM3bsGAdtaSu87hCkku4Gs,607 +torch/include/ATen/ops/lgamma_ops.h,sha256=JnyEbAdY_gMMukeYq-Wfz_M6NZ7cPgoLklKZBOG80Ww,2122 +torch/include/ATen/ops/lift.h,sha256=-ETrVpyCoGKp01wmVX1g_FZCFAEhfIxV50ZxVXLkoPg,995 +torch/include/ATen/ops/lift_compositeexplicitautograd_dispatch.h,sha256=s_qMNtOHoiiLcIa0ORiGWFYuUtN-sI25ELheo3nlNMU,915 +torch/include/ATen/ops/lift_fresh.h,sha256=ITB3FOammNPaJKRViQlojOxjhRbQFjTEMQ9JX_8nIkM,647 +torch/include/ATen/ops/lift_fresh_compositeexplicitautograd_dispatch.h,sha256=Epp3eIkqwBXIoyRvlyOC37GqqputV8dEDUxfUlePUl4,768 +torch/include/ATen/ops/lift_fresh_copy.h,sha256=ickiZ6UgkSXHy8vmFD9AN0jqbyx13IPAyk4LBkWpxcU,1105 +torch/include/ATen/ops/lift_fresh_copy_compositeexplicitautograd_dispatch.h,sha256=V638bvtxhLG_tfXr2hDynzA1nlm3F38RiERbWUGz8d4,885 +torch/include/ATen/ops/lift_fresh_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=mUq97k2g47V7UMj1bwth1mj96g3dmFpk93xGVY_hMXI,799 +torch/include/ATen/ops/lift_fresh_copy_native.h,sha256=hnKkY2merRN9g4brPwQS62robFxnyV2onM1JYJrXfuc,583 +torch/include/ATen/ops/lift_fresh_copy_ops.h,sha256=SLKg74l0RanMmQjUZ2-gZ0Ki78qDr4RsdpnApdcd4Mg,1644 +torch/include/ATen/ops/lift_fresh_native.h,sha256=TMr6FmHGIevX2xlmKCHZXERq2HPQ7-9F3ZEPn18vfeM,491 +torch/include/ATen/ops/lift_fresh_ops.h,sha256=yzbH_ttGKv-PghCPfNJM5F1e5wz9lolD8lYFkwbbwdo,985 +torch/include/ATen/ops/lift_native.h,sha256=l9cakGfAOWbxTo3xnTlXXPtIGlurq835y8lD67TH1sg,561 +torch/include/ATen/ops/lift_ops.h,sha256=aTxz5F-HjseLvQs3Y19U3NUmU1Pun6xm58tZDaUlAw0,1578 +torch/include/ATen/ops/linalg_cholesky.h,sha256=lQtgovYxDEU1DXK8nXjvrqwQg8kcXVfI5bJyprRqTME,1231 +torch/include/ATen/ops/linalg_cholesky_compositeimplicitautograd_dispatch.h,sha256=AeQTce46XEZ1XMKLAvuoyta2I_xPueqUgkVSqn0ALUY,996 +torch/include/ATen/ops/linalg_cholesky_ex.h,sha256=XwoytPIbxFo5hId06PrUfI42sUGoUTycUFnqTxjpjKU,1649 +torch/include/ATen/ops/linalg_cholesky_ex_compositeexplicitautogradnonfunctional_dispatch.h,sha256=DmQ8sjVgsv-xvdPtLZ2jc6zlXH9nRqvTD7_is42Egx4,870 +torch/include/ATen/ops/linalg_cholesky_ex_cpu_dispatch.h,sha256=jp6nL0xHjHECvBbG-05mp0ZZH4oqU5bZ-NczqNyoWc0,1143 +torch/include/ATen/ops/linalg_cholesky_ex_cuda_dispatch.h,sha256=9KQ1cc9zfJyNExBdNjbpc5qfajZfbm9bW3uCRf6e_EY,1145 +torch/include/ATen/ops/linalg_cholesky_ex_meta.h,sha256=9QXR4WgVMhNiwZXGKXaueV9F5jonjM6No5cm-JQmpqQ,629 +torch/include/ATen/ops/linalg_cholesky_ex_meta_dispatch.h,sha256=oZzyKuoZClkeng2J_RTrQGjLFgm_uAOvVnV9BU4twnk,1145 +torch/include/ATen/ops/linalg_cholesky_ex_native.h,sha256=P2I6PdwaoBq68MQ7xx1BBlAlxMfE_SDKe5sDawOBWZM,697 +torch/include/ATen/ops/linalg_cholesky_ex_ops.h,sha256=vjew4Dg7kPUdmkuV_QTSjvff-eko8G2Hnlcnp-e7cAA,2150 +torch/include/ATen/ops/linalg_cholesky_native.h,sha256=EvF-X1f8_iZyR5p_gnVtT6Y1TtiTeITAJvGtYJvnJZM,613 +torch/include/ATen/ops/linalg_cholesky_ops.h,sha256=_srkPW1y_WvhJcXRnmX0SAZ2rydqb-Zt3AsKlXqXs4I,1743 +torch/include/ATen/ops/linalg_cond.h,sha256=q2pd61YEvRZopLGYQrpBN1sENwILsohFfU_kOYIfOjQ,1955 +torch/include/ATen/ops/linalg_cond_compositeimplicitautograd_dispatch.h,sha256=kV5WFK3rVG4XG-7olhiMMbc1uXx-wuLvNwGZEkYSFS0,1359 +torch/include/ATen/ops/linalg_cond_native.h,sha256=F_70aTqGEZ_uCUqadJkUOEuy6zmnUO721j_hcyAGYkw,844 +torch/include/ATen/ops/linalg_cond_ops.h,sha256=ufGD248ECLGOVzicxTswPwYJivewxd1fic-ijNTXaho,3221 +torch/include/ATen/ops/linalg_cross.h,sha256=W3UaAQloW6wQzjdaWPoUPlxaCN71jL2J7phddiqzprE,1315 +torch/include/ATen/ops/linalg_cross_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WxdqUrIeN0dnAB1Dhsrvo4heiigJ1foqgQbNPkIrs-I,838 +torch/include/ATen/ops/linalg_cross_cpu_dispatch.h,sha256=GbUiLkfRAo3bBs_hP60FNHqbZtBvvu7k9t0HO5Uda1s,1018 +torch/include/ATen/ops/linalg_cross_cuda_dispatch.h,sha256=nJYsij1yAWkz-u6h9zD9C18rW1t6gYRcN_9KOlgo4dw,1020 +torch/include/ATen/ops/linalg_cross_meta.h,sha256=aKi1uv86XVufBIqJ61AacgxYZOFmJ995A58fkFvP9iY,631 +torch/include/ATen/ops/linalg_cross_meta_dispatch.h,sha256=llqEj0BPdym1Z4fNBLfVb4gdzOSVsbO2LeFRLPa_C48,1020 +torch/include/ATen/ops/linalg_cross_native.h,sha256=DQxUusqh5G_cemtygLcYn8MVKEOeqks6LNTs51qy9Fo,777 +torch/include/ATen/ops/linalg_cross_ops.h,sha256=QD-YQ_8gXimbahQ8Geh2xvN-TNX_OTVF1xNxhvMnGJ8,1895 +torch/include/ATen/ops/linalg_det.h,sha256=CyvnNZfXgdtaksuzO7qcgPpY8KpVvpbjFTQA6pm5r_4,1028 +torch/include/ATen/ops/linalg_det_compositeimplicitautograd_dispatch.h,sha256=dYCsBZYJzGdz__EwNHNbA4a0nbCgxN9B8p-1OA_6j8c,924 +torch/include/ATen/ops/linalg_det_native.h,sha256=QtoTQYdfwI1UVSS4sACgcGFJ1IzQva3FYAFNz6JIy4c,567 +torch/include/ATen/ops/linalg_det_ops.h,sha256=gSreHedyKUuGrkFd-IxpnQiXVJlw5TJH9dWct3rF0HQ,1596 +torch/include/ATen/ops/linalg_diagonal.h,sha256=qHp93j8ma1FSE5XrSYFXvyLrH93cCRhtd36_A2LKVfY,773 +torch/include/ATen/ops/linalg_diagonal_compositeimplicitautograd_dispatch.h,sha256=PUqGbsFh5qRWriLNSflGHNEKFKsbKxCyFTz2dw2w7KA,822 +torch/include/ATen/ops/linalg_diagonal_native.h,sha256=PWheJBfpHMWUJ9bKSrWAY0eKMJtX9KsdGEjk-wSoEOI,545 +torch/include/ATen/ops/linalg_diagonal_ops.h,sha256=OFL7gXgY8v0hzrhYi7KZ-ml2oX-jSPANiXT3t4rxHnQ,1149 +torch/include/ATen/ops/linalg_eig.h,sha256=s-hbCPnB2iEQkiNX1SnO1dqgNFR44FKCZmyI8SAGmhQ,1427 +torch/include/ATen/ops/linalg_eig_cpu_dispatch.h,sha256=IXX_aHDbu9PYzx7yxtEuljgMXaDewPUWb827O5NRo7U,1038 +torch/include/ATen/ops/linalg_eig_cuda_dispatch.h,sha256=H7rrfuazDX9pi6DtBjvZxco3-IS89JNEiz9yleGGRes,1040 +torch/include/ATen/ops/linalg_eig_native.h,sha256=pl8gXCrgLkEDF1qAnJLIDzqQ8kNNn0R0p9FHCOmJsu8,660 +torch/include/ATen/ops/linalg_eig_ops.h,sha256=C3T6wXAk_qo3jZgxsCeYYmXUt4XYEmDtTkBcWHL8_T4,1961 +torch/include/ATen/ops/linalg_eigh.h,sha256=Nf18N4L7BKpwPjtWwL3unO4selAMELqdKMFpfVTXwSQ,1536 +torch/include/ATen/ops/linalg_eigh_compositeimplicitautograd_dispatch.h,sha256=M7U0cEFF-8l5MHaH_NY4_w0D7R0qnDXUKdXLNk1yf88,1144 +torch/include/ATen/ops/linalg_eigh_native.h,sha256=D_5Oeln-NdicZ6D7tLOw8HhfhZp9Cq6hxM_ZCKJAdTQ,703 +torch/include/ATen/ops/linalg_eigh_ops.h,sha256=bVgmoeCbaUw06ZUiABDLlkBXoCOKZESXrNbUqbYVu7I,2112 +torch/include/ATen/ops/linalg_eigvals.h,sha256=KLwTCgPh3jws-9vJDBW6yxO24SsF7HGhjKopwsAWVN0,1095 +torch/include/ATen/ops/linalg_eigvals_compositeimplicitautograd_dispatch.h,sha256=WLOpJ_8pVIPUeTJWWrvLYYSr9UFVwQwftehDlxUduXg,772 +torch/include/ATen/ops/linalg_eigvals_cpu_dispatch.h,sha256=sf0tsRZxx9i3EWBCWwv9kJNwRUJujhz3yljugOM4C98,839 +torch/include/ATen/ops/linalg_eigvals_cuda_dispatch.h,sha256=avcvg216S9vIWDoq5XlgHHUQ2IsbkvsEEfie49qs_tg,841 +torch/include/ATen/ops/linalg_eigvals_native.h,sha256=FXxUp9PkLcv36njZTFE9DioXmq7cboGY-m0qJPx9nN8,581 +torch/include/ATen/ops/linalg_eigvals_ops.h,sha256=xj0uHNLHALAmcmfuO2BQqveQrgthnyKiCP_aSwbxgsY,1638 +torch/include/ATen/ops/linalg_eigvalsh.h,sha256=tVKBKbbn290_JsFbJ0x7lgrrTVxeSXsxTIVL3nE9S-w,1242 +torch/include/ATen/ops/linalg_eigvalsh_compositeimplicitautograd_dispatch.h,sha256=d8dIOnhLKOFUXrncNdEQGrvs3_d_aQTvmNjzXnShNIU,1025 +torch/include/ATen/ops/linalg_eigvalsh_native.h,sha256=CIIhES1A2qDceu_NWbQ3nSpFgW0fkcGnyTAmWyGbHxg,633 +torch/include/ATen/ops/linalg_eigvalsh_ops.h,sha256=7cboAcJ6c7SLg_lj06upzr9x16PGbufuF9gRCbQGbH8,1804 +torch/include/ATen/ops/linalg_householder_product.h,sha256=-s7JACd6LvkBuI-P54NVmw2Au_3HjThRszwiszbZuvc,1347 +torch/include/ATen/ops/linalg_householder_product_cpu_dispatch.h,sha256=bvrmTo0qKelasHOFD-6sMqk_utquKXUvu-emGLkJcYA,1012 +torch/include/ATen/ops/linalg_householder_product_cuda_dispatch.h,sha256=CZZJthOjlqWBINhAfbgeMrSa1fkNtH-e_mFTByXT_Qs,1014 +torch/include/ATen/ops/linalg_householder_product_native.h,sha256=kYk5QcZiYQFPE551zKlPFi1BU0Q4o4j7OjyO8KLV2k8,655 +torch/include/ATen/ops/linalg_householder_product_ops.h,sha256=KAysmwuzUgqKIRm3PB7ODJuQ2OKZZUyfPyp5ZZx4fj0,1876 +torch/include/ATen/ops/linalg_inv.h,sha256=SLBssB2ItRMogCC8drQvuPlk03dy6XAmz-OBxxz229A,1028 +torch/include/ATen/ops/linalg_inv_compositeimplicitautograd_dispatch.h,sha256=xifdp404nbGnsKcgjlYZH3C5vYXt2AI5T3hJDBp0EXQ,924 +torch/include/ATen/ops/linalg_inv_ex.h,sha256=UxRoJ65tDCDR2-KDf1-HU5FPbkq7IA0iJBXpb5dPTng,1527 +torch/include/ATen/ops/linalg_inv_ex_compositeexplicitautogradnonfunctional_dispatch.h,sha256=y8IGNs_EPJG_OStM1lJshdO_oWINpDBaVu9FaO4449E,844 +torch/include/ATen/ops/linalg_inv_ex_cpu_dispatch.h,sha256=kGYXUMJSGuIF-4TZQFTx5K3oTE8O_5Ap0nm_-_fPspM,1083 +torch/include/ATen/ops/linalg_inv_ex_cuda_dispatch.h,sha256=8DyzJ7eKuZoJ9erFCn5zX7ogTCRIrXqGv3_U_TWym78,1085 +torch/include/ATen/ops/linalg_inv_ex_meta.h,sha256=aGpyvGbzkkuu3fRSCH9epd1Hv5zIy3_uHZ960JmqPMQ,609 +torch/include/ATen/ops/linalg_inv_ex_meta_dispatch.h,sha256=cZ-MXYBoSiIhJ3mO2lR0A8b53lMirMGsvigO95H8zBY,1085 +torch/include/ATen/ops/linalg_inv_ex_native.h,sha256=oa46dOA2U1qH4mbotJRtNR71uSWLrHR_fLNyAjBxhrg,673 +torch/include/ATen/ops/linalg_inv_ex_ops.h,sha256=ysBMW6FhZqG6WmIsZBKlceBvReHnZtKyK4IKEyPAQ54,2054 +torch/include/ATen/ops/linalg_inv_native.h,sha256=N7nyGXFNcgg8KPRdcZyR2Ky624Jf2_oeWiQvLqzUN-g,567 +torch/include/ATen/ops/linalg_inv_ops.h,sha256=dXULkP5n2swsupP1KlcJ-B9cMZdS2bCLLCoxc4vgD5A,1596 +torch/include/ATen/ops/linalg_ldl_factor.h,sha256=7-vG2ApO0ky4NYYyHXkmSBtRq9XP3PKa3h8LpY-HE1E,1524 +torch/include/ATen/ops/linalg_ldl_factor_compositeimplicitautograd_dispatch.h,sha256=rLPIQKmR-hvDbhsNfxeamYsk9sp6OSehHs0I_5Wz4fs,1133 +torch/include/ATen/ops/linalg_ldl_factor_ex.h,sha256=BVeMgHq8jpzR7VTb8QXjZNe8Pew1XX3NNPt9DTMH6_8,1908 +torch/include/ATen/ops/linalg_ldl_factor_ex_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XoLjJjg2Xgbe19pZplpYNkg7BzrQI08E0xGPlAInbb4,887 +torch/include/ATen/ops/linalg_ldl_factor_ex_cpu_dispatch.h,sha256=m8MTePggsQs0Nhw3JyHWCw4Ybsy8JxhVUhNG8ieg2n8,1242 +torch/include/ATen/ops/linalg_ldl_factor_ex_cuda_dispatch.h,sha256=EKIdD96tRVvOfjDzeBpt9PMsuS5gA43GrAKUeK94dtQ,1244 +torch/include/ATen/ops/linalg_ldl_factor_ex_meta.h,sha256=SYlxrbzXRfSkOKXTseMfNKXG2m4iGdyEv96krC8ffK4,635 +torch/include/ATen/ops/linalg_ldl_factor_ex_meta_dispatch.h,sha256=OKxqYiYpXg2OHeW9Cn4NN57TeBXFaKjjuBIxqCFl_0E,1244 +torch/include/ATen/ops/linalg_ldl_factor_ex_native.h,sha256=JkpUMmmjOvHfp-V64ZhGVPMN4L9pICpcjxL4KkbcGNg,735 +torch/include/ATen/ops/linalg_ldl_factor_ex_ops.h,sha256=VHR_uxZBq8H1YbNA_un2UUP6a0bjRJjyWocpaA7Tz6Q,2378 +torch/include/ATen/ops/linalg_ldl_factor_native.h,sha256=jBMtlr0l20E5NKpYosznfKdSe-MPeoyTtUal9hV7zsc,697 +torch/include/ATen/ops/linalg_ldl_factor_ops.h,sha256=tx2b2-ddI5UbgmO-xs6ma-2h75I9qMYu9dZWZHdQg4Q,2051 +torch/include/ATen/ops/linalg_ldl_solve.h,sha256=m60NV2vp0ESkD8R_Y-7yQFqjwCgCq0bLXEWGhPLSA-A,1514 +torch/include/ATen/ops/linalg_ldl_solve_compositeexplicitautogradnonfunctional_dispatch.h,sha256=CV3VnzneqLbwlhVjHM7O2zDjR9HbSE7mR4X6Pby-8zw,869 +torch/include/ATen/ops/linalg_ldl_solve_cpu_dispatch.h,sha256=nLU_qlUPQbsrNp3mo2Mzn-ibSdThflElNnDKYxfaHI0,1108 +torch/include/ATen/ops/linalg_ldl_solve_cuda_dispatch.h,sha256=PWy4L7ZdrnQ_IAKEz4LlX0e_-JsjKtZCxSwaKusPsR4,1110 +torch/include/ATen/ops/linalg_ldl_solve_meta.h,sha256=l7WgRWK73ArpN5CXNRtYWb3T2LZkYAv1EPKnaV390AQ,659 +torch/include/ATen/ops/linalg_ldl_solve_meta_dispatch.h,sha256=tzqJiqVOMN5qcLSUIplJXZTaI2UslRcNgKcY80ANcmY,1110 +torch/include/ATen/ops/linalg_ldl_solve_native.h,sha256=BXPd7S6J7IOekheb6lrdAEufpHu4SJpT2oqCRrFjp0E,700 +torch/include/ATen/ops/linalg_ldl_solve_ops.h,sha256=IeSC4dJZUdxWMpbdl8srmGcKpi4_ud90EDuNx83Ldyk,2087 +torch/include/ATen/ops/linalg_lstsq.h,sha256=FzowCGbqZQ7VVWjhmWunps118o93SVih4pDi0xfp2zo,2351 +torch/include/ATen/ops/linalg_lstsq_compositeexplicitautograd_dispatch.h,sha256=DJfbazOeCJaqMNFHmSZUUkx-OUBy8UZpHrZ352nuJ6I,934 +torch/include/ATen/ops/linalg_lstsq_cpu_dispatch.h,sha256=PVawPCDRXizPALQqq_skaR8nv_WI7wZvguW8KaU-Un4,1305 +torch/include/ATen/ops/linalg_lstsq_cuda_dispatch.h,sha256=lh8FJx41eyGyhPFiizi6CCPtxgRMX0xmA5HHiAPvkiY,1307 +torch/include/ATen/ops/linalg_lstsq_native.h,sha256=Tg_tyzt8Dzi5I4U2Tolde25TqzCo6GpqqOZXIuJK11Q,963 +torch/include/ATen/ops/linalg_lstsq_ops.h,sha256=CTnW66Hh9Y6t4PYEyLuNCLNYjf89cYpnzKGdMiHl4d8,2953 +torch/include/ATen/ops/linalg_lu.h,sha256=U8o9FifneHng2M_--lh6Y6uYOLbF2MX0DUkCZCKgaNc,1463 +torch/include/ATen/ops/linalg_lu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=smtmNY4C8YljZ1ykgna3nAc41ErMW43WWQg6y47dWtE,843 +torch/include/ATen/ops/linalg_lu_cpu_dispatch.h,sha256=Xp7_D4L1il7ip5dwwtKO_Pqz3OWh6N0JhFNzzjfoVIY,1099 +torch/include/ATen/ops/linalg_lu_cuda_dispatch.h,sha256=uiYoc1rh5c-9GtJj34CAPP-11HZIBg5k4eDnzkM0JtE,1101 +torch/include/ATen/ops/linalg_lu_factor.h,sha256=xFvxsomRp1Gfj8y4s_v4gdSO5p_-HTJQlwvY7XFepbc,1446 +torch/include/ATen/ops/linalg_lu_factor_compositeimplicitautograd_dispatch.h,sha256=8vUJQ8riaNtEXmkP4XvXh5qDoZu45IrXYH88MHa1EiU,1107 +torch/include/ATen/ops/linalg_lu_factor_ex.h,sha256=Jd2O8obbvGQrucJ3PHPT1HqF8huLnLJafnJnUjF0tVY,1830 +torch/include/ATen/ops/linalg_lu_factor_ex_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AuCmBCTJMmmgAt5ZTS_I4yS8dWyK9zES31pa99w-FFM,878 +torch/include/ATen/ops/linalg_lu_factor_ex_cpu_dispatch.h,sha256=R1P9J-kB3kP7sqH5Lc5ZT5odnFN9JVd10j4YCIm4t1M,1216 +torch/include/ATen/ops/linalg_lu_factor_ex_cuda_dispatch.h,sha256=Mn2CQlZLkBe1FhWH7rMyuCrAp9NzLyay3e4ZgDDw4BQ,1218 +torch/include/ATen/ops/linalg_lu_factor_ex_meta.h,sha256=CmyDT98YlBdSTYpLDEyoCwjhGJFZ-Vn3Fr5wYidjVHY,627 +torch/include/ATen/ops/linalg_lu_factor_ex_meta_dispatch.h,sha256=eXbcXiFGM_Ikqgela1zN1EglIZilZxdeyYAHwZUwU14,1218 +torch/include/ATen/ops/linalg_lu_factor_ex_native.h,sha256=e_VS3XGamzXWwxPEB_FpBfyZ7irUDTlS10pPrANV7cQ,725 +torch/include/ATen/ops/linalg_lu_factor_ex_ops.h,sha256=fpoh8YmqAjndsG2cjfWM4uknJvlnqo9xF2yWxbWgTJ8,2328 +torch/include/ATen/ops/linalg_lu_factor_native.h,sha256=xpqbYMq9GCW_tP8DExeMIELeWI9SXSwdX8nwLDBAdIc,680 +torch/include/ATen/ops/linalg_lu_factor_ops.h,sha256=MSl99HgWh5Ilqr3_WVyuwnIm9loAnE1bPtd3C6-gkvw,2001 +torch/include/ATen/ops/linalg_lu_meta.h,sha256=IUTWgxdT2Abuwop9vWsfvKElBsaLGfgUc1faK0Wmr4U,598 +torch/include/ATen/ops/linalg_lu_meta_dispatch.h,sha256=B8teXxNTtx2YftlFlWnvYJz8Nw3QJVRb22GZmskEWno,1101 +torch/include/ATen/ops/linalg_lu_native.h,sha256=RogYrGKd41B9xQDBxoZEC31NWqtp_CHmaPYGmGGW5gs,667 +torch/include/ATen/ops/linalg_lu_ops.h,sha256=i00jI5Pi1dikFvdf-nsAxUbQerGTzoDLT8YmfPcal98,2085 +torch/include/ATen/ops/linalg_lu_solve.h,sha256=BNcEhxRYmFiA0Hyy2d8uaANCMVeA3e7hG6gKIhsNhaY,1595 +torch/include/ATen/ops/linalg_lu_solve_compositeexplicitautogradnonfunctional_dispatch.h,sha256=yDxFDDhx0T8KutdXHAJhMf9fnn7Iu4JOymmVwAUVA9w,882 +torch/include/ATen/ops/linalg_lu_solve_cpu_dispatch.h,sha256=Pogx7Ji1bVUqqADhPj-IyHf44YPpzm6VLgLM-h6K91g,1142 +torch/include/ATen/ops/linalg_lu_solve_cuda_dispatch.h,sha256=kYq9fGi2__Qzd9GDG9Klte-ryXKZDcl5vbaTSozunG0,1144 +torch/include/ATen/ops/linalg_lu_solve_meta.h,sha256=mgLfCBD5uid2ih6LybmGSkRnM76EGyl8q7jKpddyYYE,667 +torch/include/ATen/ops/linalg_lu_solve_meta_dispatch.h,sha256=nw642a0aRVtBLFvBXa5E_80BBLR7sT621A0pDE3JanE,1144 +torch/include/ATen/ops/linalg_lu_solve_native.h,sha256=WR-Y277oMTYWk7CBZ3OkwHuV_AJH6BJumuVfVWwFKvA,706 +torch/include/ATen/ops/linalg_lu_solve_ops.h,sha256=L0cYgXWYT_Dqsl-VyL__Pq6I9pt67ZPAFA0jrJHraxY,2157 +torch/include/ATen/ops/linalg_matmul.h,sha256=L39TLdEXj80ajEfZQxDTQuBvMoDG4PYnR5-OWFQfzdE,1226 +torch/include/ATen/ops/linalg_matmul_compositeimplicitautograd_dispatch.h,sha256=Q3uz6RawtS4rq_yETtDzm23bP4v35zDesmU8KjkBj8I,1020 +torch/include/ATen/ops/linalg_matmul_native.h,sha256=81L2omQ8BBYmzVk6CcGQna063zeG80QRjj5-xahrCC8,631 +torch/include/ATen/ops/linalg_matmul_ops.h,sha256=SWkk1sA2-nikkuUw_VQD42qY4bQEbozCojGZ5-Q4u1M,1804 +torch/include/ATen/ops/linalg_matrix_exp.h,sha256=fVWkO4u3lhMZylGOIDw5f56NG7QSlwVbD7M6UmF3FMo,1125 +torch/include/ATen/ops/linalg_matrix_exp_compositeexplicitautograd_dispatch.h,sha256=m7KVL5YQSOj0jmGsp6hX59dYJ14RQgYKiy-_kL3PsyQ,889 +torch/include/ATen/ops/linalg_matrix_exp_cpu_dispatch.h,sha256=brPS4ishlrgIM0GQYTkpMfzy5NC14JfUImajpcjnSX0,731 +torch/include/ATen/ops/linalg_matrix_exp_cuda_dispatch.h,sha256=skDxjmJFuCVge-yFNbu8ZZzu9Z3vxQnRtMwD7T3h2MQ,733 +torch/include/ATen/ops/linalg_matrix_exp_native.h,sha256=QyBI4JapGxd326jgIxU6XsQMc_mG-3Z58RCAwYSUJgg,587 +torch/include/ATen/ops/linalg_matrix_exp_ops.h,sha256=Ku2u8WPenxtN8mgUXDBCBfrRFhVSzEyptmQ69be8AAw,1656 +torch/include/ATen/ops/linalg_matrix_norm.h,sha256=pSOkw6WlegYJmtFJ96N6u5vn9HEj30JkpD9jjSRuG8A,3127 +torch/include/ATen/ops/linalg_matrix_norm_compositeimplicitautograd_dispatch.h,sha256=tHDKbhOW6-cPiJrQ7d4jcN-94_Y8az-Kuz-lGIzw8U4,1894 +torch/include/ATen/ops/linalg_matrix_norm_native.h,sha256=QrQQDLGV1RN5ggfUwlNSJJO1PFwiLvrm2zAAkLAxPZ4,1185 +torch/include/ATen/ops/linalg_matrix_norm_ops.h,sha256=rInr_8gyIoJgYetUIA_QYD8CZz9ffj-C2khuxtFVWuk,4301 +torch/include/ATen/ops/linalg_matrix_power.h,sha256=gSFbsjHD9E1MZmm9DGz1UgBjQBWTzUP5i1TkfTPzfh8,1208 +torch/include/ATen/ops/linalg_matrix_power_compositeimplicitautograd_dispatch.h,sha256=3sHPktmIURdB8o_H5ehBCYGQBKRUcb3j3XyhXxILems,993 +torch/include/ATen/ops/linalg_matrix_power_native.h,sha256=PbV7mVeFM-7rIu9PXV2YkBHRiBT4_iZcL1KhQFk3BXg,613 +torch/include/ATen/ops/linalg_matrix_power_ops.h,sha256=L-jE8IZ7kO4L3bvlg-ebebMv-kew8YTHc_SoMnaOUx0,1744 +torch/include/ATen/ops/linalg_matrix_rank.h,sha256=7AHN4Gi4A4-nPW8j_CG5M9PQJn3rksnzMvnfEQMq3TA,4879 +torch/include/ATen/ops/linalg_matrix_rank_compositeimplicitautograd_dispatch.h,sha256=Pl33MJdP9grUZJmmn25e0PR4V6LyclNDTmeRpFJlojQ,2472 +torch/include/ATen/ops/linalg_matrix_rank_native.h,sha256=DIro0-dj11NZTA8ru9b2NvWl9HWOw9qCejE0G9QTSX8,1589 +torch/include/ATen/ops/linalg_matrix_rank_ops.h,sha256=mON-z8k27zEkfJ9Pn0dg1KXR4agN7LGSxIbJgBOITW0,7275 +torch/include/ATen/ops/linalg_multi_dot.h,sha256=3_0zpx2TF9dxPYU_S4utR3U1d-l3yTs7MKc-uo3TRVs,1136 +torch/include/ATen/ops/linalg_multi_dot_compositeimplicitautograd_dispatch.h,sha256=bXaWoHpaT67VqY7UPfhALyd4AzXT1xFQUYeTIp5XiiY,948 +torch/include/ATen/ops/linalg_multi_dot_native.h,sha256=ZPYSBAJDlDERrbadfqBwmzMGffXGkO4GDCBNEjH1hoI,583 +torch/include/ATen/ops/linalg_multi_dot_ops.h,sha256=DprcDcANn2iVicW_KOBVsHhmjPV4bhwCG8qbqjlsoyE,1648 +torch/include/ATen/ops/linalg_norm.h,sha256=3wg0wcu5hjf4ktK4aNcdIKCPrzRGDwXFmfhKYeN6RQI,3115 +torch/include/ATen/ops/linalg_norm_compositeimplicitautograd_dispatch.h,sha256=QC7c2-H4bAyQBliZaNzM5rPdvdrQfPe5ct_9cu-0RKQ,1979 +torch/include/ATen/ops/linalg_norm_native.h,sha256=skSOo11spR16M1fgsDcL6ynKxuRIkT9IUc5nE47tBCg,1236 +torch/include/ATen/ops/linalg_norm_ops.h,sha256=BlLeHOrRm0RNNA24xjkFTnsftB3OJbqrVjMkHVwhB8I,4399 +torch/include/ATen/ops/linalg_pinv.h,sha256=t-zoMOwNFkgUkL77cf7DnHzUNOUqZxj0FMFyMVRJNHc,4650 +torch/include/ATen/ops/linalg_pinv_compositeexplicitautograd_dispatch.h,sha256=Gg5PE5NEY7y2dKqmag5P_JcrtoHGcMjAj96K_mzCvsQ,1081 +torch/include/ATen/ops/linalg_pinv_compositeexplicitautogradnonfunctional_dispatch.h,sha256=6NHDCST6hhEvx3CT8vhPqafaHR-ycasaoe4fvY6Dr6I,903 +torch/include/ATen/ops/linalg_pinv_compositeimplicitautograd_dispatch.h,sha256=sz3ZdwZIDcdadCZst4TysgkKGtdPtkJ4561UH4ArCnw,1856 +torch/include/ATen/ops/linalg_pinv_native.h,sha256=8BeAFR4r-nj-EQcos40TaB83La6aC_8ZRh6-_4CveAA,1537 +torch/include/ATen/ops/linalg_pinv_ops.h,sha256=yCdB2WUwgwXGDp5-cUL_ElP6beB3AnOoXvy-AkGm8HQ,7131 +torch/include/ATen/ops/linalg_qr.h,sha256=_sUND9Njyi1LkZmR3mU1r1mws5-CI0D5g0mr6-AFNkM,1368 +torch/include/ATen/ops/linalg_qr_compositeexplicitautogradnonfunctional_dispatch.h,sha256=FCJ9MjgtDChbM30XPAGtxzi58IARZx8Pix-jSwWHvYk,848 +torch/include/ATen/ops/linalg_qr_cpu_dispatch.h,sha256=euAJ4D_Rp71zYwdcpiG9s4ytOrpyg5ZVY2qlu6fzxOw,1073 +torch/include/ATen/ops/linalg_qr_cuda_dispatch.h,sha256=zb2_m3CL3xSR6-_W538KkXt04STnT-K4IAoEZSUK3nU,1075 +torch/include/ATen/ops/linalg_qr_meta.h,sha256=pxOGqCC4_irm2_0sz69RfvRcutLgDDK8-061Edi8Lzg,609 +torch/include/ATen/ops/linalg_qr_meta_dispatch.h,sha256=xf8OjPcSwRXrluAzKXJerNZIyVrDsQE-bQpsDwyYLGo,1075 +torch/include/ATen/ops/linalg_qr_native.h,sha256=UsiEYew7uDOQGhTPo8dJRVdULVAwp_7DnrG2hNmskoU,656 +torch/include/ATen/ops/linalg_qr_ops.h,sha256=Pz8ZPaLJeU1ZvwQPDQqdNQ7KwSPK6g0AhijqPsisu7E,2000 +torch/include/ATen/ops/linalg_slogdet.h,sha256=hEryXNp3Duc5jji4gj8Nuj8jGz1d70jyZxnEQi8VeMk,1350 +torch/include/ATen/ops/linalg_slogdet_compositeimplicitautograd_dispatch.h,sha256=di5jHc0VrIubufgKqQBOH1etWRrc2u9r9uc_CokyQsc,1065 +torch/include/ATen/ops/linalg_slogdet_native.h,sha256=O5c5zpE-fLRFECQhPW33Tw5mU570Vv_6SqJRsgu79gA,652 +torch/include/ATen/ops/linalg_slogdet_ops.h,sha256=ssLd9_Dj7QIRarPwmxmGmW0LnIUgc6KqxIj9GN06W0c,1917 +torch/include/ATen/ops/linalg_solve.h,sha256=mQWvdhAiJJYvV7Hb6jqGziln3V-UWoA7WPpB5iIsaT0,1265 +torch/include/ATen/ops/linalg_solve_compositeimplicitautograd_dispatch.h,sha256=8cY-0PMm0sj75iR6eBQOs1kYVQj-KBEnWBDhHw1FuNM,1039 +torch/include/ATen/ops/linalg_solve_ex.h,sha256=42EhYNfEm56H4BYQ9JSVtMf_JhGgQ2jyd0RoS7IM9Vc,1736 +torch/include/ATen/ops/linalg_solve_ex_compositeimplicitautograd_dispatch.h,sha256=HZUPTWcwao_GoW3OhxMFul8gRH0OHZBZ1C3eANupxFY,1240 +torch/include/ATen/ops/linalg_solve_ex_native.h,sha256=SWb_p3H_g7vLEMnZWKxroTAGsB3b34Kow66PkUTrbL8,766 +torch/include/ATen/ops/linalg_solve_ex_ops.h,sha256=AYrRef9dAF-nW-zWSSAFT_RJ4GgraPgbnk9JpSUIRb4,2285 +torch/include/ATen/ops/linalg_solve_native.h,sha256=wrn17aVhbZmiZ1dvDZ02xZsHBqHBKHMap73bHrnnDJM,642 +torch/include/ATen/ops/linalg_solve_ops.h,sha256=M6zaCNGtEadidg0twpSLUMZgwcBI8C9I11N3rN3ta8o,1847 +torch/include/ATen/ops/linalg_solve_triangular.h,sha256=P-EyP2A-H3swgf3eHsAS9e5eus1SOxQLGF6g1sYkvQo,1690 +torch/include/ATen/ops/linalg_solve_triangular_cpu_dispatch.h,sha256=4U0K_-QB9weJUUAgCgnwIcCnvo1fDkGLZFqoYyjmcHQ,1145 +torch/include/ATen/ops/linalg_solve_triangular_cuda_dispatch.h,sha256=CQUuMO8zIXOdehSoQQaf1XJpppDNtM9HQ8dmk-yZjIU,1147 +torch/include/ATen/ops/linalg_solve_triangular_native.h,sha256=WupYsjX3itblir82R9-VtJ_qqgaVHpr-pwN2jC3nwrA,740 +torch/include/ATen/ops/linalg_solve_triangular_ops.h,sha256=WGGezErIhDBwXffyvtNXzDspq_G2dsel8nMTQcDDY-4,2159 +torch/include/ATen/ops/linalg_svd.h,sha256=rH4d4_tyq7ZjhLJmr52ffekYU8sWgGsjB7CxpSf-l3g,1770 +torch/include/ATen/ops/linalg_svd_compositeimplicitautograd_dispatch.h,sha256=IK7KHSZdAjNVHOu0D9eMsA_hzTRS9qFQoBKWHxjPeJg,1318 +torch/include/ATen/ops/linalg_svd_native.h,sha256=4vm3RqBkFuRGsgmFG-VM4b81t48rMZBWx7X-ODG3Iow,812 +torch/include/ATen/ops/linalg_svd_ops.h,sha256=cosx4snlCSDNOuv16mHtVARW07t4aI7zcvAVsDQPGi8,2400 +torch/include/ATen/ops/linalg_svdvals.h,sha256=dq1n29QmU8Qv6KJIZL8FKVGq3RODquTGbWlYgTcTSIg,1295 +torch/include/ATen/ops/linalg_svdvals_compositeimplicitautograd_dispatch.h,sha256=NFYSHtOLJk8ybkfTIrstYieb0mluUUF-QzoaoqWTKDQ,1082 +torch/include/ATen/ops/linalg_svdvals_native.h,sha256=iMCnBuQkI2I-FLWRNEG1Eqtu_ngAm9eDeQkEn5P_jNw,668 +torch/include/ATen/ops/linalg_svdvals_ops.h,sha256=eIL5prqWkcgSBMGxNk43ApyxM89u7EYGfT4LmOjeDTA,1885 +torch/include/ATen/ops/linalg_tensorinv.h,sha256=EWKHEeLlrr5em7u5M7PLPwXgeQjhatGG6tuesYor4xk,1206 +torch/include/ATen/ops/linalg_tensorinv_compositeimplicitautograd_dispatch.h,sha256=oBf9t0vCRaKFN8v36An5TaBsmM7utTyFWiKoNQjrhYc,994 +torch/include/ATen/ops/linalg_tensorinv_native.h,sha256=BuQRPF0R9MrbLzGyM445R1xn4veb3Kls0FGBYR9Ur9o,613 +torch/include/ATen/ops/linalg_tensorinv_ops.h,sha256=BQ1dhISC-eY9Ho08wW_Efnv844x3lESkfj7NeCIMzwY,1742 +torch/include/ATen/ops/linalg_tensorsolve.h,sha256=fmDaOIbLyBq2cw2KNZw1sCycf1LqJPhow0yi0zd58l4,1464 +torch/include/ATen/ops/linalg_tensorsolve_compositeimplicitautograd_dispatch.h,sha256=s3IGcJ0_LkSFvFfG2zMCBUJlfcLx2F2urSBpwXWhd04,1151 +torch/include/ATen/ops/linalg_tensorsolve_native.h,sha256=7ZEenDBGwR2yGrM14Y9B3dfgCVQnaTxkY_6N-SwTpug,714 +torch/include/ATen/ops/linalg_tensorsolve_ops.h,sha256=4GuQ8YpSIEPnw_ejgUvgkI0r2l3neM6yuHGTykYOV3I,2040 +torch/include/ATen/ops/linalg_vander.h,sha256=MwhSRao4mw3NpyhhDMMDIXkKj2GbPu2gPiTxfMz4_Mw,1560 +torch/include/ATen/ops/linalg_vander_compositeimplicitautograd_dispatch.h,sha256=mHCqeR9WBFeRjKbs9Znn9Vo40-j5_qwkGH-kPj6qn24,915 +torch/include/ATen/ops/linalg_vander_native.h,sha256=_m8OLJfrP000FJfBHV6kefs9LFeHFiP2JmOOfhkd7RY,541 +torch/include/ATen/ops/linalg_vander_ops.h,sha256=4Z7X4LLDPA5XXAb2Yo2HVn6qSO8XPeW_aD0UEpdETf0,1086 +torch/include/ATen/ops/linalg_vecdot.h,sha256=EDG26VSs3FoZw9SreQ7MzSekmrmIn0Ws6L9sY8rNDeY,1262 +torch/include/ATen/ops/linalg_vecdot_compositeimplicitautograd_dispatch.h,sha256=JNyVgc0Uml-umeeX2Jh2-odMb3qOTkShubw1fYz8N8o,1044 +torch/include/ATen/ops/linalg_vecdot_native.h,sha256=LaFG3FeONBLErrjhXFQC7WVZls7GSSPh1Txj3Tsk1g4,646 +torch/include/ATen/ops/linalg_vecdot_ops.h,sha256=_gvg7DndsvX8iVnvnA_B_uq8M4_13YpbjKodYrkRQ2Q,1859 +torch/include/ATen/ops/linalg_vector_norm.h,sha256=IXWIf1tiTGDxU2R7g1zfgKnRfx-dhssKvylVGYlOhQ4,1824 +torch/include/ATen/ops/linalg_vector_norm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jns-7jmlwFGAm3NCJ3BkAc1nRe1ID-bITrRI_4XMGeQ,940 +torch/include/ATen/ops/linalg_vector_norm_cpu_dispatch.h,sha256=N07of73_K-whnbpLHzXYPykiqOO76-jIs-xmRe11etU,1293 +torch/include/ATen/ops/linalg_vector_norm_cuda_dispatch.h,sha256=9unWe1MUMbKdBEdRIjrKoEnGo3d-aMwPNbEj7DtX5Cw,1295 +torch/include/ATen/ops/linalg_vector_norm_meta.h,sha256=RNNVZoFIEdcUxVw6a7lTZbAtSuaBso500TlontXYmxU,702 +torch/include/ATen/ops/linalg_vector_norm_meta_dispatch.h,sha256=3Z_Rb-IIfi9HqXq2IbhgSFxoW0gUi6rkdUj32rb7yCo,1295 +torch/include/ATen/ops/linalg_vector_norm_native.h,sha256=O8u1L9GY8_yBXY6IpLS9N0thnXqO6c_0Wk0O0LEUQVk,747 +torch/include/ATen/ops/linalg_vector_norm_ops.h,sha256=YQOnU8za3bcFvywYhc2UaS8h-TjlfrvrOQEsTRSeIJo,2397 +torch/include/ATen/ops/linear.h,sha256=7fsxhbt8Gj0-4IhEHlayz5Tnk_0EDJNZwARUyaRCPVo,1375 +torch/include/ATen/ops/linear_backward.h,sha256=xIn4SWPiDEGO2s9XRbUI5AmA_AzDxqQZZozultYPMjA,2014 +torch/include/ATen/ops/linear_backward_compositeexplicitautograd_dispatch.h,sha256=x8aT0z87AANsyzfWu6-B6cBrKo3cAe4XCTM7UVWAslw,1229 +torch/include/ATen/ops/linear_backward_native.h,sha256=FRHYsKeXrrLV8gbOZ4tq7EmWjS5RM7YovYv9wTrn12A,891 +torch/include/ATen/ops/linear_backward_ops.h,sha256=Uf9cBBI3rVZQHtKDDhqxoVjeZIpJb9yJukglMLgFQOU,2665 +torch/include/ATen/ops/linear_compositeexplicitautograd_dispatch.h,sha256=sVxa0F3-7umOXxFjcA-oaXeYSLDtMKb0S96IpTR62Hk,1006 +torch/include/ATen/ops/linear_compositeimplicitautograd_dispatch.h,sha256=RsRTglwQmqAlj8Wk1JavqxAp1btB2Mp4OFZ6_KWMYfU,835 +torch/include/ATen/ops/linear_native.h,sha256=gFahzLiBMTcVqJHI3Dzv9CRUPYe8lwVZvZq7_ITOWZA,836 +torch/include/ATen/ops/linear_ops.h,sha256=fk2Huw8fEDtF5_97kM_BDQM63Ml9tz_jMyJZs0bIhZU,2042 +torch/include/ATen/ops/linspace.h,sha256=0KY2nb6N16krXIuE0ZPLzgrMC-XeHymgSxOmBKrWm4Y,6832 +torch/include/ATen/ops/linspace_compositeexplicitautograd_dispatch.h,sha256=SkzjFipH1a8BHM4Z6_dneXhuetzKc20xZK9iV7ok9yw,2869 +torch/include/ATen/ops/linspace_cpu_dispatch.h,sha256=ulTqqc-sXxiBRDzc6AL_W6IcXoCnwS2Ysmy8aBGb67c,907 +torch/include/ATen/ops/linspace_cuda_dispatch.h,sha256=JMvkDEkCk-8XNIPY2d6NP0bTBfTkZS1V9I-YyLKp30k,909 +torch/include/ATen/ops/linspace_meta_dispatch.h,sha256=tkxveHfnIO5T9J0loBOcuyOII39B9qDRa1I2w0rD0BM,909 +torch/include/ATen/ops/linspace_native.h,sha256=xw8zvOi_SgewBWOp26WOSRtaue8P9_c5tk6xMoNI7Sg,2018 +torch/include/ATen/ops/linspace_ops.h,sha256=nKVE4vK4loDjsQgCbnPF7LsBKBZGEF18yB3BR0GqTss,8307 +torch/include/ATen/ops/log.h,sha256=kBRdxvSaujdJqby4Cv-Mc87iQbai56KGo4j5RxGMpa0,1118 +torch/include/ATen/ops/log10.h,sha256=PXrsx6c4Fqt5pkFaBw8_DMqiqosfxHBrjKjwgE0vD9g,1144 +torch/include/ATen/ops/log10_compositeexplicitautogradnonfunctional_dispatch.h,sha256=NP-hwD4L2nLYQH-POFuf7M7aaDxO37MIm9Eos7DE0Yo,839 +torch/include/ATen/ops/log10_cpu_dispatch.h,sha256=C5AAstlgh3CRIbh2CyQuPjf7cx1LOfzS1wOPuSD8Lek,924 +torch/include/ATen/ops/log10_cuda_dispatch.h,sha256=Zr1dHQslm1PiUXxdBtCE5i7egd5NXEYllVcqm1mgXu4,926 +torch/include/ATen/ops/log10_meta.h,sha256=p3GfjSoqADEuyy5eUgAOjME6TVekSxthl_b_CK2Aj3s,585 +torch/include/ATen/ops/log10_meta_dispatch.h,sha256=dY9_HA9tiH6FFYJRqxKOJFtclnp_fCOM6vSbkXxTh5A,926 +torch/include/ATen/ops/log10_native.h,sha256=-DWMlsNK-9PPDYty9Z8Tj27KFUNvMbqW-TKZmQog7sA,604 +torch/include/ATen/ops/log10_ops.h,sha256=VMWMazkB92iwpPZm8BM33tbi_HLcYV3F2w-SnNQGxxE,2113 +torch/include/ATen/ops/log1p.h,sha256=8mKgv6tkqH9peTpnFzNyH3-E5J1gTTb6Hli6REkmAgQ,1144 +torch/include/ATen/ops/log1p_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KqXkNFECg8JrjY62r8R2-r5pliijNanXqkSeXu61U2o,839 +torch/include/ATen/ops/log1p_cpu_dispatch.h,sha256=T5rxVVCiaBTfbTh_lTDDb3SwWXyu6zE805tKIyneuUA,924 +torch/include/ATen/ops/log1p_cuda_dispatch.h,sha256=pFopz_KuXJjjuKIH-9vQ1bYt-i0F7h8CSgmy9QIiHzI,926 +torch/include/ATen/ops/log1p_meta.h,sha256=LhlVn5X9v3Swz9j_0qucfgrqYyS53ff5X3gK6XUyivU,585 +torch/include/ATen/ops/log1p_meta_dispatch.h,sha256=8vlGzc0v3JC6MpahpYFTVy4Dax2egP7eeMxu7gAcuHw,926 +torch/include/ATen/ops/log1p_native.h,sha256=B6G0D1PLNtZ68fR3Sfzp12WNpRmudEjBNJhDhkQbbkw,1018 +torch/include/ATen/ops/log1p_ops.h,sha256=-gjTT5OwDnkl5GjwOYHhCiICrzkR3YI0AuAGZXa8wtQ,2113 +torch/include/ATen/ops/log2.h,sha256=tGDrpJjOqCI3G_KkVtxqwEjvO68EPgfSZelBl-o7d5E,1131 +torch/include/ATen/ops/log2_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AUm0c7_tnZT8LUY2y0keVJiAqRKPfJJuEXDByhYW1Vg,837 +torch/include/ATen/ops/log2_cpu_dispatch.h,sha256=e3oy2Cug8UiLUkCC-bpv96mszAlcL_Ad4oMMAecPrn4,920 +torch/include/ATen/ops/log2_cuda_dispatch.h,sha256=sHoqPDKA3sLwRv2NWahdofJXAqBmmYM-st74vd6gaCs,922 +torch/include/ATen/ops/log2_meta.h,sha256=Y8meCEx89ZpPAzBiGn0AgA5679-DuzQiFA4aQJbOVc4,584 +torch/include/ATen/ops/log2_meta_dispatch.h,sha256=K6J2HMuMjNMaLtK_6oDLaiv9OaivrMKw_Iy-wr7otKI,922 +torch/include/ATen/ops/log2_native.h,sha256=tfW6UsxOqSXuyhQHZksxtzUXUjszegElAFaCmLPCP94,601 +torch/include/ATen/ops/log2_ops.h,sha256=NbrDDBjdbqX-DJE5D0M5ht9lCuAESM09f3DTeLO3G88,2104 +torch/include/ATen/ops/log_compositeexplicitautogradnonfunctional_dispatch.h,sha256=R0qUyXpi3CT-cR2n2n21s5JHMkySnZD19veEAMxnHVE,835 +torch/include/ATen/ops/log_cpu_dispatch.h,sha256=1scbJNlTj9Svm9bpk8dzdf6qnQaybTuz1FXKK4aM6uQ,916 +torch/include/ATen/ops/log_cuda_dispatch.h,sha256=wVeI5GNaoZ-qVyJot-7teBov9ZniPQ5qRydcuixamRg,918 +torch/include/ATen/ops/log_meta.h,sha256=RoxGxV6PlGOFWSpnIRtqlKrRIIzm7hhxXDINQ3ytrl4,583 +torch/include/ATen/ops/log_meta_dispatch.h,sha256=auLInGknpTv08vFk7YujovQ7UrjDGGKQ7u_2kvcPOs0,918 +torch/include/ATen/ops/log_native.h,sha256=Si5KV81O-IVy43yuzv-tnfm5BDnUjLlpcYJ6PxnqXmk,598 +torch/include/ATen/ops/log_normal.h,sha256=rZprOIO6BGDTNa4bNvdugZM_yJmTcl-8j4t875xu11c,1515 +torch/include/ATen/ops/log_normal_compositeexplicitautograd_dispatch.h,sha256=etoh8eQeRtynTQJlvrL0n1WAf_vt32ugEjDyhGbzKlg,1162 +torch/include/ATen/ops/log_normal_cpu_dispatch.h,sha256=l1rslXqTvnOk3EN_0Bdi4uTA1L7Odn5xmQhB5GnhA-Q,803 +torch/include/ATen/ops/log_normal_cuda_dispatch.h,sha256=GOuQgyWvw-TbgrdgcO6nho3sPQULXPqWxm5BDB9zEvI,805 +torch/include/ATen/ops/log_normal_meta_dispatch.h,sha256=tny11Kd6IvzaJ8dFeYqlwf9HpL-zqwlBhiwicNFlTRw,805 +torch/include/ATen/ops/log_normal_native.h,sha256=UN0t6qadiEGV6oiCjPNcysAm5RC-0281Ff9vQmyCxNk,857 +torch/include/ATen/ops/log_normal_ops.h,sha256=WZI2Z6jVyiMa4kZabvUzpOouPHAFJn2sCitlxjAVJ48,2854 +torch/include/ATen/ops/log_ops.h,sha256=4bX1rkb-mNpEyZu0LlCwMIlOptxvsJHHrRM8QQCzO9c,2095 +torch/include/ATen/ops/log_sigmoid.h,sha256=fqINtW3RblpSxqCwMXtnPMifTfQ7tBQy8KOX7qdlZQY,1065 +torch/include/ATen/ops/log_sigmoid_backward.h,sha256=tY1SnC7NBTPT-cPcTAH1AX7SllY_8pkKyJrdoiO7WsE,1570 +torch/include/ATen/ops/log_sigmoid_backward_cpu_dispatch.h,sha256=VYlouOZtPurG_oFO4ZTpUFIdUdmSissSXnHwwUbb1dk,1110 +torch/include/ATen/ops/log_sigmoid_backward_cuda_dispatch.h,sha256=3XkRbmt3bdVwdEph9u9rM2UL0uXLmp-9Z5DnSkA0D6A,1112 +torch/include/ATen/ops/log_sigmoid_backward_native.h,sha256=x-rP5NYEUkQcSMU8darEbpO8u75pytL2Y4Iaw7v0Mkk,1021 +torch/include/ATen/ops/log_sigmoid_backward_ops.h,sha256=waImE7ReUiakqCmnV-jsoihC19P9TkO0i0u4Q1SRM-E,2102 +torch/include/ATen/ops/log_sigmoid_compositeimplicitautograd_dispatch.h,sha256=Ok7h2c47DYJL1q7NUjbtUav2BOUAybPnMr2b1VKNW_4,936 +torch/include/ATen/ops/log_sigmoid_forward.h,sha256=C8puUi9BA9l-8ZLuA8k_RZh5JEzkiV4b8Q2kbhlHvx0,1402 +torch/include/ATen/ops/log_sigmoid_forward_cpu_dispatch.h,sha256=5OgHsH3a5Z-kQMtzEfBi98VvNN8wm5IMMbBytL1IB0Q,1043 +torch/include/ATen/ops/log_sigmoid_forward_cuda_dispatch.h,sha256=-rD7OmAWyX1Wcaax8-makfMsekD_LD_9HWmldJPKt9I,1045 +torch/include/ATen/ops/log_sigmoid_forward_native.h,sha256=RdzfhlK-AbBBWXIpshFGPEGPLzpuEK6AMalJwnCBRnQ,919 +torch/include/ATen/ops/log_sigmoid_forward_ops.h,sha256=UFCcOMPJ6_o6pcsE5LXkPXQne6XGW0wmU-yxdXKbklg,1955 +torch/include/ATen/ops/log_sigmoid_native.h,sha256=nhDNVPjyA2wOlXBPGD3VwwoY8UOZXFZbto76cN_eouE,575 +torch/include/ATen/ops/log_sigmoid_ops.h,sha256=iBhPLgLkybondELseJbJb2J4PmyIeqMH-IPV12Gcouc,1620 +torch/include/ATen/ops/log_softmax.h,sha256=JtVB53ayO0MtwjFU9xyx1NKmu13X5LQIpKtoXUKiMxo,1685 +torch/include/ATen/ops/log_softmax_compositeexplicitautograd_dispatch.h,sha256=1pAcq9W8w4IT5tywXBjKW2Lr_uXqVfG8hQ7e9ucYHQE,990 +torch/include/ATen/ops/log_softmax_compositeimplicitautograd_dispatch.h,sha256=f54FxV8d0RYrXbO2ziB9K8SP3HfQGCl5WN8imEn6xvA,958 +torch/include/ATen/ops/log_softmax_native.h,sha256=4eK3s6_uuS-pCEyUw5RvKcYLTIvZhf-IM1IlvgfpFVk,814 +torch/include/ATen/ops/log_softmax_ops.h,sha256=FL69wIjMplkoSv6bOGGHFfeT2lVer0Xm1OfQWqEs8Zs,2752 +torch/include/ATen/ops/logaddexp.h,sha256=ciJPFVwMcbLiTL2-bSHsN6xD7lcum1Xkrp1zXF0BGOs,1186 +torch/include/ATen/ops/logaddexp2.h,sha256=djKiVy3RVa22g_BBEkwlH2MzLAJ07pzpu9X4XlY4t34,1196 +torch/include/ATen/ops/logaddexp2_compositeexplicitautogradnonfunctional_dispatch.h,sha256=7I_XgYDS5ZZvdVRH0t4O-L0t9usQninkZbDmQ2R1Yg8,820 +torch/include/ATen/ops/logaddexp2_cpu_dispatch.h,sha256=u2Ny-PRgGqX-rACBKejXub6FbUsFj_1grlY29le0LYE,967 +torch/include/ATen/ops/logaddexp2_cuda_dispatch.h,sha256=N53TT8UTTQs_6_fj2r66JFVKnGSzdK9OMvYPakUoq-I,969 +torch/include/ATen/ops/logaddexp2_meta.h,sha256=lTL3ZXBI0O2y4Sx1l1JcuY3fs6hol-_du2a5dRBSwe4,616 +torch/include/ATen/ops/logaddexp2_meta_dispatch.h,sha256=KSp3Tv1k2J3YO9vIcmk8U3V3IY7Qn_sLk2a-aLTHEbU,969 +torch/include/ATen/ops/logaddexp2_native.h,sha256=mfv45iAGbZZNo0Vo4t-yaxTx4mHvNxh3I7hjOA49Sec,645 +torch/include/ATen/ops/logaddexp2_ops.h,sha256=AmJtikJ02iO56bYqwUVRPfWwJJqQVQa5Zx2LlKINW8g,1786 +torch/include/ATen/ops/logaddexp_compositeexplicitautogradnonfunctional_dispatch.h,sha256=bc27hqaHJuF1-PlT74ga5CIv1PLV0HoH68lFFA3cGhQ,819 +torch/include/ATen/ops/logaddexp_cpu_dispatch.h,sha256=2ugkj6JTjpTaG1GFYnO6iTJdnakkXWesKbUEard7kSc,964 +torch/include/ATen/ops/logaddexp_cuda_dispatch.h,sha256=nkHjcXhFtrSZH2JCgkqFTVcLWhYDxd6WqQB6txJomh0,966 +torch/include/ATen/ops/logaddexp_meta.h,sha256=p9pIsTyN6cCUaj1XwBl-KU2DuCuzIpbeBgV7qOgoCNY,615 +torch/include/ATen/ops/logaddexp_meta_dispatch.h,sha256=DLlzaAJCcqQCfWMoYf-woFqFHzGT9OWtdlJgrDssoys,966 +torch/include/ATen/ops/logaddexp_native.h,sha256=kTPoq8ngJaiv7Gx7sN36j7kO5rVVlGLQqiZBT8RjAiY,642 +torch/include/ATen/ops/logaddexp_ops.h,sha256=vYe9kVx_sbwcauvdwIgdN_03OPclBAngglDcsHDaa5I,1780 +torch/include/ATen/ops/logcumsumexp.h,sha256=Y9U45TW2nTkWzvPhINcHdVHqivAggkPxcGT1XGBlXQU,1888 +torch/include/ATen/ops/logcumsumexp_compositeexplicitautograd_dispatch.h,sha256=ZdaEVXzPSlWPdldhhjL0zBH0UhjHyuJRqoIoGr6E4CY,978 +torch/include/ATen/ops/logcumsumexp_compositeimplicitautograd_dispatch.h,sha256=maRoxGYE-a9toJGDnFV1WTVX1tVbIG8zT8D5giqhCrk,990 +torch/include/ATen/ops/logcumsumexp_native.h,sha256=ZPIRKEeBvdSD3omS6t60zEkB2yUIc8hjoxuhOWiXUlc,781 +torch/include/ATen/ops/logcumsumexp_ops.h,sha256=URmMrvevQ9gWQR8DF7LyIQRccbtIXC7647KXu8UGOP0,3073 +torch/include/ATen/ops/logdet.h,sha256=KEYhyuZLmepDRuZ5udCrNaxaAv12txmFrBy4oqXM72o,625 +torch/include/ATen/ops/logdet_compositeimplicitautograd_dispatch.h,sha256=sakW73DeFiy3EJoOI6TnZOja4Ux7KfqfyAJlzBDeRMM,764 +torch/include/ATen/ops/logdet_native.h,sha256=UItEOD4mFYabCwpDaWh6SWUm7GIhTvmlQX87ctAFg6k,487 +torch/include/ATen/ops/logdet_ops.h,sha256=9XCtUP-QmX6Dw4_RRUiCMzx6r8XvR-apvYQbD0J7VFo,967 +torch/include/ATen/ops/logical_and.h,sha256=XMA0i9swZpWX284BEPlExTD6MsS2NF152aUqT_hckQM,1206 +torch/include/ATen/ops/logical_and_compositeexplicitautograd_dispatch.h,sha256=B7nBUHUsDDcnUtb1jr4pi59wEiKtks43m2-cXR9IkrE,877 +torch/include/ATen/ops/logical_and_cpu_dispatch.h,sha256=dzXGNFHfpMDWfxKtEa08QXJNUBqzHveh55Bk8v7_1wA,885 +torch/include/ATen/ops/logical_and_cuda_dispatch.h,sha256=kwNsiuoj3AuhHyE9u5oh69fg8T64zXEoBzWy7gRZo0U,887 +torch/include/ATen/ops/logical_and_native.h,sha256=ejfi2PzDXP1IUEk8Fyd6EEkBffJ8Ob8gRc8eXtybG7U,709 +torch/include/ATen/ops/logical_and_ops.h,sha256=9WEpX5w7qUbDJq_k29h3wQu68Yim_lLcXIkeOu3oFm8,2425 +torch/include/ATen/ops/logical_not.h,sha256=m8sc3YfgQBmSpvfDV98nV88azV4K6w9VsIfmKI72ziw,1065 +torch/include/ATen/ops/logical_not_compositeexplicitautograd_dispatch.h,sha256=c0_UHtPG0hnPwvNGu2xPlvh_qD7--bZ642QUCSnJgTM,825 +torch/include/ATen/ops/logical_not_cpu_dispatch.h,sha256=tob0XD-izc3K5yvLxOcasfCwB-kPs4OxhPT3Gs00oK0,833 +torch/include/ATen/ops/logical_not_cuda_dispatch.h,sha256=W9vTjbo5wcHui6al3CEyERTrkmEWS9zjyYAM4XzUvZ8,835 +torch/include/ATen/ops/logical_not_native.h,sha256=4HnY8WeU3N3jhqfFxa-NKDAM7EL6cJ0WRFxjkq0u5ek,772 +torch/include/ATen/ops/logical_not_ops.h,sha256=KNfZuS8HKrXNVSRUoYtxMWY1nCELGYng_ZDv2Wh9toY,2167 +torch/include/ATen/ops/logical_or.h,sha256=d257H4bJ6CG8jOA6_D-M6TX2U9lmIA9v-t1CSt2wZv8,1196 +torch/include/ATen/ops/logical_or_compositeexplicitautograd_dispatch.h,sha256=xBax8bjDlC3gCLLjnSdnVH2g7hNdMvoWPKL4n1nryRI,875 +torch/include/ATen/ops/logical_or_cpu_dispatch.h,sha256=mxXGaNamr-nRzho_VXH3HaQyZocaHNaY-0kTBD1tjCQ,883 +torch/include/ATen/ops/logical_or_cuda_dispatch.h,sha256=2Rp4qKQPdSifWBc6nViCNeEK_D_O8jR07tAsFtpII6M,885 +torch/include/ATen/ops/logical_or_native.h,sha256=Nv_Vbz-ngqfxL0LSTjWSEAQvFwFWm8ZEA3PurIYxxTQ,706 +torch/include/ATen/ops/logical_or_ops.h,sha256=pEL60h3bX3FG_kHjMR8BIgHrtOK5dkB2zh8FSPqjgtE,2416 +torch/include/ATen/ops/logical_xor.h,sha256=CaLcPkSYCM-J43t1nw2CcmsoNUBEn8Lro6G2Qj9cUFM,1206 +torch/include/ATen/ops/logical_xor_compositeexplicitautograd_dispatch.h,sha256=byN_XRa6285A-DveuuYDr9Fh_2JvCXR3hQM3mM2qsec,877 +torch/include/ATen/ops/logical_xor_cpu_dispatch.h,sha256=MNYc3FYQRAZSXG-HbtrtX05RycNuWN4wniBkT3WKNXw,885 +torch/include/ATen/ops/logical_xor_cuda_dispatch.h,sha256=HlO2iVUTQ37xwSimEDWQrjpVQla4z9umbNEljEpeeTc,887 +torch/include/ATen/ops/logical_xor_native.h,sha256=fK7t2JSK7IYxdf9GYDgOGgrsZAG1djxz7B0i_278GKE,709 +torch/include/ATen/ops/logical_xor_ops.h,sha256=dSQPCiXaY6LFMq5QZTzON4B-mOI4TyMs8d6r_zBobGM,2425 +torch/include/ATen/ops/logit.h,sha256=4XSSNAgLHYJYZK0B7G9DcF85SQECw5xTf5L2ZJWJJHk,1379 +torch/include/ATen/ops/logit_backward.h,sha256=y41q7PYlhr7C-gMwt3v6wkQ_n6VNuhzhIuAUZJlDOPI,1533 +torch/include/ATen/ops/logit_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=CSxVyNFD7eWCRbjQ5cO0S_TUMocHqGMSYUVCBzq-6vk,870 +torch/include/ATen/ops/logit_backward_cpu_dispatch.h,sha256=XMmC-5e9Y7pEY7hs2FtOPppCUDRPxXdzqvOBPYaVC44,1118 +torch/include/ATen/ops/logit_backward_cuda_dispatch.h,sha256=3gClIMKJzZkeiV5vXYadMxoSQhV2p_7XZGC5zaokx_c,1120 +torch/include/ATen/ops/logit_backward_meta.h,sha256=2h5EPsE75YeGo3KaBk8-dLP-W0rSV9rIdRiHZF7zdww,653 +torch/include/ATen/ops/logit_backward_meta_dispatch.h,sha256=aHiDpUM5bJbKRVhwFwBoBgSlX_dVccQs-maFbFs54tk,1120 +torch/include/ATen/ops/logit_backward_native.h,sha256=XXQ1iUxoljvcCB5nuyb5Fnb8WTAWpTGSOJiWIx9TaeU,697 +torch/include/ATen/ops/logit_backward_ops.h,sha256=G-QYCWWmzHqXOtzLfoTovkMD05aP26OvMUnheKBDNoU,2076 +torch/include/ATen/ops/logit_cpu_dispatch.h,sha256=yYIri6xqOJjcWNVZ3ScQA2Z6Lur9iMc62fzUCfXN5KE,1071 +torch/include/ATen/ops/logit_cuda_dispatch.h,sha256=9jvZQgCy7vjpEVrk2kQZqnSsMPYFdaDU2OX2iVj2Hs0,1073 +torch/include/ATen/ops/logit_meta_dispatch.h,sha256=_BuD6rSOVdAss8BSJXzoSOd01Pdv_GRsnZEe8C1Z1Rc,758 +torch/include/ATen/ops/logit_native.h,sha256=J4pQzirsoB2eYfn2CLsloYUCIc5Mnk0cq5X81DIMUa8,720 +torch/include/ATen/ops/logit_ops.h,sha256=1OzmAv6dyVbDQ8TTpW0T4_lIvPKGBsj9dm5Pwjng98s,2395 +torch/include/ATen/ops/logspace.h,sha256=SdzNIw0xqZ36ibpQ_KlRXCerI221TPym44VEofxwd9s,7448 +torch/include/ATen/ops/logspace_compositeexplicitautograd_dispatch.h,sha256=NB0a9nvxG3To6obIr1X-qigeBePzMozJa1MzR1Y_38s,3086 +torch/include/ATen/ops/logspace_cpu_dispatch.h,sha256=lIbC92l2z6YYc1i69eBuzc9N3mxFJLCF6E2Qvhs5-lY,938 +torch/include/ATen/ops/logspace_cuda_dispatch.h,sha256=Xi-FnMUCpNarqwhTiE7UEzDtf4sU79WyplN-hg-5C4c,940 +torch/include/ATen/ops/logspace_meta_dispatch.h,sha256=KLZEzq5BpvGTkBIU9xk5s4ksGuoETrCxMAhMLoM8Dwc,940 +torch/include/ATen/ops/logspace_native.h,sha256=wMdJDitKqhyGiorviXHr9ET8ot6Bugp7JJYODrWDWHE,2155 +torch/include/ATen/ops/logspace_ops.h,sha256=HCwUnHbcAWydHbbzETqmQO5yEbJ4XQqaP_Hj2q4HINk,8715 +torch/include/ATen/ops/logsumexp.h,sha256=TB6QCS9C9JKZQTvoQ-yWxFbX7Yxi1EKB8PlzA_wMYb4,2155 +torch/include/ATen/ops/logsumexp_compositeexplicitautograd_dispatch.h,sha256=UrwIhA6det4vpkAUASP5QCkB5lxt9mfTIe6sfKJ1o8A,808 +torch/include/ATen/ops/logsumexp_compositeexplicitautogradnonfunctional_dispatch.h,sha256=IcoFrqLTlhRccV0UBYg8WcUR8cDbWP8qUUs5DB5Sb2Y,975 +torch/include/ATen/ops/logsumexp_compositeimplicitautograd_dispatch.h,sha256=zK_0YBaabZeNgognSpNYm0UZxRn6RSwfzgBucfiUh8o,1047 +torch/include/ATen/ops/logsumexp_native.h,sha256=42wUaie-IyIutRl4qkz5TGFYPgfSi6-LlOzqTlLcNFI,861 +torch/include/ATen/ops/logsumexp_ops.h,sha256=fm1fNrD_Jf9uxmIqGDvZfx5tIfOHFSrOk5irIx82sZY,3325 +torch/include/ATen/ops/lshift.h,sha256=uibLGdx3W9jR3796lLsC59hG1YXASGbJL9qIb53KcoY,1978 +torch/include/ATen/ops/lshift_compositeexplicitautograd_dispatch.h,sha256=x4myy8Ylu7bzDpBNtcllaXLY81TSMLY0EPrn0eahh7M,1144 +torch/include/ATen/ops/lshift_cpu_dispatch.h,sha256=ImbVJ1OFP-DKtWTFKCfEkjMU-BE_IXHa9yro9xn7fJQ,996 +torch/include/ATen/ops/lshift_cuda_dispatch.h,sha256=Mfch3l_jbK5XQNfaLhXp6Ocvo5HUKhGNsQzHcfLPGw0,998 +torch/include/ATen/ops/lshift_meta_dispatch.h,sha256=8BQni9LNubFUj5L9wWrzOIIUCYoG5w_N5p0wEXKFP0U,830 +torch/include/ATen/ops/lshift_native.h,sha256=J2FMS6oqmiE9RbYyQD7Zv7xT25hJ29uu6Izmj73LjtI,993 +torch/include/ATen/ops/lshift_ops.h,sha256=lMAbUXO9G11jNkW4T1b8Xa78MjXkS029WDzU3eemjqg,4520 +torch/include/ATen/ops/lstm.h,sha256=e2utVUAM8wG4b8VDiRv82ScNsqkyg-Cy3XypGTRvNgI,1601 +torch/include/ATen/ops/lstm_cell.h,sha256=5Dy3BUzfvljOU7gnJWeVTlIrqaKoZVe4pPcprdC3WRw,935 +torch/include/ATen/ops/lstm_cell_compositeimplicitautograd_dispatch.h,sha256=V1I_BQsMZbtLXgy7EX9fYm3v75RxOLeXa2ZaR4Dpk3Y,948 +torch/include/ATen/ops/lstm_cell_native.h,sha256=gXwNSyM7JM2AXsy0n0EPY7h9BT675Dum352HymlIARg,671 +torch/include/ATen/ops/lstm_cell_ops.h,sha256=dultg311Un6Q4M2KQAK9BMOAHJ6MhgkdJiKvKEfPais,1565 +torch/include/ATen/ops/lstm_compositeimplicitautograd_dispatch.h,sha256=fkyqlCWp8UACGxzhsW-_yZrLasxjQYICWWrzftAIlYQ,1191 +torch/include/ATen/ops/lstm_mps_backward.h,sha256=xpYI8JQqwq998RzUFNAkgjhuPjUbGTE2N58sF4SvMHg,3645 +torch/include/ATen/ops/lstm_mps_backward_compositeexplicitautograd_dispatch.h,sha256=0UtOvBVVoRn4UgxEcsrLfSYljaKYc_8iZfI_xeOCB6g,1701 +torch/include/ATen/ops/lstm_mps_backward_native.h,sha256=9B-EL1yBAsrTiBwsd_5AvjI40Uxqxm7UFH-0pmmiQX8,928 +torch/include/ATen/ops/lstm_mps_backward_ops.h,sha256=9S2U8U0upElrqYoRH-S9ziKm3TtpeNFPvqQNLDJ0BDo,4441 +torch/include/ATen/ops/lstm_native.h,sha256=o3PMhWEnBzHrnz7rpwMsSg8VUpYIX3UKZx_6t-fP0oA,914 +torch/include/ATen/ops/lstm_ops.h,sha256=4uGYzXkv_YzOjtwsnac3ARqpnng6ZLBX3V2lcg6ydeA,2800 +torch/include/ATen/ops/lt.h,sha256=Niay9kilblvu43ffVkd-P-lol4WOeRaxOv5RA1nTkVg,1830 +torch/include/ATen/ops/lt_compositeexplicitautogradnonfunctional_dispatch.h,sha256=SArQJmYLRzdjhA9J0YtsRqanWbpkkk5zgBBStLxzXOM,1034 +torch/include/ATen/ops/lt_cpu_dispatch.h,sha256=8cQPcA5Xp1iDmRxCcxKx4l1mRAAiZXSIDRF1vZCSMBo,1366 +torch/include/ATen/ops/lt_cuda_dispatch.h,sha256=b8TooVTHOkBITOLJYs3wsDVv86xvYXtXSpy_Idg7Bd0,1368 +torch/include/ATen/ops/lt_meta.h,sha256=fV4WjB-PzIvhd5rZWsphTq95ngbt5wjedtruUNhd4SE,762 +torch/include/ATen/ops/lt_meta_dispatch.h,sha256=axFyNImwwx6g7Nw3KlcTs7sVCnQ3pVMj7fjo8FFv8DU,1368 +torch/include/ATen/ops/lt_native.h,sha256=hMfYBXg_UJmWgei_tA4ha48Uoq5HGv93VixZYOM8Jk0,1216 +torch/include/ATen/ops/lt_ops.h,sha256=oSUkOkhlcuK9H2yWjI7nyQ8XBVvh6uGez0EZpWzJK-w,4376 +torch/include/ATen/ops/lu_solve.h,sha256=bpio8iokexr8D_crgsiX4aZUnlT7MbLzADMYhThK6e8,1371 +torch/include/ATen/ops/lu_solve_compositeimplicitautograd_dispatch.h,sha256=6-UqzkNBV-lzs9QzSQEJGtdwXCHupVq2c8AGODa6REs,1101 +torch/include/ATen/ops/lu_solve_native.h,sha256=ypER_nRQaAUFhBkSlk1Kp7NhbnoC_UoxE7fNtWGO9K0,685 +torch/include/ATen/ops/lu_solve_ops.h,sha256=Gp6XD8HHV1TqgNhX6OjiSj-zBPjBwrZAjIDVB4lIwxo,1982 +torch/include/ATen/ops/lu_unpack.h,sha256=BDmtY2V9IQS93k49ZyyFdCN0elRtNJrLrFLs6V68LsM,1935 +torch/include/ATen/ops/lu_unpack_compositeexplicitautogradnonfunctional_dispatch.h,sha256=uknmKso8TMw5EhozlajBM-DkV9dXFO0WTr71SVUfMfU,910 +torch/include/ATen/ops/lu_unpack_cpu_dispatch.h,sha256=8V3hXMYZBq1UiRSMlyFWdNLUz8mgALSplAnvjrzu408,1295 +torch/include/ATen/ops/lu_unpack_cuda_dispatch.h,sha256=_n5AavfVhIkZe7F2ysigMDGt09FL2nPHkOJufdPE4l8,1297 +torch/include/ATen/ops/lu_unpack_meta.h,sha256=1FoWSI_YrdFOoxBMoq2_pT_h3jw-3HFvBuKSvbc4i28,660 +torch/include/ATen/ops/lu_unpack_meta_dispatch.h,sha256=bjfhj2g0TjCgAjc4SIZir8fBgrR3otbysU-tIn5YHc4,1297 +torch/include/ATen/ops/lu_unpack_native.h,sha256=osRGJN-JmKc_o2Qw_6AEOiY0rXexxeYrFlJkAMJtptA,729 +torch/include/ATen/ops/lu_unpack_ops.h,sha256=C0sL3Zutx3J54O7HJNi8qfL-I1ImkUkQf1apWuhkBfI,2492 +torch/include/ATen/ops/mH.h,sha256=Jglri1vGC4-ZR3w1yr6xmua6Ryp7g8nIs_jckfwM3rU,487 +torch/include/ATen/ops/mH_compositeimplicitautograd_dispatch.h,sha256=Qgn_B4neSq-pHvFFlgIrYUmjDfzDkDXeFqWYTX2atNk,760 +torch/include/ATen/ops/mH_native.h,sha256=t1VzCcjHiTaxa7aLg580ClparYvvDPP-GvIz4ggcDSg,483 +torch/include/ATen/ops/mH_ops.h,sha256=cLNQa865PZ3SoxKiOVwpx8UZALX9yifKivX_Vi7I8do,961 +torch/include/ATen/ops/mT.h,sha256=kDG_AJra-JMEvF5YWiKjQOnBu9j_G8vdSGHNp8YhDBQ,487 +torch/include/ATen/ops/mT_compositeimplicitautograd_dispatch.h,sha256=9XrU66nNz5i8TeYoRIaxRsuVZhBXBB4Plz9Vz_Tztp8,760 +torch/include/ATen/ops/mT_native.h,sha256=YjOpGe479tIF9WeJoZkA2pX9nkS-VEjeHwEipO30faA,483 +torch/include/ATen/ops/mT_ops.h,sha256=p5lsPyFQN_IhodPzLGgdMkUdLuWkUsDlLWBM4XQAdLU,961 +torch/include/ATen/ops/margin_ranking_loss.h,sha256=5uHM-bjy1JlUKELJPDPwLHPvZYjY2Kgm6v-jV5Y43FA,898 +torch/include/ATen/ops/margin_ranking_loss_compositeimplicitautograd_dispatch.h,sha256=bdfxYFL03AA-RibFkW4dSxsGa5Qi9yamzvUIEnD98LE,891 +torch/include/ATen/ops/margin_ranking_loss_native.h,sha256=_I4_fyepST7oBnP8SX88pqH0wmSnO_rOxk1LccdOP08,614 +torch/include/ATen/ops/margin_ranking_loss_ops.h,sha256=yQDKUukOnXBwGxy4FY429Z3w1-VDXOoIE4d7-5PO9Ig,1313 +torch/include/ATen/ops/masked_fill.h,sha256=_EbMQ-ePZNOmlh-FOVjBzMPPJjmya7rztXI7A7lkZ7Q,2265 +torch/include/ATen/ops/masked_fill_compositeexplicitautograd_dispatch.h,sha256=GtC3FtJQ3kwkxuAo642-kJdb_qckd2ZzpS-iULidfzY,1468 +torch/include/ATen/ops/masked_fill_cpu_dispatch.h,sha256=DWObWOVWsfS7hpSg7kn_0utMHCfake_YmwAgAUT8JCg,880 +torch/include/ATen/ops/masked_fill_cuda_dispatch.h,sha256=WahwAlL1cI8vj-6jdBQ2mJQsYIOAlGJVTtm7MCjXWAs,882 +torch/include/ATen/ops/masked_fill_meta_dispatch.h,sha256=YXkifJG75xG23gj1o9EmvemHPRbvyhztqSN-knCvk4k,882 +torch/include/ATen/ops/masked_fill_native.h,sha256=jMcp_4fjlQFB7S1G4cRyUWO1ETYZaY0LfD81E6eC9qI,1990 +torch/include/ATen/ops/masked_fill_ops.h,sha256=ecc3eDn5qb0kjoTR_5a96wBezNpWdDV_FueAIkly9DI,5036 +torch/include/ATen/ops/masked_scatter.h,sha256=RwcnvGS52j93yRoChAWoQAbaNFOXo112_2eB6xDOUFM,1377 +torch/include/ATen/ops/masked_scatter_backward.h,sha256=wx6qqlUpdL3GPYYntJnCOwIQI3dZmyqVZp1ATnMbp4s,1788 +torch/include/ATen/ops/masked_scatter_backward_compositeexplicitautograd_dispatch.h,sha256=Fq6xvGYz_QvL5SMKHBwzjsQAZxOLgwe9Ze7A_6sdvTo,973 +torch/include/ATen/ops/masked_scatter_backward_native.h,sha256=X0MHZO73Xo2HpCoqq85r_R1nxN-iioY0FXWBnx82tHU,570 +torch/include/ATen/ops/masked_scatter_backward_ops.h,sha256=3lvuKm4FiYWit5BaIAQ_xi2hlUooZXh5W0f9OZ3zhw0,1213 +torch/include/ATen/ops/masked_scatter_compositeexplicitautograd_dispatch.h,sha256=HMpnqJA8Prp_D--kCluZ7KhvCIW3rQAies1AhDq2unU,1101 +torch/include/ATen/ops/masked_scatter_cpu_dispatch.h,sha256=_Leg0ox_AEk2TWF1pr2Sa3HZk5ue1ydwvDImeokiFno,777 +torch/include/ATen/ops/masked_scatter_cuda_dispatch.h,sha256=sNnC6beSVZc45z4K7MmAehRQ73m-qmhgkZ1VJC0Fi6w,779 +torch/include/ATen/ops/masked_scatter_meta_dispatch.h,sha256=8XCK4lE9U9k7q_CCD857a5Xs38lcEOa7MDWa1D154SE,779 +torch/include/ATen/ops/masked_scatter_native.h,sha256=ZlM1nVXZ2orBpOZpxkrb6z0RHqLr77DX633lZeGPctA,916 +torch/include/ATen/ops/masked_scatter_ops.h,sha256=a7uV62SrSgGX6lRzgNtfHrJy1ze9WQTKXmx_1dWEigs,2710 +torch/include/ATen/ops/masked_select.h,sha256=exCRhiM2FdCtCYqSI45koKZakvUQOoX0ArBbpOmD9ns,1217 +torch/include/ATen/ops/masked_select_backward.h,sha256=rw3bRxMX7MSNvKQMWixfr4qU38IbVD27HPASfvWhdtY,780 +torch/include/ATen/ops/masked_select_backward_compositeimplicitautograd_dispatch.h,sha256=2RFDp1nA2LuekX6SdqsjouB2lyEE4l2YKeK0dx9fJG4,831 +torch/include/ATen/ops/masked_select_backward_native.h,sha256=4MWrs0VKmfc8WsEZaQV7--hWzz4CsrCWM495S_3j4Vc,554 +torch/include/ATen/ops/masked_select_backward_ops.h,sha256=hDyHqsvk_q8EGODw7GJr4ohBI3O2z-AyR-ddVxNWqM8,1184 +torch/include/ATen/ops/masked_select_cpu_dispatch.h,sha256=8Yt4cYmNe_XhIorOZp6C2YdCxP9qXjyAtqgfTeLourM,973 +torch/include/ATen/ops/masked_select_cuda_dispatch.h,sha256=flnYJp7xyQbIouWT8T3ojlp61gnxOuX3fRaylYutPjA,975 +torch/include/ATen/ops/masked_select_native.h,sha256=mQts7YLhDtSpJ34PXFuaQvj8dfKakb_J5ORCtHmkJYg,843 +torch/include/ATen/ops/masked_select_ops.h,sha256=olTZ87FOp1uTJUha7l6tzv8E9lJw8bpQoz8cXkYlCj0,1798 +torch/include/ATen/ops/matmul.h,sha256=8xvjzS8MS3IyXouIcgZ-Lks905KxKDVDk7sMRXjques,1156 +torch/include/ATen/ops/matmul_backward.h,sha256=UL3dgJwP0P4UaKwK8hHk3qXn-SrOyP_tjwxH_4SrBAw,1726 +torch/include/ATen/ops/matmul_backward_compositeexplicitautograd_dispatch.h,sha256=IfZAwsZXBjNcNtWoYyxLNmLAP-8-3M9v3CrPt_M6FD4,1135 +torch/include/ATen/ops/matmul_backward_native.h,sha256=hb-A_VBd4CUr1VDqQrgPeZtzWtq0J7nwIVH_QLLfGWA,818 +torch/include/ATen/ops/matmul_backward_ops.h,sha256=bo-yyzhkdhIQf6SdoUtq6Aq5kFgd3_Z7uGX447LbnDc,2414 +torch/include/ATen/ops/matmul_compositeimplicitautograd_dispatch.h,sha256=QJtM3u5qAYC6-faSHGw1n0_QJhQXCGkOInYiOQrSZaA,999 +torch/include/ATen/ops/matmul_native.h,sha256=a8EI-ve4QEyZuwBV5VpkhxMriDtbLn2xUOVA3Hqz4xI,815 +torch/include/ATen/ops/matmul_ops.h,sha256=-d5ZUx3JeMDLE8LWeJrK_xjVhpzjQ1j5t24u0ISjrzs,1762 +torch/include/ATen/ops/matrix_H.h,sha256=h22jKZVvthNCtb-Hyc6B5-xyyEsAhA-bLEPofsIR0ME,493 +torch/include/ATen/ops/matrix_H_compositeimplicitautograd_dispatch.h,sha256=-ajflMamPGTvhRi4uy3-skucUUufMNlXVi6AqqP6Z3M,766 +torch/include/ATen/ops/matrix_H_native.h,sha256=8VMFPyYSpWRe8E3-0ds4fAmk2PE432f-bCeAmgpbzSc,489 +torch/include/ATen/ops/matrix_H_ops.h,sha256=88FqmS-ruJsbTZggReLMHxEWZCtxdiN74HLrZp-js6Y,979 +torch/include/ATen/ops/matrix_exp.h,sha256=WAKVQSB4ey2QRI8iOFqIDvuDB1hWQemYOgGSLTRbVLI,641 +torch/include/ATen/ops/matrix_exp_backward.h,sha256=eyRN4U3FTbNGd9WXji-qEX8ZiC42JD-AbsOLVuF1I1o,721 +torch/include/ATen/ops/matrix_exp_backward_compositeimplicitautograd_dispatch.h,sha256=uUS28D7wPGFYwHYcsXYkmYCd5u92FjNrrjH6fIpR4Zs,802 +torch/include/ATen/ops/matrix_exp_backward_native.h,sha256=O08w6Ve-fmwiuQelFbp6n_dn-JUPemWJI5dltuwWwUw,525 +torch/include/ATen/ops/matrix_exp_backward_ops.h,sha256=HWbsK70bFpXN9TQzq6MY009goecdIRZ9e6xB2a34o3Y,1089 +torch/include/ATen/ops/matrix_exp_compositeimplicitautograd_dispatch.h,sha256=BTFybvwdLa7K-3s4NLMqEih9GfEaV3V7dQcrPTSgBYI,768 +torch/include/ATen/ops/matrix_exp_native.h,sha256=zcUwmXWjlk8DYkbrl2USB7Ab66yfjbDn5MLPIqQQqR8,491 +torch/include/ATen/ops/matrix_exp_ops.h,sha256=ERRMvk04r1faHxw4wmZWJnnFlt3lDQZgcAfnRX8B4vc,979 +torch/include/ATen/ops/matrix_power.h,sha256=yLxgn2Sj-8AXoefYTpWYkoE_qNGIzYc8Lte85K-FS8Q,1138 +torch/include/ATen/ops/matrix_power_compositeimplicitautograd_dispatch.h,sha256=ggBKUWmjgiq4CPpuybMr49VyOwqgVHHpTPKx2UgsQzQ,972 +torch/include/ATen/ops/matrix_power_native.h,sha256=wdNqlCx0Jf0Z0A2ssJhs3-17mPdfVG3Uq5OF465rYn0,599 +torch/include/ATen/ops/matrix_power_ops.h,sha256=BZ2IUjwXXdtgUR9W_qCl1O4BtZL3JANnktrhUFLgaHM,1702 +torch/include/ATen/ops/max.h,sha256=en36XurtpBq2woZgjGEVsCq7kCe8Em-6A_esIBdXQWI,3772 +torch/include/ATen/ops/max_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oQgn2RhxmfMGPuFSINQjiah5-NfLl-LS3wWBFMjcf9s,845 +torch/include/ATen/ops/max_compositeimplicitautograd_dispatch.h,sha256=mZb4YTt4QH5ZgOdfKTAruj3yq4RwNUI4vDMBmDizdNE,1426 +torch/include/ATen/ops/max_cpu_dispatch.h,sha256=-8j1oSNDI9PSKEJtpILgrQNqadVeBa0MKmsdWTYdehc,1292 +torch/include/ATen/ops/max_cuda_dispatch.h,sha256=NT0jfu-2O7T2whYD6ZjkJdDH9Xsrr2S6sHs32eI1FjU,1294 +torch/include/ATen/ops/max_meta.h,sha256=1zAiuMoppJFe_DSTuYQTN5jjSGoRrfn05YblIfNFbwM,1088 +torch/include/ATen/ops/max_meta_dispatch.h,sha256=3i8JSPJptX5dfA782p5dM_m43XoPtp7qKI7cyPxlrq8,1092 +torch/include/ATen/ops/max_native.h,sha256=0WSKmEb_O4pofgVjWqDCDIZwVPk3YvAuSbplFK_ikTk,1507 +torch/include/ATen/ops/max_ops.h,sha256=R_eePJPATC2z_BZVwW0AuvsH1eiCL-2BJRP5hFcTDUs,6293 +torch/include/ATen/ops/max_pool1d.h,sha256=5V64npPVE-LQ7n-amRf0d5tJaOgx04cpMOd7oAjM4zI,922 +torch/include/ATen/ops/max_pool1d_compositeimplicitautograd_dispatch.h,sha256=DF8sZvX435wLllAp6uvpUTgms25HffE1cgKSdBKBqyI,901 +torch/include/ATen/ops/max_pool1d_native.h,sha256=K9SYP17EbLP2H-YJhAQy0CCUIfrroEPAy3TvU45RqjA,624 +torch/include/ATen/ops/max_pool1d_ops.h,sha256=IaVQuU1IJoH79YHPQSh61HMXNZh2p2uIkfun9wNnsjs,1390 +torch/include/ATen/ops/max_pool1d_with_indices.h,sha256=jkIGa1zT2SVrE6kP9Yod4BjSoPoqfcBW5Qhd48-zslw,1009 +torch/include/ATen/ops/max_pool1d_with_indices_compositeimplicitautograd_dispatch.h,sha256=C5kjki9wDdSlniaafgHM70uAptXDB_N20LU7ujYF9cw,939 +torch/include/ATen/ops/max_pool1d_with_indices_native.h,sha256=wCHHr9NgcOarsVWxTpJTeuAr3-Y-7CQ_SJ52z7RyceU,662 +torch/include/ATen/ops/max_pool1d_with_indices_ops.h,sha256=l9lpdn_WGW7-QbnyCBNjgMgks9I3jY3n6-Cem8GI7Gw,1514 +torch/include/ATen/ops/max_pool2d.h,sha256=1UR7drXElbeGyRXkvFnzC5cDBi6s3yhnCjiHaugHMmM,922 +torch/include/ATen/ops/max_pool2d_backward.h,sha256=z9Qu79WSHLWN6UxomaqJ8Sv_Mr-RIKUivY54bxlHrKo,2170 +torch/include/ATen/ops/max_pool2d_backward_compositeexplicitautograd_dispatch.h,sha256=gQ7VUKhB527wOR2LVRrxQM5Y5FcwZ3J2TUYAlEZp1Uk,1210 +torch/include/ATen/ops/max_pool2d_backward_native.h,sha256=aKz3H4YmnmDCSk1TRoaNP8eT3zoq1dIxwRyaBHbZUyg,676 +torch/include/ATen/ops/max_pool2d_backward_ops.h,sha256=hRuw2V8glUrERNgIpPruhr7-lTtN38FsSF-1j-skkYA,2698 +torch/include/ATen/ops/max_pool2d_compositeimplicitautograd_dispatch.h,sha256=9Gok7VNwNIHmV2NfC7fxifz_nFTTucD4vMQUNfmQhvM,901 +torch/include/ATen/ops/max_pool2d_native.h,sha256=q1axMLXfKeSHGSSVH7CCKdWFftCisnz9XT9_hN2kOu8,624 +torch/include/ATen/ops/max_pool2d_ops.h,sha256=TJL_UqQ1qY-3PAbqKF7O9O-340YvTUyH1hIydqpGGLA,1390 +torch/include/ATen/ops/max_pool2d_with_indices.h,sha256=71R_3rDTuXpTDzo5YPmJMxPMBbwEqxaPgxh8oBgtrcI,2234 +torch/include/ATen/ops/max_pool2d_with_indices_backward.h,sha256=UBscMPb3ZptVYuPCo3Yjnf4SEIyiLc1nxVy9akCofbY,2464 +torch/include/ATen/ops/max_pool2d_with_indices_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nGoahet0rfcevcKyuG56TOJh6cIRgbh8noXxmSrw-Ek,996 +torch/include/ATen/ops/max_pool2d_with_indices_backward_cpu_dispatch.h,sha256=lUEzB6hWsVCiLjqc2ll4C9r2p1XouZeYqe3v7tMIS48,1509 +torch/include/ATen/ops/max_pool2d_with_indices_backward_cuda_dispatch.h,sha256=HJxfFJ6ALfEI2gXa0su2rFCB8IXMNqi54YGvoAmX94c,1511 +torch/include/ATen/ops/max_pool2d_with_indices_backward_meta.h,sha256=Dp0sI-dD9gYTuTkJsSyHhvREbT7abi99KfCB9_wKhQ8,792 +torch/include/ATen/ops/max_pool2d_with_indices_backward_meta_dispatch.h,sha256=u7b6dIwWfdxARQwo_3GP-bJxQgDH_MEQWdpsYt-6bu8,1511 +torch/include/ATen/ops/max_pool2d_with_indices_backward_native.h,sha256=Q4U4dMPNSJ9eyFaKuhg55Ymo1gQGl25U6mKPAkAVq0w,1261 +torch/include/ATen/ops/max_pool2d_with_indices_backward_ops.h,sha256=eGx6YAGwHAlEjZFRIzOVOTuGtkI3mxjRqMQKVROrfRM,2976 +torch/include/ATen/ops/max_pool2d_with_indices_compositeexplicitautogradnonfunctional_dispatch.h,sha256=T5MFgLSN2CrBL-ec8cVQC8n0L0qV6_6lIL8JHVbLw2w,965 +torch/include/ATen/ops/max_pool2d_with_indices_cpu_dispatch.h,sha256=Ya8HebugKpVAxZwvxzenIVbhwld-JK6gpP5SszUp3ZI,1437 +torch/include/ATen/ops/max_pool2d_with_indices_cuda_dispatch.h,sha256=g86F4IdJFFVnwVQeWiIqaTyjZ8GY4AeMEtII0CHrSHM,1439 +torch/include/ATen/ops/max_pool2d_with_indices_meta.h,sha256=B9xRpKvNdLLblw-C5CIjdRZtul16DaDbunEbHGv5hFI,723 +torch/include/ATen/ops/max_pool2d_with_indices_meta_dispatch.h,sha256=HUVhgX_v6sL4iuzPQXLee1LS1dUNlJR2ji6ZRWv6xrk,1439 +torch/include/ATen/ops/max_pool2d_with_indices_native.h,sha256=vLMlmtNjZHOkk-thDSpxr-LMzqYbHsFjKZIuCqcejuI,1138 +torch/include/ATen/ops/max_pool2d_with_indices_ops.h,sha256=ekOCHSnFYYomUdjFGsWjCNSPp9-r6ARbWRbazrkIm5k,2772 +torch/include/ATen/ops/max_pool3d.h,sha256=qMN8U_DnosTErLdkrMQVSmskLSeJ07yLWkZwL3kxUfg,922 +torch/include/ATen/ops/max_pool3d_compositeimplicitautograd_dispatch.h,sha256=-59HnY2XbtqxV1pnx0diBuSVITVyeCxnyC7aXE4EdbY,901 +torch/include/ATen/ops/max_pool3d_native.h,sha256=M8IVUvDK6Oa1iLyUL7rKRSUHnwVwxlQc-6YTBFj-4z4,624 +torch/include/ATen/ops/max_pool3d_ops.h,sha256=7POoAsMi3CxO7SBq2_HyYPOlUjTcWaXquonyVeQZWZA,1390 +torch/include/ATen/ops/max_pool3d_with_indices.h,sha256=IHsezZi8dB34FOGpRk4ZIcCvvYq75V6OFFJZ7AW0OLc,2234 +torch/include/ATen/ops/max_pool3d_with_indices_backward.h,sha256=fRQRuKFyZtLAKQymanxFdTNiwf7Gp_0StTHeq3xx-bw,2464 +torch/include/ATen/ops/max_pool3d_with_indices_backward_cpu_dispatch.h,sha256=g9T7v0y6tUwzCVFeSiL0L_Ywsst0ZrfoUUsI2VGvySs,1509 +torch/include/ATen/ops/max_pool3d_with_indices_backward_cuda_dispatch.h,sha256=1UkC4-ToPZ3ZYtuEBAHRlALZ8H2s5SyqGCBXiGOUhzE,1511 +torch/include/ATen/ops/max_pool3d_with_indices_backward_native.h,sha256=jvefMOHGWRSd-q5wYrX-ayMcNsKa40WKkhSrQplwz6M,1553 +torch/include/ATen/ops/max_pool3d_with_indices_backward_ops.h,sha256=Q1JrCcH49teFT6dnxRo0fQvDI9SV44BHCk9tjJc3Lp0,2976 +torch/include/ATen/ops/max_pool3d_with_indices_cpu_dispatch.h,sha256=__GTLWy5DSpJjFbjGsNAPx-mnand2rtIgx15Wtkhb3U,1437 +torch/include/ATen/ops/max_pool3d_with_indices_cuda_dispatch.h,sha256=OJxVUg2NawWQ4mCgbx1rIbonSR8zDFxGhUjMNLj-Mz4,1439 +torch/include/ATen/ops/max_pool3d_with_indices_native.h,sha256=3dVB2iJDD3DFIDSBMbOLgTpVHi6yrwWWWzmeqRsa4Js,1437 +torch/include/ATen/ops/max_pool3d_with_indices_ops.h,sha256=_DhxaSBbJFcioUiE1cvVTzIcAWY5TAzt_ozxLSTktDg,2772 +torch/include/ATen/ops/max_unpool2d.h,sha256=fJDWWBRxicpQ0DvsfozF5I4MO9Vf1bBqX1Rx2ZVNL0Y,4451 +torch/include/ATen/ops/max_unpool2d_cpu_dispatch.h,sha256=Y5vJM3pG_qThEErm0kGhNUrm8P-Ge6qzeUmcQBSqBPU,1499 +torch/include/ATen/ops/max_unpool2d_cuda_dispatch.h,sha256=6LLpeLQzJQAJZJ5s5AavwziNRro5QpO9tfD6x1vsTfI,1501 +torch/include/ATen/ops/max_unpool2d_native.h,sha256=XSqRSX9E5-dP8r4e3eF00aYaSFtOfjAD3HyLueRiZbs,1011 +torch/include/ATen/ops/max_unpool2d_ops.h,sha256=nPR0-D7Re1VsYXg7C8vAjTNabMxMMFGx8tYnk4qlp7w,2030 +torch/include/ATen/ops/max_unpool3d.h,sha256=itV8m6SBD9riJUuaFIB134KUJAa-AKSIYe2-RzpHjTM,5429 +torch/include/ATen/ops/max_unpool3d_cpu_dispatch.h,sha256=11aqKZqsA1BaSqbM3qVgxe9XcL_9vRKaBut5vDSe3BU,1793 +torch/include/ATen/ops/max_unpool3d_cuda_dispatch.h,sha256=2uB5CE8MsqGfIDFNyJJqZbiNF0TCahD8LRMihrfp0ss,1795 +torch/include/ATen/ops/max_unpool3d_native.h,sha256=LderDFqMLZrTHdJ3kfT3oR3d5XNq3lDhZwyijMVDQkQ,1207 +torch/include/ATen/ops/max_unpool3d_ops.h,sha256=NoGj2d00USQl2MmgubCN_gqh-EolJlFVwpJ1mWSeglU,2356 +torch/include/ATen/ops/maximum.h,sha256=7Ke_xLoCo3pQjkjMCyVwgSoRfdvA8V0KdKz1ZdL7F-k,1166 +torch/include/ATen/ops/maximum_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KKg9KPUCB80Lh0emHI4KNMDobeFWnyINTReOsZvw2xA,817 +torch/include/ATen/ops/maximum_cpu_dispatch.h,sha256=pghd81gWcT09b45l264XaXdvV3mSfUF84JYwWnaAHxg,958 +torch/include/ATen/ops/maximum_cuda_dispatch.h,sha256=pCVRIvSNume8t8k3N5X5A5M0xNpES1rttjbHt2oRRhE,960 +torch/include/ATen/ops/maximum_meta.h,sha256=K6mQS2kuy6YnrEIGCPz3DvtpPzp9Xl7gp38AjomiiaQ,613 +torch/include/ATen/ops/maximum_meta_dispatch.h,sha256=TgoZmCVzVoAgMXUROk3C0u_VY05zZEaKtscRbBKdfuU,960 +torch/include/ATen/ops/maximum_native.h,sha256=D9y5v143VDYBpw82MCqiX0xOPPOcwK4hP3oX1QP8_ro,636 +torch/include/ATen/ops/maximum_ops.h,sha256=x4MX1aRx-EfJg2MnxTS3rHfxAKSIhaaGSCpHJneHjVY,1768 +torch/include/ATen/ops/mean.h,sha256=QmnfjSRe-OHn-y60HTf9M8fXs2ITUeOd0lXusbxB8fU,2782 +torch/include/ATen/ops/mean_compositeexplicitautograd_dispatch.h,sha256=lBJcEkcrmonsFXEHajwaSLH6sej6rQHgUMakyz-9FLY,812 +torch/include/ATen/ops/mean_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Sas93z-t2-Kjxpo2-E4GFS0JCNw6Th5rtmtZDYLfIa0,887 +torch/include/ATen/ops/mean_compositeimplicitautograd_dispatch.h,sha256=7dYq1GoCQG72KhZTvPF1AEiBSYNLEDg-tMdOrQqMzgE,1169 +torch/include/ATen/ops/mean_cpu_dispatch.h,sha256=XnArgxA-jCGMpfQt8rPIe1tl58UcocE79jfnijiyk0g,1149 +torch/include/ATen/ops/mean_cuda_dispatch.h,sha256=6DtFyeRGQlTmdHis5SDecrnZyAsoPySDGbkyWis2c84,1151 +torch/include/ATen/ops/mean_meta.h,sha256=m-LeqcXbrCId0w4ccWf6Cpiy8Do31SuNr1KIJ6_-tR0,668 +torch/include/ATen/ops/mean_meta_dispatch.h,sha256=OUoO31Hs4DFrwh2cr25Doi6GH4prJRAEtGGKu9G4We0,1151 +torch/include/ATen/ops/mean_native.h,sha256=-u46EFPEf3_s3hizN38y5QLp9Cqd5m5KBWca3t19B5U,1413 +torch/include/ATen/ops/mean_ops.h,sha256=5TRHIyG_LSRZ6DSCNB2sG5seIVL5eKz2yLqYPf5H82E,4519 +torch/include/ATen/ops/median.h,sha256=nugEt1bEcMDcpxL0HXy2othf7nR_rlfRtdnSllu1vmQ,3205 +torch/include/ATen/ops/median_compositeexplicitautograd_dispatch.h,sha256=NI0DRVMls9CQcIbk7ZQ9aIyTQBGyH1tB2oeC1ziWrpM,979 +torch/include/ATen/ops/median_compositeimplicitautograd_dispatch.h,sha256=kbnqBK7nzMdcrHhSDEYuNSbPJYiFqjAP747i5KtJ6yo,1155 +torch/include/ATen/ops/median_cpu_dispatch.h,sha256=L9rNNPcB-6eB5fPltEpOErlmdMbh2-K3aAKRlL5ntY4,1041 +torch/include/ATen/ops/median_cuda_dispatch.h,sha256=0U0DKCxKT3UjzwPSci0N0NA4TsV1FanDeUgidYpIeX8,1043 +torch/include/ATen/ops/median_native.h,sha256=65xEUKVsZD_TcSPAEROnv72CJb-ZIbEesEm2utUgZrI,1340 +torch/include/ATen/ops/median_ops.h,sha256=zBT7BqRAchc9Ww6N8G10SsmNAa1SukDWepOo3U62-Ok,5020 +torch/include/ATen/ops/meshgrid.h,sha256=utZtMssSucK2UA6ol1ojoKLqJSU-L0SuCFgGSj5ab88,894 +torch/include/ATen/ops/meshgrid_compositeimplicitautograd_dispatch.h,sha256=ZZdjr_0aAYZNtcE6hrK2wFBtY36i7QDkC9xzT4EwUOs,877 +torch/include/ATen/ops/meshgrid_native.h,sha256=Jw_MQuag9MN_Yi6SksDi443CtuPuBPZWtivWh55vda0,600 +torch/include/ATen/ops/meshgrid_ops.h,sha256=qYCmBNIlUabpgJl9MHEfsKdYkQ9fw47ZMUidJFDpOYs,1719 +torch/include/ATen/ops/min.h,sha256=eqa2ya_OtnKmZP0y9XGhLdwwX348SH7FM3ut59Ef_xQ,3784 +torch/include/ATen/ops/min_compositeexplicitautogradnonfunctional_dispatch.h,sha256=yZeiTF6DsejCuRMy90M7JEKF6ALrLVcp2Y1ChwFQyeQ,845 +torch/include/ATen/ops/min_compositeimplicitautograd_dispatch.h,sha256=MidFFlx8c5xpQi5Q7NNr9uG5kRFdwZNIxt7Ih6ukiBc,1428 +torch/include/ATen/ops/min_cpu_dispatch.h,sha256=bwBX5JE-M14njzn3lPfKH0JkPMeeGTKK-KRg-dyMA_o,1294 +torch/include/ATen/ops/min_cuda_dispatch.h,sha256=WquZLCzonaMeDRYUoJcgPkBio_4OTVxYA8tvYyCotV4,1296 +torch/include/ATen/ops/min_meta.h,sha256=A5VVmQvyVD6DPpfMSqCcLEP5Q0KwcEwM_84ibx1KFpk,1088 +torch/include/ATen/ops/min_meta_dispatch.h,sha256=0HbzU5-UhAgkLA2z8SoxdY9Uqfn9hHPCuMTAkPb40Js,1094 +torch/include/ATen/ops/min_native.h,sha256=pMwXMdtfJ3O7DynS8qEGDBWWyWHWbBjgtmkrGvAZh14,1509 +torch/include/ATen/ops/min_ops.h,sha256=mUO06dj96YHhGsZ8iDSw1JEnC6VY3Eqk6kAio8_XdTg,6299 +torch/include/ATen/ops/minimum.h,sha256=_hFyULaGH6RmJn6bFBbRvH7KmfmRpxPHWdBXsZdH6OQ,1166 +torch/include/ATen/ops/minimum_compositeexplicitautogradnonfunctional_dispatch.h,sha256=YViqkkU8aBEPsqtU_CIBn-IDUAhDTq46ZjK-zYOUfaU,817 +torch/include/ATen/ops/minimum_cpu_dispatch.h,sha256=YzBtN9UsGh6bYXNsxasIRHfnXj_vLVVGNEktglm5IG8,958 +torch/include/ATen/ops/minimum_cuda_dispatch.h,sha256=wA2E_-db0grMPAZSH-jE9xFzvjMZmIwqYgOTqNZFtYY,960 +torch/include/ATen/ops/minimum_meta.h,sha256=x3COf4GRN8MDOGAmLNrSTjWTpqnIQgNkpquNqGVPpDY,613 +torch/include/ATen/ops/minimum_meta_dispatch.h,sha256=ON8t_0TuLWdomudwTRnfRJlsj8fmkQE_Cw93feLpaVc,960 +torch/include/ATen/ops/minimum_native.h,sha256=z6hW33YzQSuOFcldm3Y8sq0Anpj6GLxjaf-GGGkRCiw,636 +torch/include/ATen/ops/minimum_ops.h,sha256=lD8cLnHL4tWVKLBZeYvpQObDM5CKT4oEzrJkRH8fe3M,1768 +torch/include/ATen/ops/miopen_batch_norm.h,sha256=TMdXs8Ym2wZToEmDFoizm3XYCmhJ0W3duKrYIxpZTt8,2850 +torch/include/ATen/ops/miopen_batch_norm_backward.h,sha256=gE9y9nkFgLLUb9_IaTt58T9sjkGrf3KA5fjUIdHpQvU,2985 +torch/include/ATen/ops/miopen_batch_norm_backward_compositeexplicitautograd_dispatch.h,sha256=XNeYIIoyQRgbu0GG0VPw9zi-RqFKq2AXnSqw1sL-S1Y,1585 +torch/include/ATen/ops/miopen_batch_norm_backward_cuda_dispatch.h,sha256=jU9lWzx6uDfk4CsNKZQ8ZwB5LKJEDRh1FIqszHcUn-E,1038 +torch/include/ATen/ops/miopen_batch_norm_backward_native.h,sha256=8DGdazU7NM4Y7p3yHuNDlHlZXuG8YUF6HI-bEeuBzEg,1240 +torch/include/ATen/ops/miopen_batch_norm_backward_ops.h,sha256=vmOzfwjwtg_4RNaxQMWH9D3N1vEaq4FTKqe6jAq9hlc,3801 +torch/include/ATen/ops/miopen_batch_norm_compositeexplicitautograd_dispatch.h,sha256=zJHvaQhTUZWJ9IcGohWe93nfDzHpN-FhLh9I1Zj6P20,1505 +torch/include/ATen/ops/miopen_batch_norm_cuda_dispatch.h,sha256=vVSZKaPu5jyYb2VK5dRvjYYApfNHvh9027Omtccu6IU,998 +torch/include/ATen/ops/miopen_batch_norm_native.h,sha256=AUuKLBFUEB1a0Zhg94guORDrBt3aC_Cmy7e1xM83_6A,1160 +torch/include/ATen/ops/miopen_batch_norm_ops.h,sha256=WrMnohqAv8talz71pr0NQaagJr2aSR5OqAIvEn7tryY,3553 +torch/include/ATen/ops/miopen_convolution.h,sha256=Ws7EUk1Q1urODjJWxfpSTyGOjijKPHqVHAQp6PK0LIU,7871 +torch/include/ATen/ops/miopen_convolution_add_relu.h,sha256=uYJDPAWTbdcJTydVcFoUo1K7ZMUaVPfI0e9Sh8pH5lQ,2954 +torch/include/ATen/ops/miopen_convolution_add_relu_cuda_dispatch.h,sha256=I2ReyeIqKFU-Y2lDdJneICPYjVNqVtj87IZ7wNSUIdM,1283 +torch/include/ATen/ops/miopen_convolution_add_relu_native.h,sha256=km5QXGv4HC-wucs-VhU8ECqBWRvUmibOKNhJGtK6aLc,729 +torch/include/ATen/ops/miopen_convolution_add_relu_ops.h,sha256=mLGBgCBGJLpHxkQlhmsVQL-JfZ-kPcSHHkjtdImK-Es,1813 +torch/include/ATen/ops/miopen_convolution_compositeexplicitautograd_dispatch.h,sha256=JOVX-f9FEDycE4k4GDcF-wELjWlhWOOrVKdyXqJ17ZM,1894 +torch/include/ATen/ops/miopen_convolution_cuda_dispatch.h,sha256=zqIx4mA02ScLiEgQRB8nZlfrGGABD54pjLHDR_hdst8,1211 +torch/include/ATen/ops/miopen_convolution_native.h,sha256=Kp-Qrx9dSeVNA4G4-Kl1mvQKZ0OLR1nZhXmsSAqBa6I,1000 +torch/include/ATen/ops/miopen_convolution_ops.h,sha256=PqxSKCwccgXZDt-h_1r77DVcuNR_Qur77h6OPrAQSWs,3056 +torch/include/ATen/ops/miopen_convolution_relu.h,sha256=f6yH3wL9HJFUXXib6rAxqN8eI8ibLcDL49ouQgw_wXg,2568 +torch/include/ATen/ops/miopen_convolution_relu_cuda_dispatch.h,sha256=dSrYgn3bVnjmgRTMox94MKWIG5Gur43ORxE_K-Ud-EA,1149 +torch/include/ATen/ops/miopen_convolution_relu_native.h,sha256=I9bLoP52mZ05mC1YfvWjArN_evxFwEWcqolzzZHzyg8,662 +torch/include/ATen/ops/miopen_convolution_relu_ops.h,sha256=WjRK2aGE445CJNphonZbcS6rc08OjUG7a1v-NS3UCts,1595 +torch/include/ATen/ops/miopen_convolution_transpose.h,sha256=USOZZ20UTpHSrhL008w6OvbaAiuIncKlCxOOCRMqd4Q,9087 +torch/include/ATen/ops/miopen_convolution_transpose_compositeexplicitautograd_dispatch.h,sha256=zcbc5eDxy4EdhuZ6uYIHSU2ogWwFhk7XfyrlQHyAldc,2070 +torch/include/ATen/ops/miopen_convolution_transpose_cuda_dispatch.h,sha256=ypdQsUiHwLAKFwDrM84ROKt69FEFO4hUzJaJ4ygVWys,1299 +torch/include/ATen/ops/miopen_convolution_transpose_native.h,sha256=QULYupL81oCOEBAGUuo_GzBpt3RriJDVvKOCB7lsZys,1088 +torch/include/ATen/ops/miopen_convolution_transpose_ops.h,sha256=wAd_5eYCVJhbBm8aFgCrmi9e5iiv-j_YhFX2RSy1CTQ,3352 +torch/include/ATen/ops/miopen_depthwise_convolution.h,sha256=2QuESPHfOt9WUJShDAL7MgAlgw0F5XQsfdfc1gY2MDM,8181 +torch/include/ATen/ops/miopen_depthwise_convolution_compositeexplicitautograd_dispatch.h,sha256=j7IS6iMTgqYbabcc67_MvmPedCHdWvCqgHgvPpD1hc8,1934 +torch/include/ATen/ops/miopen_depthwise_convolution_cuda_dispatch.h,sha256=veucVIcgIFC2lxJaOrAB2hpS_9vzHqIA_EqZSEUp5oE,1231 +torch/include/ATen/ops/miopen_depthwise_convolution_native.h,sha256=FTieA_SBN2sWgKB4Dly33orWX982op6GuGA8EfagWQ4,1020 +torch/include/ATen/ops/miopen_depthwise_convolution_ops.h,sha256=4ZAOaNU2m2cXz_Veh1-DtVLRB4_7vlJOibKf8w3_RJQ,3116 +torch/include/ATen/ops/miopen_rnn.h,sha256=50y47SuuXpC_tlJDwfavwcCHkDKDAh0j7xlZBcWiDtE,3686 +torch/include/ATen/ops/miopen_rnn_backward.h,sha256=2cl4qGRaVDR5dFAQR_0dK2p_dBD3IosK1E64k5yqWWg,4790 +torch/include/ATen/ops/miopen_rnn_backward_compositeexplicitautograd_dispatch.h,sha256=ea4BA7pMGMhgigTeo1V7iVzMM6r--9U_-w03SMJNt0M,2119 +torch/include/ATen/ops/miopen_rnn_backward_cuda_dispatch.h,sha256=vDTxavz4mjb8DPevZTN0Z3qevNtlwlw2OuuLY9c6_cg,1358 +torch/include/ATen/ops/miopen_rnn_backward_native.h,sha256=8sIgyqunsHB7LY9eJXrS9eLgz2x1YyqGEbGXu82oxE8,1827 +torch/include/ATen/ops/miopen_rnn_backward_ops.h,sha256=qd_1PMCXA5t7Wz7JT4Qgppxx7nGcDQ_g9K9RdMNtSdE,5730 +torch/include/ATen/ops/miopen_rnn_compositeexplicitautograd_dispatch.h,sha256=PvC9AgeDS4CTrwPUt9G2fUebELVxoyInMJb_aQASUyA,1777 +torch/include/ATen/ops/miopen_rnn_cuda_dispatch.h,sha256=rN0F6uixrAHwH05f4u-7n0OHqQQmDAfy-xRPc2rGlzs,1092 +torch/include/ATen/ops/miopen_rnn_native.h,sha256=MMmiKvuAyGWsNjFfKFpJDaQZdFAJxK_6qB0muS14ygo,1390 +torch/include/ATen/ops/miopen_rnn_ops.h,sha256=zBKZ4d4Ufn0DgBWCIBjSQAhSj3njqqU3tzu4_SKafj0,4373 +torch/include/ATen/ops/mish.h,sha256=pJ2rlCbKVVF8KcYESqjjgduvYLoMq4EXxcIjIt1RMYs,1131 +torch/include/ATen/ops/mish_backward.h,sha256=GOejsGHxrNTmZBbow1LEDXZWsJkUgdk_6-JVxyRl4iE,718 +torch/include/ATen/ops/mish_backward_compositeimplicitautograd_dispatch.h,sha256=sjaTqkPtn8DYRK9BKg9UdQ-Pu9GTC0NgTu0uVNeGBnA,803 +torch/include/ATen/ops/mish_backward_cpu_dispatch.h,sha256=bVODwoS__2M4DEA_Z5QYO7Jdt2SVPfeb3Xfcv1eA5Mc,759 +torch/include/ATen/ops/mish_backward_cuda_dispatch.h,sha256=Uo5MdmBtQwvTo5hwt7vR75_8sb45kGSDq1zwlu8Bchg,761 +torch/include/ATen/ops/mish_backward_native.h,sha256=rKv2-vjjj15ugGt7Dog6WiglUi5yxxYXITfZKPgWrn8,624 +torch/include/ATen/ops/mish_backward_ops.h,sha256=CiaJGTnakc88W9OcdMhQt1CSCPmzcq7_Q3yn_vUDy9A,1092 +torch/include/ATen/ops/mish_compositeexplicitautogradnonfunctional_dispatch.h,sha256=-ibYHDLqaY7uQmXRTpdWzBAAxQrERiQrEcAjj9nF2RQ,837 +torch/include/ATen/ops/mish_cpu_dispatch.h,sha256=7BfOMpIf3X27mStmRGBSwHo2RA2XvgeaDWlXbq9pM18,920 +torch/include/ATen/ops/mish_cuda_dispatch.h,sha256=69PawBuyzCIlcHgrkYXJ8MJy9u2tX34s-2t4L2GrKqg,922 +torch/include/ATen/ops/mish_meta.h,sha256=MSZwIP6rYZETuqK4ce-1DdJn-0utVO0WDfAhvX9gAKA,584 +torch/include/ATen/ops/mish_meta_dispatch.h,sha256=rRObNDUNIDNKE-iNn6tbPuUQfKlnY6AzeawySBqpyM0,922 +torch/include/ATen/ops/mish_native.h,sha256=ekPdX1wp6YLUhDbl4VB8g3-gV_0KNS9njx-bcvcNq2Y,601 +torch/include/ATen/ops/mish_ops.h,sha256=SJxR-qNzaH9nyJcPk91k4BoEwm1hZvHvpfUR636guUg,2104 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d.h,sha256=mu624J2wxzSKEtWwNHlV2_987wAI8zJZCH3JugNOWjk,1401 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_backward.h,sha256=1-XULF-QU4PvMNPZtpkL6CZIm_3TV5OBbd18ok6n1fo,1500 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_backward_compositeexplicitautograd_dispatch.h,sha256=5IQtgzY_LduH3bknIOPNrIMWisl0hzHNYMmEqbl0Ez8,989 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_backward_native.h,sha256=NwNzCfBHCR_N7DSwO1cxEUuJ1FFLf1-HWShPW42eJTM,687 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_backward_ops.h,sha256=BbTbGgk3Cnjx6Ag1Cj2ei9qYrQjB-Gc4cELpv598afA,1972 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_native.h,sha256=mN-A78rhPo7kGmXcasDF0Xnrzu4gZuYEpr7cDVqpLHY,663 +torch/include/ATen/ops/mkldnn_adaptive_avg_pool2d_ops.h,sha256=LhPVQSJ_EE5Fq4T0I5uMdArBLw6z3XvUaWo4ECYN-Ss,1900 +torch/include/ATen/ops/mkldnn_convolution.h,sha256=UzUngl8n-pKFHWU5AGqmmgpWnGrH5SDQkM6reChEsVI,6911 +torch/include/ATen/ops/mkldnn_convolution_compositeexplicitautograd_dispatch.h,sha256=NECZKW6CmsvsiTR6OCnafLRY8uaOcqWz9Ok0--_f6wg,2221 +torch/include/ATen/ops/mkldnn_convolution_native.h,sha256=QKDbZI3Ftuu_YfWTX8eCib7jSBphGSCfCOj996GkwOc,928 +torch/include/ATen/ops/mkldnn_convolution_ops.h,sha256=o6uNoj_LuB1U1FjA36BD601GWKXX5myG8EXqJ9czbtY,2816 +torch/include/ATen/ops/mkldnn_linear.h,sha256=YDcNXIokkdpDMhGHA67o2ZddYwfWX3zuE4tCrkBNTEQ,1436 +torch/include/ATen/ops/mkldnn_linear_backward.h,sha256=xKg-xgltJ82VXxx0lK2H7sYSds4GU5VFr0WuSzxgl3Y,2084 +torch/include/ATen/ops/mkldnn_linear_backward_compositeexplicitautograd_dispatch.h,sha256=HshatuKdCbXJUkH0Damx9mGbmpzm8aYW3k3CoUYFlfM,1243 +torch/include/ATen/ops/mkldnn_linear_backward_input.h,sha256=imFKDSUiYxg3pYNoZxeOfzIqdCpddYqfJTqUAl5aTRA,1622 +torch/include/ATen/ops/mkldnn_linear_backward_input_compositeexplicitautograd_dispatch.h,sha256=ainUrq6BsTfIX39oQ8UGaPZlfWaK48biV7tPwkaShrU,1035 +torch/include/ATen/ops/mkldnn_linear_backward_input_native.h,sha256=AtUXqZGx4PpbwnOw-qVF_WcbxDAI1Xk-6d9cld20XZU,733 +torch/include/ATen/ops/mkldnn_linear_backward_input_ops.h,sha256=3ifjr6daMbmx8EY3bP5H1mt8Hqbi_lRYSRveAogT9VQ,2124 +torch/include/ATen/ops/mkldnn_linear_backward_native.h,sha256=flSGfpgRinw5iJnt5iVAOu1VsUjS-9a3nAWzPRty0VU,898 +torch/include/ATen/ops/mkldnn_linear_backward_ops.h,sha256=4Ld0BUmPNHbhaq2xV6UjrNHLHs1hcWFR4Tct49nT390,2707 +torch/include/ATen/ops/mkldnn_linear_backward_weights.h,sha256=uu42o9QHi_cuRty544UTYVlFunnVF66HQH5V9KWD2ng,1972 +torch/include/ATen/ops/mkldnn_linear_backward_weights_compositeexplicitautograd_dispatch.h,sha256=QM2v61b9EY6_DmLygIrYv-_Z1TA3vtUND8tGSSPNX7g,1167 +torch/include/ATen/ops/mkldnn_linear_backward_weights_native.h,sha256=Rq8cX1D3pDeil5k7zU5ODvKVzGGSIEnPBuYkGFeHtM0,843 +torch/include/ATen/ops/mkldnn_linear_backward_weights_ops.h,sha256=c8pLIlW5bY3erY2oJGyDHKGQca6bzIAlnc2i_aem_Ms,2504 +torch/include/ATen/ops/mkldnn_linear_compositeexplicitautograd_dispatch.h,sha256=nOY1pHiLOA0RitW6-6sto83MmkgLLwNear4el_OQyO0,1018 +torch/include/ATen/ops/mkldnn_linear_native.h,sha256=HBiGpmBFWpBOVXWkDogJ7odhSiFaO-T23Tjz-Iso0SA,716 +torch/include/ATen/ops/mkldnn_linear_ops.h,sha256=XPZdaaLRL61pPxKpXpxLg_NB2S_vThQNRsJLNmOK8j4,2078 +torch/include/ATen/ops/mkldnn_max_pool2d.h,sha256=Y3o1tIJQ4cROR7Hr7nP9Uyp0aCkOvgSQd9AkYHD2rw0,1955 +torch/include/ATen/ops/mkldnn_max_pool2d_backward.h,sha256=QRdYJmSeYTzxhsFHDkZZJzGjklwwl-LmdYhXPph5aRQ,2399 +torch/include/ATen/ops/mkldnn_max_pool2d_backward_compositeexplicitautograd_dispatch.h,sha256=W-GHd_uDPgGgJb61UDO_Nuqhz3Lb7r6bZW3FB1nin5k,1280 +torch/include/ATen/ops/mkldnn_max_pool2d_backward_native.h,sha256=yIpwHUmFOj5M9AOjm_m8RRH51v5MaXjEs4cfMieBEVc,978 +torch/include/ATen/ops/mkldnn_max_pool2d_backward_ops.h,sha256=ftIlILpJzN8Fiy0iY7LcB_Zqt8zsujm8vaAaviKpyB4,2924 +torch/include/ATen/ops/mkldnn_max_pool2d_compositeexplicitautograd_dispatch.h,sha256=x-gDfK5YQ3KscofGu6LGMvKk14n3qVtujJBva6zMxtA,1142 +torch/include/ATen/ops/mkldnn_max_pool2d_native.h,sha256=69s_rIcXYc5A5xZlHTJdg9IxmB-xL3MGb10BVz1CMOA,840 +torch/include/ATen/ops/mkldnn_max_pool2d_ops.h,sha256=X1Lwu3roEeGxWERJkzZ-0QiIxW0CCaEIv0qdx1nkqcU,2478 +torch/include/ATen/ops/mkldnn_max_pool3d.h,sha256=lsQi8ygfFJsz9ob2A8KJf8rpcNjkK47qWp_60nMYNkE,1955 +torch/include/ATen/ops/mkldnn_max_pool3d_backward.h,sha256=gEEHsg68L9ZPCU8ifrnxz6EDPORP9miaMW9uNYLYRpI,2399 +torch/include/ATen/ops/mkldnn_max_pool3d_backward_compositeexplicitautograd_dispatch.h,sha256=NOEZKZcef2UHL6jClsc_pGcwyO2riRVc85F2CRRvwmM,1280 +torch/include/ATen/ops/mkldnn_max_pool3d_backward_native.h,sha256=h5xlPnYh0LHpGCwJrAavkg72cE4JJJILx8CStg8thqk,978 +torch/include/ATen/ops/mkldnn_max_pool3d_backward_ops.h,sha256=-lDEFPmslwX3RswE3c6kGkIbvzYac0fLY-ywsH9Jkn0,2924 +torch/include/ATen/ops/mkldnn_max_pool3d_compositeexplicitautograd_dispatch.h,sha256=vIDea-OnUwC_IdUQMpnlBLJn-rILWfhT3pD8ObMkaQw,1142 +torch/include/ATen/ops/mkldnn_max_pool3d_native.h,sha256=IKEmEQ9J9zA0jeAdHq_ZwVhRGqUs-lwjCQCJHGDeH5I,840 +torch/include/ATen/ops/mkldnn_max_pool3d_ops.h,sha256=LojQwe1_TkuAaBMLYhD9aPYYl9n6-i8UAVrLKHmhjTo,2478 +torch/include/ATen/ops/mkldnn_reorder_conv2d_weight.h,sha256=UpWHAGwKXDjkoQPPJgHF43oA865QjV4_OCx4o4X1UCk,7743 +torch/include/ATen/ops/mkldnn_reorder_conv2d_weight_compositeexplicitautograd_dispatch.h,sha256=by5HQWMDcVFj76i15b54uUG6cmCpOYayyP-GxhD0_NY,1753 +torch/include/ATen/ops/mkldnn_reorder_conv2d_weight_native.h,sha256=BIwIUwRZwNB0L86o_L0aaZ7FkARwODqer9z2Kk2zPos,910 +torch/include/ATen/ops/mkldnn_reorder_conv2d_weight_ops.h,sha256=kA3pqTcN2W_V4I5n4TeSdmSdmWTgP5FAEnzxtsf3ecY,2728 +torch/include/ATen/ops/mkldnn_reorder_conv3d_weight.h,sha256=hDQcsDafngXh_STmQLAZsUzUqk3qI15-5yITKp9iQ7I,6361 +torch/include/ATen/ops/mkldnn_reorder_conv3d_weight_compositeexplicitautograd_dispatch.h,sha256=3VTKEkUOaMskHCsVvxIwtXBoud78O_xoM3YIEC1THJU,1577 +torch/include/ATen/ops/mkldnn_reorder_conv3d_weight_native.h,sha256=dsljc9-09PPK2XpHPxc4qa7lS3HkJfVMr5fROI21DhI,822 +torch/include/ATen/ops/mkldnn_reorder_conv3d_weight_ops.h,sha256=7VoT6Jxmv8rZ0vskeSg8fhSjJk9wDDEMOs8fcchOF6w,2462 +torch/include/ATen/ops/mkldnn_rnn_layer.h,sha256=OpEz2OSwCi0Vv_kLedfTyhd2GQfrCmIcLC4WQTZBvNM,3743 +torch/include/ATen/ops/mkldnn_rnn_layer_backward.h,sha256=9wPF87WaVzj0sUkZ7Uzl-sjxr14V6C4PXe_2X6l8zAQ,5549 +torch/include/ATen/ops/mkldnn_rnn_layer_backward_compositeexplicitautograd_dispatch.h,sha256=RocIHQXfuopN-ggc58KZsLoNBCrhYlMBiK-LcJvK0ZA,2453 +torch/include/ATen/ops/mkldnn_rnn_layer_backward_cpu_dispatch.h,sha256=Ahuzh_L1IL2qhiVhrUhtYmppMF0-Dr_UheXCptzm_ws,1386 +torch/include/ATen/ops/mkldnn_rnn_layer_backward_native.h,sha256=CfPa73NVBHn3VRa9w0Sqowe4gBh4Enc6Z8Ccb9U_h3Y,2024 +torch/include/ATen/ops/mkldnn_rnn_layer_backward_ops.h,sha256=YodL0f_EKyuBs_pMg_DLaSFDXjwxclnbwJ47rcgI2yA,6481 +torch/include/ATen/ops/mkldnn_rnn_layer_compositeexplicitautograd_dispatch.h,sha256=9hMvweCvF-PAgR_aQ75FP-yAhd6xz7llMQZBjpGBkUg,1761 +torch/include/ATen/ops/mkldnn_rnn_layer_cpu_dispatch.h,sha256=EcOtf3uG9B90tGTX9B2nlGegs2YcfWx6XOYcuOaaHfg,1103 +torch/include/ATen/ops/mkldnn_rnn_layer_native.h,sha256=wRDaoz2K6tZYNGLuYZFMYNL1j-YbuQ6Z_JrDo-qCWLc,1395 +torch/include/ATen/ops/mkldnn_rnn_layer_ops.h,sha256=jr5Hb6gxc_UWwoYzEwWY8miUZ3PqImbq1euvHz7R3QQ,4380 +torch/include/ATen/ops/mm.h,sha256=dtqQN5DohyiSlZ_7bLjEsyEYFljlNPULsjGVNzTedKs,1107 +torch/include/ATen/ops/mm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ReNeYLeW2Oo6wzkTDXZ4WYv2FThtaA1Lh1D3--tv8DY,811 +torch/include/ATen/ops/mm_cpu_dispatch.h,sha256=5PdBe8AGnCEzTroRbrpiF7CZ-W8_9SA9Y-0XcQaCA2E,940 +torch/include/ATen/ops/mm_cuda_dispatch.h,sha256=X4dZ27WGvRRncGVUsFNOB6GPpXRRZG6BCm_ZCtZtJmM,942 +torch/include/ATen/ops/mm_meta.h,sha256=EZEPRUjaIpYSSM8Lj41LridwOeOMwXRIftpO86zWRO8,607 +torch/include/ATen/ops/mm_meta_dispatch.h,sha256=jYXxC7gP-lJ6pE0E6clafVELaW7DDAbWShDhX_l7hsk,942 +torch/include/ATen/ops/mm_native.h,sha256=BjipXeM5i508nMKsc0VVa-t9LJRuvu02ezRn-I52QvY,1175 +torch/include/ATen/ops/mm_ops.h,sha256=srs1mZNgRBHVV9cmYIvAfozeGYYKORZyhF6-T_ZJPnU,1732 +torch/include/ATen/ops/mode.h,sha256=F6fMnjrlVbpP6aYSG7H7QSq11-PrMGZq8getp544rgA,2609 +torch/include/ATen/ops/mode_compositeexplicitautograd_dispatch.h,sha256=yVjw9RBIyefmqmqCh4IwYpVi-ZDfiWk1VhlndK54bm8,1030 +torch/include/ATen/ops/mode_compositeimplicitautograd_dispatch.h,sha256=2cjpJiDxzaczkC3bcy-FxnFkC-rp__vLee7UyN4BAY0,1149 +torch/include/ATen/ops/mode_cpu_dispatch.h,sha256=LXChVP5tLSI6szhpdOuxZ0SkCf9o2Hvu-brMglWFvIA,779 +torch/include/ATen/ops/mode_cuda_dispatch.h,sha256=kVBHurRgXiDpsiIHkEE3vzPMd1dTBH3YJgw2pqCHPsE,781 +torch/include/ATen/ops/mode_native.h,sha256=ILNWCfu6axPcl2Ve9HVsIatkUvL2kt4Yma2DeI3bsYg,974 +torch/include/ATen/ops/mode_ops.h,sha256=LKWYW2ElfwHMAUuNppEqYi9Jqx9Xrc2wsI89WT3-LYU,3802 +torch/include/ATen/ops/moveaxis.h,sha256=UAoobVr2Jmrv12t9S9ZLAUMPGBgQ7vvmbiy_fgDfDzY,1004 +torch/include/ATen/ops/moveaxis_compositeimplicitautograd_dispatch.h,sha256=63FIf4CY-v2SiJFepjN4hutOjXSIXSkyinG5xgS37U8,912 +torch/include/ATen/ops/moveaxis_native.h,sha256=BJBzdfqEVA_FsY1U5ophzzZj3Ynrf5otyiSR3XOhrD4,635 +torch/include/ATen/ops/moveaxis_ops.h,sha256=SRVhVvlvH5GkF5cM8-OCCUS0xNTses5yaTjb6XxgRGk,1852 +torch/include/ATen/ops/movedim.h,sha256=rlrmgxeyTe_Gq1xVHKNjyi_9N3DhcdfrVkyG5-7sd68,997 +torch/include/ATen/ops/movedim_compositeimplicitautograd_dispatch.h,sha256=wB-0aaLseyYN1YOEQCyKxxsx2pJJ1UbPqDm2Jcb4z08,910 +torch/include/ATen/ops/movedim_native.h,sha256=dVtebM6BClrYn3ByyE9jf7c5YidxUIg_b_cyPOX7rrY,633 +torch/include/ATen/ops/movedim_ops.h,sha256=O5BpI4KFlJfMsU0Cjxw49pE5Qv9dZGXRXaXMQwSe_uI,1846 +torch/include/ATen/ops/mps_convolution_backward.h,sha256=Lq1M2tAj0MNi-WAVdCLFDzZZbhUb5AkNDh08y4Ou_hU,8971 +torch/include/ATen/ops/mps_convolution_backward_compositeexplicitautograd_dispatch.h,sha256=Ll7yey86REXlxLuN7b7LmdCESa3p4zstiVMjtCQoNPs,2194 +torch/include/ATen/ops/mps_convolution_backward_native.h,sha256=5GJiEmgnREVo3CaHn1RL7fXrIcpQYX_G-hoFy68bJ2w,815 +torch/include/ATen/ops/mps_convolution_backward_ops.h,sha256=H4EUHaQCFcZGP7fwOsOL0vXP19-3YIgTcaGU4ywIxIk,3437 +torch/include/ATen/ops/mps_convolution_transpose_backward.h,sha256=VdM_cs6qVk6Nto9I5u_7A5XW4TKqZrTuQ7-X-fpgb6k,9707 +torch/include/ATen/ops/mps_convolution_transpose_backward_compositeexplicitautograd_dispatch.h,sha256=6kAymuyRJtQ6yai2CYT_r2udh2LSas9MTt0d_5WrhyU,2242 +torch/include/ATen/ops/mps_convolution_transpose_backward_native.h,sha256=_U7bC_WDQ-WXr2UluDMYMTxyKAERD0pMpEH66kmYee4,829 +torch/include/ATen/ops/mps_convolution_transpose_backward_ops.h,sha256=XS9wqMIg3yA-784TKbZfoRYIV9uLSNxcsDLd1w13XeA,3572 +torch/include/ATen/ops/mse_loss.h,sha256=ggdcRaW8isPUHWRg7FHEmlES9xHlfxIECxn9w12pQP0,1375 +torch/include/ATen/ops/mse_loss_backward.h,sha256=_umnffHaKP_8NL8vLL_yowkdxtEIBCUawWFXwK1gcFE,1675 +torch/include/ATen/ops/mse_loss_backward_cpu_dispatch.h,sha256=prsBkiByBVplwQwpPL6rcwkuHJQHzFumxoqWe86wMc0,1158 +torch/include/ATen/ops/mse_loss_backward_cuda_dispatch.h,sha256=k260nCwJOwDhqtC2PHfTluBlqWSBKxqaZlKYZJgGi60,1160 +torch/include/ATen/ops/mse_loss_backward_native.h,sha256=frKMQ3EP-w6e6ZyKLig13rpfX15_By9Ey984GCYDfIA,750 +torch/include/ATen/ops/mse_loss_backward_ops.h,sha256=SlQZDPEX5VzryZk49GGx0iUXtdmwirk4PmaHUoARWBg,2208 +torch/include/ATen/ops/mse_loss_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wzoVe5Ba0jGdHzrYtqkpLp8aK3DJDDJqAKMtmzPLsAQ,858 +torch/include/ATen/ops/mse_loss_cpu_dispatch.h,sha256=6ZVxCEppchCoCnWGbfhNpNQwIKv8_WEDpyJCCC3fo04,1061 +torch/include/ATen/ops/mse_loss_cuda_dispatch.h,sha256=ZP4HTD0MG8FfGl5OWy4IvOHhrMqswu_wusCfAr46I0M,1063 +torch/include/ATen/ops/mse_loss_meta.h,sha256=35ABDesnff7x6OWUQCoGTEzOa1GeQY_sKjH1H7D0t00,634 +torch/include/ATen/ops/mse_loss_meta_dispatch.h,sha256=wH6I1oRvOpI6RSnxkIYkyHoJ_yKFXX6x0KkFS-xjm2w,1063 +torch/include/ATen/ops/mse_loss_native.h,sha256=wrYXz-paj7J4OVqGR_Ymhu9BYT-im-XTsY-Vg4n7yVw,659 +torch/include/ATen/ops/mse_loss_ops.h,sha256=fQdczsZdhJvPgw1dAQ5lfKr3md9A8x9oMNqFWBM_Dqo,1914 +torch/include/ATen/ops/msort.h,sha256=ctwivNWgQRqeT_SEzHjTWOCs4CQQYrsJTtSL-xHmS-I,1005 +torch/include/ATen/ops/msort_compositeimplicitautograd_dispatch.h,sha256=9Az46MGiuCu0enLjDsr61JyiCbNcoXskzCDxdmUzFPQ,918 +torch/include/ATen/ops/msort_native.h,sha256=o8skUvp37Uw2hvJSo6D7Q_R-Q4HSxjfZp9PqOZa_dqo,563 +torch/include/ATen/ops/msort_ops.h,sha256=wOoWbvh4-M_Q_Gy08oyCwaHat7q5m2kEC3WsvaEtc9Q,1584 +torch/include/ATen/ops/mul.h,sha256=cwHnxU_gSl894P59hT34QmA6UzgQD3qXF9yhgDnzgaM,1821 +torch/include/ATen/ops/mul_compositeexplicitautograd_dispatch.h,sha256=jEUDiEx5YLIIzB2n7F1C1JR2DKu7kyBX5uWh544STWE,1064 +torch/include/ATen/ops/mul_compositeexplicitautogradnonfunctional_dispatch.h,sha256=4Cxk7Qbusyzq3Hj-wvG6lPHkKlk3JaLhvl-wUboT-6Q,887 +torch/include/ATen/ops/mul_cpu_dispatch.h,sha256=PubA9Dmbd9biBychi74OR_taVAhP4Q3D4ZDxDunh6rM,1020 +torch/include/ATen/ops/mul_cuda_dispatch.h,sha256=pT_BMvqChXy5ih3nf4V4aCxMoanv2ZYdM6maN7r329I,1022 +torch/include/ATen/ops/mul_meta.h,sha256=lOel4A0LHABbK1NM0eNI89WGlQqYh_JlIciWGkPDe8g,616 +torch/include/ATen/ops/mul_meta_dispatch.h,sha256=uCHg0P3BoO1Mf07_NsrUU6c4DNnPnqubU3drOWzbFmA,1022 +torch/include/ATen/ops/mul_native.h,sha256=wEDxiQF1Syyf-OCelwXtI38X5C6y801QhLyTXhmNnKA,2495 +torch/include/ATen/ops/mul_ops.h,sha256=e8IgaZ1oeV65OcMsll93oPzMVupN_SvADoWy-BjUYFw,4373 +torch/include/ATen/ops/multi_margin_loss.h,sha256=OqO3ToKp3nTUeTPPq7DGdJVqjcpGj1V6fCwJFaL-PJs,1959 +torch/include/ATen/ops/multi_margin_loss_backward.h,sha256=byw78N9xeqR15XoxkZWYSTu6mVGGwir9QPi5To745pE,2294 +torch/include/ATen/ops/multi_margin_loss_backward_cpu_dispatch.h,sha256=pVw8eEmvvt-G6JJEUxBc7SPWPbkCuvxVUHn0S-PBFsc,1504 +torch/include/ATen/ops/multi_margin_loss_backward_cuda_dispatch.h,sha256=xcSde64-6BvWwik4B-L4H9SF-eMT8jtrAkSCdGqXGmE,1506 +torch/include/ATen/ops/multi_margin_loss_backward_native.h,sha256=J_YtPV9D18qiYlCwteBGr8d8E0ZBuJ1HzNmPwcSzrOo,1531 +torch/include/ATen/ops/multi_margin_loss_backward_ops.h,sha256=_RjtWNBJ8s5qu3UPm4ajR8hCNdn4gY6Y1Yv13MvVx7E,2878 +torch/include/ATen/ops/multi_margin_loss_cpu_dispatch.h,sha256=JxNx2CntfkAKN2u6jJ4qlWodwuqDg0-ilndfiNVlb70,1375 +torch/include/ATen/ops/multi_margin_loss_cuda_dispatch.h,sha256=HTn_uTCItLlmRkKq6wk6nyVZRbH6UNVaxs8vc05NQvc,1377 +torch/include/ATen/ops/multi_margin_loss_native.h,sha256=URuKEBT84GS39bH-mHO5_6xRebZmrNd3zcOq_k_Efxo,1361 +torch/include/ATen/ops/multi_margin_loss_ops.h,sha256=4JWCier-z9R1fVwFETYGnfywrMl3gryDUjzNnw_1LHg,2582 +torch/include/ATen/ops/multilabel_margin_loss.h,sha256=LAWNSk4WqAs-hysOCYA0eSgoRYWJprwsIeFJOpVSvDU,1515 +torch/include/ATen/ops/multilabel_margin_loss_backward.h,sha256=kWwMxN9NnqG5P4SzvnW511EhWqOPC7Ll19FJiPHh350,1992 +torch/include/ATen/ops/multilabel_margin_loss_backward_cpu_dispatch.h,sha256=tHGtNMwj4_hMZc0iYfI7pKc4V6v-lC6d-0PYQFpDDZ0,1290 +torch/include/ATen/ops/multilabel_margin_loss_backward_cuda_dispatch.h,sha256=ztcKAbtClLZTFmf40Wi17o-_h9tf_QBy4YqAZwMMJXQ,1292 +torch/include/ATen/ops/multilabel_margin_loss_backward_native.h,sha256=A2Bqw2ZPGfwkcvLmM_2612bW8bTiQU8hwSNGkv-R3FU,1261 +torch/include/ATen/ops/multilabel_margin_loss_backward_ops.h,sha256=B4zb_qlzKgCZ0kCSn_0fH6D9JeQoDO51M12VAOPLJ1w,2488 +torch/include/ATen/ops/multilabel_margin_loss_compositeimplicitautograd_dispatch.h,sha256=78u8wCES5KDdQni7yL6CIWml732XLYsgeNZg2IMJSKE,1147 +torch/include/ATen/ops/multilabel_margin_loss_forward.h,sha256=AajW7gxw-SB7pSSVoL13_BN4-sHznrHGWDSexUYFDi0,1818 +torch/include/ATen/ops/multilabel_margin_loss_forward_cpu_dispatch.h,sha256=IpM-D4rJyMjV8vt8vfaBPyFlimLBp2m15_nPOkyZXnQ,1220 +torch/include/ATen/ops/multilabel_margin_loss_forward_cuda_dispatch.h,sha256=bkrgCtg7hYcRFM2agOfQYADEZhNcLVHNTPfGsakARDs,1222 +torch/include/ATen/ops/multilabel_margin_loss_forward_native.h,sha256=oewx9-CKnSRAf3KSfYVZlXIqTnY9sOAFXiW_itpFUQw,1153 +torch/include/ATen/ops/multilabel_margin_loss_forward_ops.h,sha256=WVwNb5emXeoLlciYv3_PO4FQScE0urrR1kzaDUrT3pc,2335 +torch/include/ATen/ops/multilabel_margin_loss_native.h,sha256=0OcZo2A3kejPNZBOMs2eFcPSH6ry3s13HK6wkS-a2iU,709 +torch/include/ATen/ops/multilabel_margin_loss_ops.h,sha256=MOgt5N9h_Ee1r6fJ2Sg0jDdDxDdWkXsktGXcdHdcRXo,1998 +torch/include/ATen/ops/multinomial.h,sha256=PT97sFjP7wTT7AODFnXqRlMb3yMji2rBwJS6X7OQZ3I,1658 +torch/include/ATen/ops/multinomial_cpu_dispatch.h,sha256=TAocyrktqBR3WH8DhOTLWrHxDbGByN8x2DVoQINkCG0,1167 +torch/include/ATen/ops/multinomial_cuda_dispatch.h,sha256=Usk0SVh0CUhIOy91eV2bX_b6QwzIr93Buy_eqSIUm4A,1169 +torch/include/ATen/ops/multinomial_native.h,sha256=dwht6uP6BdHTjTI3tRIFHDu18ergfeCO4d1ocx3Uzyo,752 +torch/include/ATen/ops/multinomial_ops.h,sha256=ER1xFTXqd2xYlAYj1ex_TohdfvE91RHpvmu-Tnh_4sQ,2165 +torch/include/ATen/ops/multiply.h,sha256=7z0Rwwl0snxCHGRlsGl56XPWw-zUFFZVJJckw4NbhBo,1392 +torch/include/ATen/ops/multiply_compositeimplicitautograd_dispatch.h,sha256=JVc8j_zycpTTwTEds50BsZk3ARMCKnO18xq-tEkdv54,1245 +torch/include/ATen/ops/multiply_native.h,sha256=Jy0v6CP2CWc_yw3FvBFjcVgmUeBZxnVOSwElNkluCco,861 +torch/include/ATen/ops/multiply_ops.h,sha256=VPBhsE70bMMKo0rDVs3M5V4vW_B3PI7DA5AKUnVOm8Q,3727 +torch/include/ATen/ops/mv.h,sha256=qY-shBP8be_1fv7fWjKYvWEA8My3I02NMRqhShDp_ZU,1098 +torch/include/ATen/ops/mv_compositeexplicitautograd_dispatch.h,sha256=lZCLFGCvxrwdhMImb-9WFpCfholt8zwix1JHc7p0zpM,981 +torch/include/ATen/ops/mv_native.h,sha256=BXjKKrFYWen2CZ7gLmCC5QnyZZ2gzorRfclNCx3Es8U,686 +torch/include/ATen/ops/mv_ops.h,sha256=hQx3m0t08zLcaCbrEk6oUYpsVY-r0-G1gxwd9rR5244,1726 +torch/include/ATen/ops/mvlgamma.h,sha256=mcdTJczeNihO9hrTRVyDqvLVKUlk9XbcujYb7zpa_jg,1098 +torch/include/ATen/ops/mvlgamma_compositeexplicitautograd_dispatch.h,sha256=JfMNo-T0tAdZIlt_AK8532RSvdJJGCepN6YkG2d0x5M,841 +torch/include/ATen/ops/mvlgamma_cpu_dispatch.h,sha256=U5q_MQLMvwJRvK2Ri2oEtfv4kN_ov_y97lZJpsnzeGM,849 +torch/include/ATen/ops/mvlgamma_cuda_dispatch.h,sha256=WYb2MIECUwJWCGovItVl7YXftKqjv9t6dJO0_FlVO50,851 +torch/include/ATen/ops/mvlgamma_native.h,sha256=Q3DSO_4cNNjAvAwC_wQlEPss45PVHrrp51qXdoHZljc,655 +torch/include/ATen/ops/mvlgamma_ops.h,sha256=LWS38cGI49Sl2FninwLjUXay-LOuN9RzZU25DJMWS60,2254 +torch/include/ATen/ops/nan_to_num.h,sha256=SMnUI17iz_9uHBPm2xJLSROFgvTkLN9ZjizrsUL6PsE,1986 +torch/include/ATen/ops/nan_to_num_compositeexplicitautograd_dispatch.h,sha256=gle_jj3XASMBNyyBlkGKKxynORtsUs4D5G4etBlo0yg,1075 +torch/include/ATen/ops/nan_to_num_cpu_dispatch.h,sha256=G8DW57gaPqtm53EUw1TFvtCL0mp4RiaOrrw7ylU8nyA,1044 +torch/include/ATen/ops/nan_to_num_cuda_dispatch.h,sha256=GqoyFYJVJVA1cI87rB6vgWCZHg4740gs8GK7hZhAM3g,1046 +torch/include/ATen/ops/nan_to_num_native.h,sha256=-dSQce25fCtd9LIE6e0lczTdIK6XZscKMo_6a3Q_BJ0,1522 +torch/include/ATen/ops/nan_to_num_ops.h,sha256=mFPPeWxS3yq5s1tBVAUonnHnut3v4bF3ZT94phLPTPA,3058 +torch/include/ATen/ops/nanmean.h,sha256=BaLfTKxKgiTK7s9KdA7JlxUwi1Ngb-UbHGZsWL5wlLM,1581 +torch/include/ATen/ops/nanmean_compositeimplicitautograd_dispatch.h,sha256=lemaiKvzGm4JBw10s6e-3WwBPvtyi_ZFRf63ib-jU8M,1228 +torch/include/ATen/ops/nanmean_native.h,sha256=wuYRSHvvTuG-83Q41ttZsr3YkKhq6zOg_wqK78Pl2xs,759 +torch/include/ATen/ops/nanmean_ops.h,sha256=NUc2zwbFF80j746mrLSj0567Qh9p5Uk31wyYTOBEM_0,2167 +torch/include/ATen/ops/nanmedian.h,sha256=pBULn7XN4074CUVV6dxjJ6XAKPaPCqirhWAffRoYV88,3289 +torch/include/ATen/ops/nanmedian_compositeexplicitautograd_dispatch.h,sha256=iIxLfSVV3FxrCFhK7FTSjyloybUN700orv8HItOEahE,988 +torch/include/ATen/ops/nanmedian_compositeimplicitautograd_dispatch.h,sha256=8Nh-81uGIeKupoirioYUEH5S_nhKBNsg7M5fW4gCOAU,1164 +torch/include/ATen/ops/nanmedian_cpu_dispatch.h,sha256=vctDDPRonNKcbe-RGaJdAXaLXgT1SVMUZbnQqFEswRc,1050 +torch/include/ATen/ops/nanmedian_cuda_dispatch.h,sha256=5JLcRz9B0xyLsNGWQ5xz19kPG3XqYS8Hh7pXNK5dZ-g,1052 +torch/include/ATen/ops/nanmedian_native.h,sha256=viyu1HdlOLcIf_zuoPKFZcSiXJ5lpT12r-7sOgTUfwI,1364 +torch/include/ATen/ops/nanmedian_ops.h,sha256=jDVyWJLG6uFFzRlG647ZjHUuO-nNaL2hEJ2r3WfcEvs,5074 +torch/include/ATen/ops/nanquantile.h,sha256=VAYs67oJtnzDj6uu6qkNvN-pqbHmNRfoYMk74DIdiOE,2962 +torch/include/ATen/ops/nanquantile_compositeimplicitautograd_dispatch.h,sha256=LKbMHXezJ71wmStn-1ooA0PUXOfMtbg625gxy9mw7fA,1814 +torch/include/ATen/ops/nanquantile_native.h,sha256=RGv6kNcmJXp_0fTs0r_1dbBe5PPOX5QbyjtQxTmTXZI,1133 +torch/include/ATen/ops/nanquantile_ops.h,sha256=LmR2rBpvm-TRY6uUOX44H7_6f-qFttUBmIK19jpjv8Q,4111 +torch/include/ATen/ops/nansum.h,sha256=o0yhZgNqd-a6bfAx2nDuJ1ZLY4QN_VZ28HsdX3p1L5A,1571 +torch/include/ATen/ops/nansum_cpu_dispatch.h,sha256=aUuHLeah4OI5gnwKaKjNx1Oa_RE_Z5VyC2j5PUi7NAs,1181 +torch/include/ATen/ops/nansum_cuda_dispatch.h,sha256=fzxRwTKK5xxnHS-dMnNs5y_iJUfnB2eztWkXLQBBcmw,1183 +torch/include/ATen/ops/nansum_native.h,sha256=pyWYjNDxdwT5sfeyKNRaosyuz6Yh1rsbhAcWUvaqEiQ,757 +torch/include/ATen/ops/nansum_ops.h,sha256=Y99Dw7eLFGczYNsTNmtM-hoXGGhlqAjgXBf3dWCbOVk,2161 +torch/include/ATen/ops/narrow.h,sha256=KJa3Sg7szdzj-pfgzdPU-URkJVOBYYyNYucd9WNhFSU,2646 +torch/include/ATen/ops/narrow_compositeimplicitautograd_dispatch.h,sha256=oyEHgOR4sIWBFraHk2R3t_-9LN5NDaWKPrvv2n1MKs0,1150 +torch/include/ATen/ops/narrow_copy.h,sha256=bGaNMsqXIDRxdTxu4_1HtrKakrsaTYZ4ypXcX0jb6_E,4102 +torch/include/ATen/ops/narrow_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WD9km1plJ9m4iDKP7zllGw1kkhGoi-LvksHuHsin80s,957 +torch/include/ATen/ops/narrow_copy_cpu_dispatch.h,sha256=aqWzrVAs2JtXkKTv_2XcpCfdu_emEKYGz-4tNVZK5aU,1427 +torch/include/ATen/ops/narrow_copy_native.h,sha256=kTADY47GgTLuy1XcA7H2gAQT0XRltFAeTFt_3ARtQI0,917 +torch/include/ATen/ops/narrow_copy_ops.h,sha256=1k6vOgk6bD7_QhmgdQziCCPWe4CDjqG8_gBbNpypcak,1974 +torch/include/ATen/ops/narrow_native.h,sha256=Gdo7rPz4VGEQQgFEg-d6K5m9RQO9creCU4L3l9WXyWY,793 +torch/include/ATen/ops/narrow_ops.h,sha256=vCERx00f6FfuVPZDDDK7cDWGj3QtkYf_RNudQSlcW_0,1907 +torch/include/ATen/ops/native_batch_norm.h,sha256=JXh8DFk9yEkFHdWOkNcqc91HQHYbPBm4avVAsk9Cw0M,2766 +torch/include/ATen/ops/native_batch_norm_backward.h,sha256=AyXB3FOe-hKTG8byjmRl7Xpu9F_0B9xGbIc4I6oMwR4,3294 +torch/include/ATen/ops/native_batch_norm_backward_compositeexplicitautograd_dispatch.h,sha256=xrFVuHWZ6p9ZaUhMVG1AbCaanGZiKsRuR6iqNfUpRPI,1699 +torch/include/ATen/ops/native_batch_norm_backward_cpu_dispatch.h,sha256=lujr5B76VwV4TEZP7hrbFxTPY2Sz-L6rF3HH5actMek,1093 +torch/include/ATen/ops/native_batch_norm_backward_cuda_dispatch.h,sha256=3DyaFVq6hQaZVmAo5Kz7UqFWNvB0GQiWwYr9aF9v9fc,1095 +torch/include/ATen/ops/native_batch_norm_backward_native.h,sha256=_g1Og4-eIQU8EEpHzTLmFce41TEr3l0P7dDGm5Gdkzk,2203 +torch/include/ATen/ops/native_batch_norm_backward_ops.h,sha256=IkBdCSK2f9Fz6gPFNLYlQ4-0FhOqshfsoKb79hn3ii0,4175 +torch/include/ATen/ops/native_batch_norm_cpu_dispatch.h,sha256=Yo5p6l4qoufEUY5AE_jEMOL3wTHX7FOQ1zn4sWJkmE4,1792 +torch/include/ATen/ops/native_batch_norm_cuda_dispatch.h,sha256=gh0kRsdn4eu0_2YOarS4TnZ0BMYN9asnceDGCQjHu8E,1794 +torch/include/ATen/ops/native_batch_norm_native.h,sha256=7MVuMpUIDgxGtiXhr88BtS84E91Klo6ItKYz1SuzdVE,2194 +torch/include/ATen/ops/native_batch_norm_ops.h,sha256=E6-avDwf_6Iz1w-JwleiRyY_Koh5yubQJNHZzp0N9Bs,3546 +torch/include/ATen/ops/native_channel_shuffle.h,sha256=ZlzS8-eg76q0XYju5SS6g6Yu-izZ3AURIux0257Cl4Y,1479 +torch/include/ATen/ops/native_channel_shuffle_compositeimplicitautograd_dispatch.h,sha256=EgPaeX8pigfObD21AIgI9rq7IDkJUv6WwUDBKAc9jkU,893 +torch/include/ATen/ops/native_channel_shuffle_cpu_dispatch.h,sha256=ckCrqMRnuAkwJBAZ84zT3YwRxbT9f57rj-nL0Zh8d84,849 +torch/include/ATen/ops/native_channel_shuffle_native.h,sha256=GOp-cNafRfKtGmc7ZFd7gO2f_9wf3w4C-vXW0cLIvRo,600 +torch/include/ATen/ops/native_channel_shuffle_ops.h,sha256=UHUquz5B_u-8FIO86QJLcXYJtixi7w52aDolEozIr-I,1083 +torch/include/ATen/ops/native_dropout.h,sha256=O9N8whUKe3eBhOu0wsPf_KQDGvTuqirKeCq4bvobU4I,1518 +torch/include/ATen/ops/native_dropout_backward.h,sha256=hjuBK8_rHK0NzzaQIa3T2ZU40DlWuEkXKC5UlZN7pA8,1482 +torch/include/ATen/ops/native_dropout_backward_compositeexplicitautograd_dispatch.h,sha256=U7WG2d3WTPdD_N8R0MTlRKtxzRbvGDzB8sL21JqHo78,993 +torch/include/ATen/ops/native_dropout_backward_cpu_dispatch.h,sha256=1bORFhHM3PR9-gzAYkolIhplknpTrNFVzax0CauxA6k,783 +torch/include/ATen/ops/native_dropout_backward_cuda_dispatch.h,sha256=5rlBnKFiOAEU8mGr4Rw3f0Ao9Ort-GtWlnjpj0O06W8,785 +torch/include/ATen/ops/native_dropout_backward_native.h,sha256=EryR5mhHPT05a4aO9WBGTX_NEg7CM6zs9iPxbgD-dlE,813 +torch/include/ATen/ops/native_dropout_backward_ops.h,sha256=pckW5clCMbnqf3oqGzloY2tbRC_AqG0und88ERLdMfQ,1998 +torch/include/ATen/ops/native_dropout_compositeexplicitautograd_dispatch.h,sha256=f5SmvasDjKYaXJSumIRSfrCDGGfQ92e6pAnxZaC0rxo,1053 +torch/include/ATen/ops/native_dropout_cpu_dispatch.h,sha256=yYe3-__Zw_VTTIEmMdEfj1CrAumr8YVK5Uxj4wIPSiE,791 +torch/include/ATen/ops/native_dropout_cuda_dispatch.h,sha256=S3dmTbENftaZRepuxCmBYAB709RzPSpNLqVvSO5Ln80,793 +torch/include/ATen/ops/native_dropout_native.h,sha256=cflv2nBsexmXvsBnYB-lpW-XU21qtFQDaujoGq_IpU4,995 +torch/include/ATen/ops/native_dropout_ops.h,sha256=B6IPNvcVpFDPui8E5GXN9xeAUdYp-SSa5YtBT-3OKJ0,2146 +torch/include/ATen/ops/native_group_norm.h,sha256=l0uO43_EzzHXUBFB5k55g0j7Dl5JHTxJUh4CQgqkLno,7182 +torch/include/ATen/ops/native_group_norm_backward.h,sha256=UU2dk0ibv7-J1tL3GuFnozE5opTIIs0ikc_cnZih4ic,8715 +torch/include/ATen/ops/native_group_norm_backward_compositeexplicitautograd_dispatch.h,sha256=x9JEcAmDXL8jU_JbkA3kIVPz4Fkig8D2C_hbc6kEJQ8,2282 +torch/include/ATen/ops/native_group_norm_backward_cpu_dispatch.h,sha256=EgtMB1dfXJsXDX8gfsONrjyASff2tmc9SKg5s2iyefI,1317 +torch/include/ATen/ops/native_group_norm_backward_cuda_dispatch.h,sha256=MH07vF_fJJ36WH86aL_WH7m6U4-mv_lkr5K8D6WkKco,1319 +torch/include/ATen/ops/native_group_norm_backward_native.h,sha256=hTic7f9GbxMcHbJg1BusqhPwz6vGsz4dvI4QgGVSkLQ,1151 +torch/include/ATen/ops/native_group_norm_backward_ops.h,sha256=SjFbeYjZg5q1QxMqWN6ZyNNY1ll7meR_kv7DVQv0nfI,3573 +torch/include/ATen/ops/native_group_norm_compositeexplicitautograd_dispatch.h,sha256=VbI3k6F1iZLdUq2dR7Gj_6nxV8NjhTOAAl1dLwSQwJ4,2513 +torch/include/ATen/ops/native_group_norm_cpu_dispatch.h,sha256=A5wmY_xubw-Kj8buD4WQ9JuRijEKdZmSRxAE6nz8orY,1177 +torch/include/ATen/ops/native_group_norm_cuda_dispatch.h,sha256=nmGDxopaHjIf9g4QpbPsrImyLtWiDtIoxKoFm0FHc7A,1179 +torch/include/ATen/ops/native_group_norm_native.h,sha256=q4ZcVlX1YhBg4XLOi7MrMLecVds-43SXT0mMyV69vzw,1255 +torch/include/ATen/ops/native_group_norm_ops.h,sha256=Sx3Wv83AzoXYPEREEfKQmMyvhoUdnkgSK_JsSRyKoLI,3119 +torch/include/ATen/ops/native_layer_norm.h,sha256=Sgh6LtsywbpBOQ4vDzRFd6_zd15OdpXqvhKOM0g5YFg,7002 +torch/include/ATen/ops/native_layer_norm_backward.h,sha256=DQ_ltMzYCDOMjFHNlWhuNnpK-eCVRA2UMSpGkYDry6o,9171 +torch/include/ATen/ops/native_layer_norm_backward_compositeexplicitautograd_dispatch.h,sha256=V7tMBf_H3_8-_TV3zq1ir8t1asOdY0hiLLH6F2R-fF8,2362 +torch/include/ATen/ops/native_layer_norm_backward_cpu_dispatch.h,sha256=Cn6pD1-h0p5GpipTQiX8fLuDqnEqFdKTZ5yUzdpw8bM,1357 +torch/include/ATen/ops/native_layer_norm_backward_cuda_dispatch.h,sha256=bKbOuQEQOFzjesXYcbEXlGEC9XlWyUSlAlhAbh13_bE,1359 +torch/include/ATen/ops/native_layer_norm_backward_native.h,sha256=BkdNRScb3-8gdCvwQU64eTWUJgGWkACkviP6NFumPzo,1866 +torch/include/ATen/ops/native_layer_norm_backward_ops.h,sha256=2rwAHABOQEORmRsAaI_kzt1Sr71Bcg8ZX9AwsvyhVLw,3649 +torch/include/ATen/ops/native_layer_norm_compositeexplicitautograd_dispatch.h,sha256=FuYUB6Ra9uhm88-FHJzLzO3qJtDZmgyrB4LEqP7ecDY,2393 +torch/include/ATen/ops/native_layer_norm_cpu_dispatch.h,sha256=_kImS1FOnx0eGDPK_MSyO8ao18nbLed2Rh-XU8cRa8c,1137 +torch/include/ATen/ops/native_layer_norm_cuda_dispatch.h,sha256=xhiobJkxNFYiHdnK8WK2PfuYPbpVr6TRm7PL12NIEec,1139 +torch/include/ATen/ops/native_layer_norm_native.h,sha256=73579-194wUyggOhe9hdHUq0WdZnUulrjCASKYmkPz0,1661 +torch/include/ATen/ops/native_layer_norm_ops.h,sha256=mj4i0gpQ2j5R99rHWJa06Ra_HBDpAR-UERpTpX12N00,2937 +torch/include/ATen/ops/native_norm.h,sha256=wG5-p1F0BFGR1IbLOwRg2DrWrfkN39Sbm1Lty88XxDc,2437 +torch/include/ATen/ops/native_norm_compositeexplicitautograd_dispatch.h,sha256=yo-pVuo3Ixr6lG-1NB1dUUzIY3d0VaN0stopgp_p2M4,1308 +torch/include/ATen/ops/native_norm_native.h,sha256=oStyLmtmCucdM8WONOVjFyOR9N0o8ZKPkSZzE-ZCRms,1001 +torch/include/ATen/ops/native_norm_ops.h,sha256=081dvo44gE8i39i6a6HcEisBTuMtsO8Tyjk_CF3CQ0k,3803 +torch/include/ATen/ops/ne.h,sha256=fpiqwnRQwC1Yi5csDZSIQvAR6C80A6jWG4aJQ1Nt3LE,1830 +torch/include/ATen/ops/ne_compositeexplicitautogradnonfunctional_dispatch.h,sha256=0gw8iMctAjcy-Z2Hpb8eo75Imq53Z2GsmVOZPr-MxMw,1034 +torch/include/ATen/ops/ne_cpu_dispatch.h,sha256=wEEAkM1FWpUvaz-2utdvzOAnm3PnxBdiDy-w2om4mcM,1366 +torch/include/ATen/ops/ne_cuda_dispatch.h,sha256=BuZttwvEAMY1AsP0EBhQkXrIAVYH6qg3P8mZlygb_54,1368 +torch/include/ATen/ops/ne_meta.h,sha256=wZuCJy-XRjTyyiyyA9RZK8Si1joG8KqFJWD7pCjz3gQ,762 +torch/include/ATen/ops/ne_meta_dispatch.h,sha256=vSzkq-l9bjmE5jw-u4khf8OCCah1cgqc_kbXKer1jgk,1368 +torch/include/ATen/ops/ne_native.h,sha256=pyJ2GwLBlOuRdDPWOigNWagLNwr1CdUB4LpZcXyXOMo,1216 +torch/include/ATen/ops/ne_ops.h,sha256=5YSGYg4oDEihLkmaYRarv99DiE_RRWJuFSSKJnz8YgQ,4376 +torch/include/ATen/ops/neg.h,sha256=-0C0jROUjS6iSgbb3q2cceIGrYQUPgSzFk0otd2ouuU,1118 +torch/include/ATen/ops/neg_compositeexplicitautogradnonfunctional_dispatch.h,sha256=8fv7s5dGUs5sM86rIZTZGxgn7oHZU349Mjo2GeU0eTU,835 +torch/include/ATen/ops/neg_cpu_dispatch.h,sha256=7euY_fTbQvFB3hm2rbv6Kn2OVEqlrHIa3QRYsPJiydI,916 +torch/include/ATen/ops/neg_cuda_dispatch.h,sha256=-KZliKkCLs-5szk1vYJ-idRfUsS7Wlku3MNcCka20ss,918 +torch/include/ATen/ops/neg_meta.h,sha256=d7SVBHYwKJ9EFIFUCheTrsNX8QN0SqqT3Ce7N2g4oDY,583 +torch/include/ATen/ops/neg_meta_dispatch.h,sha256=VgpbxF9crPHGqcTksaTWQ2LO67i9nsHusQRU9HglkvI,918 +torch/include/ATen/ops/neg_native.h,sha256=1Uz-HKHVBEkHoAvmJGdSMKBdItqFQQn1-YAvVMqYnJk,1125 +torch/include/ATen/ops/neg_ops.h,sha256=1QVUSd3Pn893aqoKeka7kKF63Y6YHZ7_ROrrM245q1c,2095 +torch/include/ATen/ops/negative.h,sha256=V2OlYW3mdpsKtfKbAe5ajSh6r-KnWTnFjEvLHCRN7L4,1183 +torch/include/ATen/ops/negative_compositeimplicitautograd_dispatch.h,sha256=op-PvxB7IRQOY89z8hgzpEvBJt3HwmIwPOd9bEEtroI,980 +torch/include/ATen/ops/negative_native.h,sha256=yRV4tWMC6KsIHJZt4s4X5QXEVY24khgp9VH_8XBACTg,622 +torch/include/ATen/ops/negative_ops.h,sha256=qbjYNYiSeo5UO_2ABMcNGdWrsBk5BBtAj98Cnd_zK6c,2140 +torch/include/ATen/ops/nested_to_padded_tensor.h,sha256=i9eJgyzxR_vAH3EP-iBvX1j4gmCGhJK-n1Ax7rUAKUI,821 +torch/include/ATen/ops/nested_to_padded_tensor_compositeimplicitautograd_dispatch.h,sha256=Ndl2oGZD76tf_lQk9rDZwv2Til8fYy57BvCe9CrmOx4,847 +torch/include/ATen/ops/nested_to_padded_tensor_native.h,sha256=8-fXP154Qx1yLE4MKShYAz1bYRzxPiQfvXs6-02J9Vo,570 +torch/include/ATen/ops/nested_to_padded_tensor_ops.h,sha256=27rDY0mvy4gU9uZljB-YYQQaepawoazNn7mXFiN_9wU,1197 +torch/include/ATen/ops/new_empty.h,sha256=YycKpP85D3fBzAicLiZsNdrtZ7tOOjcrYuHX9vG0O9U,4347 +torch/include/ATen/ops/new_empty_compositeexplicitautograd_dispatch.h,sha256=EhLFNI7cFstUDUYP7MJ4SLbWbII9RyV6jvkEkKOFVYM,1818 +torch/include/ATen/ops/new_empty_native.h,sha256=AxwUaTxLeYKVs0RGn6Vu0_ukaZHmBZSbObq7PcqTcOQ,786 +torch/include/ATen/ops/new_empty_ops.h,sha256=ncIfCFBBO0cr326Lt_dIXKXaRfSxKuEsj9Z8gicjRtg,2256 +torch/include/ATen/ops/new_empty_strided.h,sha256=Zyw563RT6rXlM26h0Gpzvs13fNQ9jPKGN2S6h2Pmv8c,5211 +torch/include/ATen/ops/new_empty_strided_compositeexplicitautograd_dispatch.h,sha256=7gyzd5EWa-1GeI9YpgmpoldiMEepkEIHYDrNHVjJ-f4,1282 +torch/include/ATen/ops/new_empty_strided_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Szfsu09opGS-K4DpmZh8dTUdF4LO1mcWA0aANurSwzg,1544 +torch/include/ATen/ops/new_empty_strided_native.h,sha256=xEsYOLzgfWz_nH-nvf48OWkTlRkj1N3vQOJjzFU_W5A,858 +torch/include/ATen/ops/new_empty_strided_ops.h,sha256=QI4gStHKFR2Do5wht0kButZI4iLhzg8yhciHIPQAKq0,2492 +torch/include/ATen/ops/new_full.h,sha256=_7sznhdbkJMHk2BlnewUp_Ho59MuQP5HR9cEPsFvyBo,4910 +torch/include/ATen/ops/new_full_compositeexplicitautograd_dispatch.h,sha256=c86Fgij7n42W-LP-L7QSWePOQJyXSFkf_bObsTmFMy0,2058 +torch/include/ATen/ops/new_full_native.h,sha256=rlW25ExrgMSc0u1PwhvFqN7bG2f6l9kjgzYSUYhoNgI,835 +torch/include/ATen/ops/new_full_ops.h,sha256=oyX-ebV4Qjk9SYTcA48xu4U9Cy7kqNExbqbsS2pQMps,2452 +torch/include/ATen/ops/new_ones.h,sha256=wITV6XJp2Jx1lYiBzDyMerc7t89NqHZaOYGzVs3VGjQ,4318 +torch/include/ATen/ops/new_ones_compositeexplicitautograd_dispatch.h,sha256=h-aJeWpJtD1V6VKnFNoMjTNhQNltPuuWBpLpmr9Dlog,1810 +torch/include/ATen/ops/new_ones_native.h,sha256=XZAU9alKvHy57aElD7MuSfHo--vApbaE66XYYHuSg58,773 +torch/include/ATen/ops/new_ones_ops.h,sha256=qIRe6L3RM19xRJsfLR6GSb1bIRz4c6edhprJ6aGLLiE,2250 +torch/include/ATen/ops/new_zeros.h,sha256=gIMPsr0slGk6bgf7eBLwGrm6lo5rBr9sJeT5E7kl0zM,4347 +torch/include/ATen/ops/new_zeros_compositeexplicitautograd_dispatch.h,sha256=04zX221RUvndivi4WM-qDu9UEdXD0O4PHLVNxYkTzaw,1818 +torch/include/ATen/ops/new_zeros_native.h,sha256=x2opLScqHs9GAkyTC-ltqzFqwwHtDfNdP73726vA_Kc,775 +torch/include/ATen/ops/new_zeros_ops.h,sha256=o-LlGjsYf0dcpQjPLDUNxaqx2YVb-Q-yT8u0Y2I9qPI,2256 +torch/include/ATen/ops/nextafter.h,sha256=hZx5yNDKA9uBNtUSCLVGPXgsaSUFnZm_7i9MqVOSKGk,1186 +torch/include/ATen/ops/nextafter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=vYK-Z3NDwBdNmqQX2vSsLBYvoEUs2XpRPveolkEZ9zA,899 +torch/include/ATen/ops/nextafter_cpu_dispatch.h,sha256=LYp7ltIrRJEYMPKE4dN3jbWCdjlbTM_aPbAnUJLpNkY,1044 +torch/include/ATen/ops/nextafter_cuda_dispatch.h,sha256=Lxj1Z4o1WtYT5iVDG6-b24VrV6WA51-NZ3BKSPLakhY,1046 +torch/include/ATen/ops/nextafter_meta.h,sha256=t0QmuWgkVBzRdoBm5vpynrvJQaHqbgAw5BdOEdLkLkY,615 +torch/include/ATen/ops/nextafter_meta_dispatch.h,sha256=F9PSZdrbwfFI0LlwM3o8PVIPd9HDsZ136TQ8SOSQe14,1046 +torch/include/ATen/ops/nextafter_native.h,sha256=r5DLeBUqHqNfxLNADYFpzmwhkTSpxhQKwiFQS0ZHbO4,642 +torch/include/ATen/ops/nextafter_ops.h,sha256=Kt_ZbcIpQsNnCIr_OGVunSjIr0y2H9QlGswmFqjE79I,2407 +torch/include/ATen/ops/nll_loss.h,sha256=Z_mexahSDiAI2XrRdjiAEsFvDevGZS7wgRUHqrFWA5A,5517 +torch/include/ATen/ops/nll_loss2d.h,sha256=sME530HHr0lOjiQRByglBpWdoNjDyUNFuC-R__m07d0,5579 +torch/include/ATen/ops/nll_loss2d_backward.h,sha256=EhupNblAApiLbC_ISCEK_kjcX53k5Hl1ULGYxdP512k,7118 +torch/include/ATen/ops/nll_loss2d_backward_cpu_dispatch.h,sha256=Nofe2SUZWy53qBbJ5CZ55JJ6r1dNDA9j0NpCHimTD2Y,2277 +torch/include/ATen/ops/nll_loss2d_backward_cuda_dispatch.h,sha256=4lKiFi1buLZDBxknx3IY5-dqaSQU8v_2_tQJXXR3_kU,2279 +torch/include/ATen/ops/nll_loss2d_backward_native.h,sha256=HNPUVNLLn57ktoICGOZk0RKUP27qUkPQ9WEonyTTKFg,1481 +torch/include/ATen/ops/nll_loss2d_backward_ops.h,sha256=fulQMzRzmuYPZDZmV3zK9tJxkABQnNXXQr3Xl_TFRfU,2876 +torch/include/ATen/ops/nll_loss2d_compositeimplicitautograd_dispatch.h,sha256=HeRE-mkGqLMqOqUNIHTJCQNbOG2rcDBoXGMv4KsG2ws,1961 +torch/include/ATen/ops/nll_loss2d_forward.h,sha256=IevemrmwcBYd-b9_jAk_pphw1JOxWzkSOkSonhtvTfU,6469 +torch/include/ATen/ops/nll_loss2d_forward_cpu_dispatch.h,sha256=vKeLXEpWzA3uMRWhNcnazUH9DG6jpcuprxTp8q1_KZ0,2131 +torch/include/ATen/ops/nll_loss2d_forward_cuda_dispatch.h,sha256=kDV3GVF8TImYthor8R-uHL2IvxKhDNIQmuWZot8Ebxk,2133 +torch/include/ATen/ops/nll_loss2d_forward_native.h,sha256=gJTNehyOs5do9YvykGwkz2StDdt58voDaFFt_Jt1Fzo,1367 +torch/include/ATen/ops/nll_loss2d_forward_ops.h,sha256=OhAyA-RiMxf1oGLZP-LchDiat5t45ClNQrnMp98qg7A,2717 +torch/include/ATen/ops/nll_loss2d_native.h,sha256=d67az3mdwL8DJaOSRguvDI2wB-0RQeCm95aIul8_ALw,832 +torch/include/ATen/ops/nll_loss2d_ops.h,sha256=IK_XCBtBped3rufaGDPkV8SrJPoAp7OXEe_0bIitew0,2388 +torch/include/ATen/ops/nll_loss_backward.h,sha256=erFInKDntpY3Tw9Boq5CKyLD5DpfeD5EXm_ev7xOk-Q,7056 +torch/include/ATen/ops/nll_loss_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=lfuZEKPVqwUYoJw0brM9SOLELtIFdzBF5gMeGTByzzY,1227 +torch/include/ATen/ops/nll_loss_backward_cpu_dispatch.h,sha256=pkJPlwBB2uI6iXBQARvjsok3H1VN7O5ySbLVbTNSiC0,2265 +torch/include/ATen/ops/nll_loss_backward_cuda_dispatch.h,sha256=THY-IkNKsktoeVjjtnJMuZBHCo0vAznmnHjia5hj8fE,2267 +torch/include/ATen/ops/nll_loss_backward_meta.h,sha256=tFTRCm0kdQOO9BQLDLdZqu2-pBC_PzUlQYaQ9IpO7f8,760 +torch/include/ATen/ops/nll_loss_backward_meta_dispatch.h,sha256=cECC09NH6HM7c5YzB7sdVvQAl2iIwzS0WLHsXAKPb3I,2267 +torch/include/ATen/ops/nll_loss_backward_native.h,sha256=IDx8NM_mjywMD5h_PTjkc9tiP8EESu0PdyZ1bSXd1wc,1152 +torch/include/ATen/ops/nll_loss_backward_ops.h,sha256=BDc-d6ztirKIBSwBd-rQi_VAeeZKhjUFtggCLsfHRSE,2864 +torch/include/ATen/ops/nll_loss_compositeimplicitautograd_dispatch.h,sha256=HGzffZSdeBaK6PrdzXU3PskxIyz-mxcIsQPWuj-EzLg,1949 +torch/include/ATen/ops/nll_loss_forward.h,sha256=oR_G69H6uzpkqTE80LLlUNBYKwf7RyWc-JZUzaZpb7w,6407 +torch/include/ATen/ops/nll_loss_forward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nvZeKGeKVt6IDdKaKGe9o5QFTui-Ud_-9kaBnHK4axA,1145 +torch/include/ATen/ops/nll_loss_forward_cpu_dispatch.h,sha256=7NirWkK722cjPvKTOyrYXOxHPv4hBdk3JE7jIMBKfMA,2119 +torch/include/ATen/ops/nll_loss_forward_cuda_dispatch.h,sha256=YtiWriLtYXYqc5qCtdsfQVWlVuTNS-l50gxdB0Fssz8,2121 +torch/include/ATen/ops/nll_loss_forward_meta.h,sha256=CBRvZLZ-goi3TBvrQBrtlIOepxp5djm5oDJd6ppCPbo,694 +torch/include/ATen/ops/nll_loss_forward_meta_dispatch.h,sha256=wFtO20n6rU0D_Y62NLQvu6gE4Z1iwgFzJkLJmgvvhJw,2121 +torch/include/ATen/ops/nll_loss_forward_native.h,sha256=O1B5Svp1wT5aHhu7oGCdMvn-6Gp6Vfki3ZJelNSEJzw,1075 +torch/include/ATen/ops/nll_loss_forward_ops.h,sha256=EMkF8vxZeRyT9MQNBZJpbZA9QK46i_7s-0GsDEXKw2o,2705 +torch/include/ATen/ops/nll_loss_native.h,sha256=nu0r0pw2J4FlRA3SYWIGtmoiVUrlXVnzELPXdq8QvDQ,828 +torch/include/ATen/ops/nll_loss_nd.h,sha256=OuldC7Oy9yn42a3cRPikrxPNuFE-2iO8wmmwej82pDM,2112 +torch/include/ATen/ops/nll_loss_nd_compositeimplicitautograd_dispatch.h,sha256=Q69Zy8op31Bq8h_0s_koaaTs-f09yyTqq0ObF-eI4h8,1115 +torch/include/ATen/ops/nll_loss_nd_native.h,sha256=mL8njff7rOMlXtxmkO8VXpo2Ryx-59vDBqhPjwe6-mE,641 +torch/include/ATen/ops/nll_loss_nd_ops.h,sha256=-OBkR6HCi3qHqj1_WXx337AN_J1PdjHf82u6SaaRK90,1369 +torch/include/ATen/ops/nll_loss_ops.h,sha256=0GoZFaD3z_KsHkau9Z-lkogaOC0_r_jXmXcMdKpe0XQ,2376 +torch/include/ATen/ops/nonzero.h,sha256=j1i1vZrgucOLFna3fcvZ65-XynStfC_WlT4CiyB0Jh8,1025 +torch/include/ATen/ops/nonzero_cpu_dispatch.h,sha256=JVA9iWUJegnvjJsq2QZC7esCIvmq_8cnSqIKzxowGpE,880 +torch/include/ATen/ops/nonzero_cuda_dispatch.h,sha256=NS-AvF2Ad8-8_7bshKBnpna0l3ear6Ifh1dVV-94w6g,882 +torch/include/ATen/ops/nonzero_native.h,sha256=L-p7_TQO9QWzKL00YjuozZCZysQu4XGpFIN7GAXdl7I,719 +torch/include/ATen/ops/nonzero_numpy.h,sha256=qHwu-Udk6KpboWokxWAdBMzXzIg38eO2DIpergiFNfI,670 +torch/include/ATen/ops/nonzero_numpy_compositeimplicitautograd_dispatch.h,sha256=2M9_IcFfBHE-FLPOGonmDs8s1PaaLDKOkB63BCamvi0,786 +torch/include/ATen/ops/nonzero_numpy_native.h,sha256=i_QB_0kmirxSlWHMDzFU_LRYjExKNYoKKIrPy6n8WhM,509 +torch/include/ATen/ops/nonzero_numpy_ops.h,sha256=VjoeHBhzMIde-izNZvrnJjPAPgflSX3ybRVbLrbyo4s,1035 +torch/include/ATen/ops/nonzero_ops.h,sha256=Z9HAVv3WObxN7nFeb31hERrfm2ABveJ9_H-Z-HnSl_I,1596 +torch/include/ATen/ops/nonzero_static.h,sha256=apzM7aQqVjr3AB1rcQrXlYIyC8AiGGopTeaumchOP6U,1347 +torch/include/ATen/ops/nonzero_static_cpu_dispatch.h,sha256=PLbx0ftOcfMXwgwWPUU5pHKPFpuFo7busPF4WmcxvXA,1009 +torch/include/ATen/ops/nonzero_static_native.h,sha256=1Lx14yP3Be4T3OhyT0o_LxHjA98l1xwvt3i6FY3008w,660 +torch/include/ATen/ops/nonzero_static_ops.h,sha256=I0ikGZjOvSAmdPoriyKmp5KHngRNRbFO0JFv0bxyDkE,1871 +torch/include/ATen/ops/norm.h,sha256=jaXW2tZTuX4AeFh7JSjKPKkApWjBiCqb29ZwIgRoksc,6220 +torch/include/ATen/ops/norm_compositeexplicitautograd_dispatch.h,sha256=FpWiu67kgFqszIRB64XBwdyzAXNsPcalioWCZvCtRV0,1367 +torch/include/ATen/ops/norm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oVldhunEdx4x0hnwuIgOybqyiuycBKEVz8M6oWzbVn8,1012 +torch/include/ATen/ops/norm_compositeimplicitautograd_dispatch.h,sha256=SVviLJVCKr7bZfGtu2CVSv33e2t19lXtbQtxur00rh4,1630 +torch/include/ATen/ops/norm_cpu_dispatch.h,sha256=RBLOhTR3z11kaB9u4hkUYpk8irrwvDz865TUVAEoiXo,1586 +torch/include/ATen/ops/norm_cuda_dispatch.h,sha256=omCQreYzFdUeIrFewpLL1yjGHrw26c-_satYxOiS3i8,1588 +torch/include/ATen/ops/norm_except_dim.h,sha256=H0K9E9MASKWAoWSjt6qOZyee9x5LtzaKvISEIshlTaY,714 +torch/include/ATen/ops/norm_except_dim_compositeimplicitautograd_dispatch.h,sha256=WFyBku0XyXj6g72Hb-vx6c3ss713V9R94V41HMQH3yw,800 +torch/include/ATen/ops/norm_except_dim_native.h,sha256=GxmCRrP_7kooEgXikYRhbF7E_N0g5aoIjU5LbbDfbtI,523 +torch/include/ATen/ops/norm_except_dim_ops.h,sha256=rnTXW55jbLYVd7UVV7eUacYKK-6Z2aJDB7h_1L4hDHo,1077 +torch/include/ATen/ops/norm_meta.h,sha256=VCVOgQtK2wyJ2ElatMdlvvfAMn97GP7-M5NZCUrj47U,876 +torch/include/ATen/ops/norm_meta_dispatch.h,sha256=CguMpaumyjOCXZgYXuLNU-8XJHkPKKZVfDQq1r6maW8,1588 +torch/include/ATen/ops/norm_native.h,sha256=ft_o742AC4nVNOcfEuFRmRh9l-QYVGezgIYnbqK5c2I,2253 +torch/include/ATen/ops/norm_ops.h,sha256=P7i3_6nkWNmZWbBb_fMWs3F82cE-4O2KHg3JbDi0Vl4,10563 +torch/include/ATen/ops/normal.h,sha256=YxJ6He5owUPuDWgZYQ_f3V94FVK97FDbKZH1xyPNr-k,11569 +torch/include/ATen/ops/normal_compositeexplicitautograd_dispatch.h,sha256=3LL80XmETiktm8xfdekyu4dE-Py89A8W9-oVgSNjtDo,2617 +torch/include/ATen/ops/normal_cpu_dispatch.h,sha256=8h5Hr-qWznl58El1gcuaEmJb2ihVJ8cD6fP8eKh4MOw,2018 +torch/include/ATen/ops/normal_cuda_dispatch.h,sha256=dVxdjcW0HNZBVCY4SdLwCTau8mmuDnnwR5gJALqI4JE,2020 +torch/include/ATen/ops/normal_meta_dispatch.h,sha256=HfKsU-cAycwB5grvyonRhndPgL0EBBXpBakmu-QSk0w,2020 +torch/include/ATen/ops/normal_native.h,sha256=d0Z2vGskocFE7k6B6XEFYFF6vEWnP88K1pwHdHdHSe8,3272 +torch/include/ATen/ops/normal_ops.h,sha256=qG8raGtcBThy00WDPK8DSKFC7ownx4APPg5EfDZ-2Sc,9884 +torch/include/ATen/ops/not_equal.h,sha256=bbzR1lSBP8_Opr5TZLhI2AyVPQ9xSpbWBc-8CoFVAAQ,1963 +torch/include/ATen/ops/not_equal_compositeimplicitautograd_dispatch.h,sha256=Hv7pe_IWW23uaET-h9de1yltqNvplM1rgp8QFiBY7Mk,1466 +torch/include/ATen/ops/not_equal_native.h,sha256=eXSXT3iUbXQ1oJJ0XKJNDucqFIk3Uslme6_Ieqwp2hM,973 +torch/include/ATen/ops/not_equal_ops.h,sha256=iFU_wsR6ShtNLgyQdyrh1EJ7fveQfAkhT04Dn6_Dz7E,4502 +torch/include/ATen/ops/nuclear_norm.h,sha256=_i7394hj3q54vxko84jloQ54RECGGgb_9eonlMQyEQg,2074 +torch/include/ATen/ops/nuclear_norm_compositeimplicitautograd_dispatch.h,sha256=vhRWRYRPERaidyNV-hbowCBZ2HlABPaku9map-l-4Bw,1339 +torch/include/ATen/ops/nuclear_norm_native.h,sha256=O9q4uRjHXy3C_AmfwxhMwyj6cRs9CBymixJRmY-Hl6Q,831 +torch/include/ATen/ops/nuclear_norm_ops.h,sha256=wzB4EX4cQaaEPzGpNSSkGS5-IxRhkVxS-dKC_k9XgpQ,3199 +torch/include/ATen/ops/numpy_T.h,sha256=s7RSovFmwpNdSSTz37DrPKMxsMw3ewlJxb03u53TP_o,492 +torch/include/ATen/ops/numpy_T_compositeimplicitautograd_dispatch.h,sha256=OCNdHot_8eP2h9wLwO048woz7aS8pqQo8mcIujot0Ac,765 +torch/include/ATen/ops/numpy_T_native.h,sha256=z9qojWHEUy7hZFw_6RtBnJpw9NnfeLm51kxlbGPAJm4,488 +torch/include/ATen/ops/numpy_T_ops.h,sha256=R2k6SuO6n-6vrijKtlTPyDbeQDUYpcB_Xvw0VEWBp5E,976 +torch/include/ATen/ops/one_hot.h,sha256=C9hQFg6wLg8V88xhJxfNR1-0B5rLvvuVkPG1twcBVvs,686 +torch/include/ATen/ops/one_hot_compositeimplicitautograd_dispatch.h,sha256=tVy4fq7qb7U4eeTz-cPl--TBb0Ee4jVUOWQsKswy5dU,789 +torch/include/ATen/ops/one_hot_native.h,sha256=CklhWCKkpm9QcR2IO6JXvMhIO12UBuAJ2ejNonKyAIc,512 +torch/include/ATen/ops/one_hot_ops.h,sha256=SvV4c3DrBPavuroVvyMn-ZQ1l35QP3yeisqA84N6rqM,1041 +torch/include/ATen/ops/ones.h,sha256=e63Qyit1knDu4-b--6gX1thY7CgQdpq-b1oVKZteWKk,6809 +torch/include/ATen/ops/ones_compositeexplicitautograd_dispatch.h,sha256=x6Ccuq4EDFNnkaUPY4s1QQL4vfPcqpz3ZcYdiX7mRa4,2142 +torch/include/ATen/ops/ones_like.h,sha256=vYFCH5Y2CFFzfp-okovE_nnl3n8MHYWJKxcd3tZTa3Q,2176 +torch/include/ATen/ops/ones_like_compositeexplicitautograd_dispatch.h,sha256=AoHhv9siDOVCozcw7m_Q1EY8crZbLhF9XY73xQghLHU,1368 +torch/include/ATen/ops/ones_like_native.h,sha256=2jCKhxqEAPCSHCZZvlYdtJ3e83Hgn4LAX5UWSB9gTtw,827 +torch/include/ATen/ops/ones_like_ops.h,sha256=BhSz3vTA_Q6IUbMLshLQseEZ9CvjWlj2ysn1pNHAYjk,2402 +torch/include/ATen/ops/ones_native.h,sha256=hUYkinEMWCih9sdV2-IfClFlkqcItvgX2sjRd6hwaKg,1057 +torch/include/ATen/ops/ones_ops.h,sha256=vnDz-bl9J4Bd8tjkvVSPoUbU-7gtb7Ad--gfZXN3DpY,3943 +torch/include/ATen/ops/or.h,sha256=eflD2vA0o9xhbp8V3HgrwWr-0vPPYppFFHi8eTG0NRo,878 +torch/include/ATen/ops/or_compositeimplicitautograd_dispatch.h,sha256=ig4iyemDkwA6VDc2NPJrsRjHRExSL6pSF370YKeHDCA,1024 +torch/include/ATen/ops/or_native.h,sha256=sQk9KFubjyakEgmMT6XJGYb_xPbbTU-1H3kspu3NwrY,747 +torch/include/ATen/ops/or_ops.h,sha256=zsIOHUd0GF5_xiPR9ZbiIX9OZG0va3d7ctuhhiVZ90s,2988 +torch/include/ATen/ops/orgqr.h,sha256=2E8BbpZ7TTuXEMSz-Q3GeInHUDzfFKh6tMMktHzitc8,1155 +torch/include/ATen/ops/orgqr_compositeimplicitautograd_dispatch.h,sha256=oP1VzvT-WgUOZ9C1M2SqhSV68rJ5eMxLAjL7WEq5cBc,999 +torch/include/ATen/ops/orgqr_native.h,sha256=KPFp35J9EAim8o5Wx-m3lXADfFfo2Xx0wATp_aEGLKc,617 +torch/include/ATen/ops/orgqr_ops.h,sha256=X9XfbELpHNRbFxek5wwyGeho-s6_HEV16VnuC0TKsmc,1762 +torch/include/ATen/ops/ormqr.h,sha256=RPRTECibyeVsnysj6FXFOVFvt2CDgJzuYKcYEDXQSJ8,1573 +torch/include/ATen/ops/ormqr_cpu_dispatch.h,sha256=g--JcO7fArdX43KXgL9q76WVWPA_8MrPRRI-GYIAP48,1139 +torch/include/ATen/ops/ormqr_cuda_dispatch.h,sha256=lUHWwaDpsKUzgE4sTV9UaHhfOyCmDkr6GYea2rKQKjk,1141 +torch/include/ATen/ops/ormqr_native.h,sha256=-zqGd500DoN7yhxV_ezdTlmpFatarFGk_ZUvr6JqYIM,736 +torch/include/ATen/ops/ormqr_ops.h,sha256=rtogJUcgh8QGLPM_T4hPrdITRS_Zo8LPoeIKDEsZeqs,2148 +torch/include/ATen/ops/outer.h,sha256=8xs62H_hKGk-9tGK9RHBeAGd6EB7Wn5VpkrGWoUX5yU,1137 +torch/include/ATen/ops/outer_compositeimplicitautograd_dispatch.h,sha256=noHy4UXi4eieN5N9eRpcIwH86Dca3XXx2GXEZHoDD4E,993 +torch/include/ATen/ops/outer_native.h,sha256=MuNmqV_vEcHMxUo7oJn4BYX5z2SCZEYui6umnkjxNpI,613 +torch/include/ATen/ops/outer_ops.h,sha256=Pf-ZUzzcBf0zoRSzbZ1EPKU3AApEJ75dttt0ptV1nW8,1750 +torch/include/ATen/ops/output_nr.h,sha256=BFNC4MbT28nRlxkhGXemxW68SC-vE_jSmmVxFublPM0,494 +torch/include/ATen/ops/output_nr_compositeimplicitautograd_dispatch.h,sha256=ADkZzPrF0NkaDkieqleI9Ul_CZA_0q6DGRRbqC1t9jw,764 +torch/include/ATen/ops/output_nr_native.h,sha256=nTFESmqXGAQ3V2gcAJMP0iupJVAxtE7KpEc4LMKWToI,487 +torch/include/ATen/ops/output_nr_ops.h,sha256=jUHXlgipu0DilJkM23lB33e82KK84aePBkkx4dJCTmg,964 +torch/include/ATen/ops/pad.h,sha256=qbGkFuBREMA1fCCPQ_bKCqu5SBX1z3yWrHLfyLG7748,1764 +torch/include/ATen/ops/pad_compositeimplicitautograd_dispatch.h,sha256=mKFoKzBNF0hiumCxEO82tdkI7a5e5yGjXB2LFCzHBs0,1017 +torch/include/ATen/ops/pad_native.h,sha256=dH9Nbn7bM1MIckgp5E-fZdz4PtU7pPEXLnnHRkMer3o,592 +torch/include/ATen/ops/pad_ops.h,sha256=BBguytW9xSnXW9gFJWirCDafu9eWoG_aAmglwGBhILI,1230 +torch/include/ATen/ops/pad_sequence.h,sha256=0NZffDJRpbrlAKdcms-ohQn6u9JwaN95i9bnjYs4Xzc,789 +torch/include/ATen/ops/pad_sequence_compositeimplicitautograd_dispatch.h,sha256=zQHfzgADpJvyS6Sh0jPigaTlFseUo3S3135NebCE8ok,821 +torch/include/ATen/ops/pad_sequence_native.h,sha256=4qukY6r2it5jWGudI9ciO2w3hb9PwumDOpza_kIdtXA,544 +torch/include/ATen/ops/pad_sequence_ops.h,sha256=hKqCGOWg6Dlq-T0gNulOIEPgaenaSiSStaK8JtzyqnE,1133 +torch/include/ATen/ops/pairwise_distance.h,sha256=cUaeq6yT7TN3aK-oEL36ILwKYMCTYOv1QD6om2eSRz0,816 +torch/include/ATen/ops/pairwise_distance_compositeimplicitautograd_dispatch.h,sha256=PJCuj024kpFizJvOWremBwg2xrEckFuZL9p547qPVOM,846 +torch/include/ATen/ops/pairwise_distance_native.h,sha256=zwuvRxV3d7qmMuP3nMkOm7FZJ08-3610dAJaO_rQ9Ms,569 +torch/include/ATen/ops/pairwise_distance_ops.h,sha256=1QsVVoYM7Rhp5ucjbnDoD8fCd-KEVHljcZDUmoywvvM,1213 +torch/include/ATen/ops/pdist.h,sha256=t9zIqsCgUrIQEy2eLnVRcuHEXkEsAg0e4Om39JMBVaA,647 +torch/include/ATen/ops/pdist_compositeimplicitautograd_dispatch.h,sha256=nJWNmO-kEwhIwizjFVtsJ5uwPVp5WPR68hFqDbw9aVQ,775 +torch/include/ATen/ops/pdist_native.h,sha256=OtLtQA0pXD8LS-0RgnWQ_S7su6cIB1TO9ZeZzteggsQ,498 +torch/include/ATen/ops/pdist_ops.h,sha256=n244EMPwJxX19XD9lI2fc0Ejblrk5SsZNHfAKeitkik,1003 +torch/include/ATen/ops/permute.h,sha256=Uaarg1JPaNmrFx9Bs3k_6BHXHjLc-4Ldh3yxHDw_7l4,675 +torch/include/ATen/ops/permute_compositeexplicitautograd_dispatch.h,sha256=znIjnggAXqVPwL1-FUsICvhKAqa70EppXBIJqSNI1is,787 +torch/include/ATen/ops/permute_copy.h,sha256=bMkGWuaFGcISbZ4tA_xYiYoMH_BtXXCRtFZi7tF34_A,1195 +torch/include/ATen/ops/permute_copy_compositeexplicitautograd_dispatch.h,sha256=RpiSHAZlCmZc-aCUlLDmlcAtJhiSlbkm5oX3M-EUVtM,923 +torch/include/ATen/ops/permute_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=HvgN6ExkSCEPfBW-ty9WLMppLX7vJZZgksAl-GEE7LE,818 +torch/include/ATen/ops/permute_copy_native.h,sha256=AP3nR8zThV4hzSJQsAIdL00zJh7xWpwNhYL40CnAPdU,621 +torch/include/ATen/ops/permute_copy_ops.h,sha256=175qzWRSQBJjq9lOUShCiMu7Q5t6lmnvuBWRw2H7JI4,1772 +torch/include/ATen/ops/permute_native.h,sha256=i981QZUEBCvf0422lAtjZ4uHwFcmexuSubPAMRfKF3o,598 +torch/include/ATen/ops/permute_ops.h,sha256=RPT8qIddeD9EYihvSQF0gMYUqQUDapcQEUT6nnYtkQs,1049 +torch/include/ATen/ops/pin_memory.h,sha256=tNepeHcdLlDZSKW7eR_fh320do0P6VFhXHahKKI0yLs,495 +torch/include/ATen/ops/pin_memory_compositeimplicitautograd_dispatch.h,sha256=2GXUo9D4sczyamKAyNYnc1Z30r_q_v1WMeE56WGdH3M,815 +torch/include/ATen/ops/pin_memory_native.h,sha256=zLgwh5ei8idt4vkqSKV8RwgRxdV3LoSYivqSpj9prxg,538 +torch/include/ATen/ops/pin_memory_ops.h,sha256=rISZsokBRdfAus2S40vtdmQK55l36IqO85Nq9xDE7Gs,1101 +torch/include/ATen/ops/pinverse.h,sha256=8bgHOMGTvqFGDLZS81Ur8G6y9P8H3CRxSrXPjfTGlk4,679 +torch/include/ATen/ops/pinverse_compositeimplicitautograd_dispatch.h,sha256=agiX8Sh2u1RWp5cyWjjoAhOwJRJwjt_VFFCc2dstTk0,786 +torch/include/ATen/ops/pinverse_native.h,sha256=cUnNsrddddJ_YmXnGB8NMfgRuWMMddteVzfhRaA5ROQ,509 +torch/include/ATen/ops/pinverse_ops.h,sha256=ri0SDzK9T-r5T3wYnc3vwgzT2CeSutSwCf8iKmxL8ns,1028 +torch/include/ATen/ops/pixel_shuffle.h,sha256=xOjcfh9uHKSTSXwn5cnGrFulAWqXcC_11EIA50quwuk,1265 +torch/include/ATen/ops/pixel_shuffle_compositeexplicitautograd_dispatch.h,sha256=T6qQA5lkzWlFqcBeRqBYqqr8W2sGmp8UU8nYQ1-8md8,929 +torch/include/ATen/ops/pixel_shuffle_compositeexplicitautogradnonfunctional_dispatch.h,sha256=2KlZIKqBxNARnD7EqM9_l6NYAEsIKZKdt7XyTteDjHI,821 +torch/include/ATen/ops/pixel_shuffle_cpu_dispatch.h,sha256=VMxgDyVdVzrE6RvjqLTJn6Bd0nF8ZDySg6wnkVa1asY,751 +torch/include/ATen/ops/pixel_shuffle_native.h,sha256=e8PS6OXwinWx5S65EDwach0mfBMVoiAUFb_BbAr3-bk,721 +torch/include/ATen/ops/pixel_shuffle_ops.h,sha256=Zfyl_b7IYhH8UBFNpo8Fk0qO9Wgqai6dXQFQkMdBDmY,1786 +torch/include/ATen/ops/pixel_unshuffle.h,sha256=uU3lDYHOzQkpyPP-4JkqHXVL8D_U-wEXbFM6YP2Czy8,1303 +torch/include/ATen/ops/pixel_unshuffle_compositeexplicitautograd_dispatch.h,sha256=8bTZWrKYAEj0Aq0mluWXCi4pywLtREZ9MTT3Olkkqcw,937 +torch/include/ATen/ops/pixel_unshuffle_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AYolLvLlcFkkPYMheQ6wRpA6wSN6NeW81mmMIbpHIW8,825 +torch/include/ATen/ops/pixel_unshuffle_cpu_dispatch.h,sha256=DSsyO3j2gQcQEqhQbIR0gc15Psd_KpyuKtWB8F_4hqo,755 +torch/include/ATen/ops/pixel_unshuffle_native.h,sha256=57bw-1yiR-qZDkCykXF7v7cox_mm7Tvu1B7LnBZSSnU,733 +torch/include/ATen/ops/pixel_unshuffle_ops.h,sha256=Tr3h7cJKo-Qi0T9UgJ9OKelGISx4R1Q3xHF-QUFcw9M,1810 +torch/include/ATen/ops/poisson.h,sha256=JnRinLS_6to_jSyLVKocTBZQqdoykNVXcLn0FKgC-mw,1285 +torch/include/ATen/ops/poisson_compositeexplicitautograd_dispatch.h,sha256=oGkfyVWd7BSNtdJ6rbrLWssOVP9SfdPnkLO-kBjajc4,962 +torch/include/ATen/ops/poisson_cpu_dispatch.h,sha256=7dtJlL6ONZfOmwTbyqs5opkdv4eqME9_5U8SMtTo7Pw,774 +torch/include/ATen/ops/poisson_cuda_dispatch.h,sha256=nUoXuzTHLG5ZFGy0fWchWCL3U9x0x5ZVtj7T9O3RYy4,776 +torch/include/ATen/ops/poisson_native.h,sha256=qOeMhgygRuddzTNrIuthiW9bjCzpTPF6TnWu6Mfy4rY,783 +torch/include/ATen/ops/poisson_nll_loss.h,sha256=q8yztP8ba3vfrPuBax-4CHRpUw7ffutxzYGTVmH1sU4,862 +torch/include/ATen/ops/poisson_nll_loss_compositeimplicitautograd_dispatch.h,sha256=ygZ3zCKxpcJtm0WO2GkK1QBV2JMv_tnEXyBzevESOJs,860 +torch/include/ATen/ops/poisson_nll_loss_native.h,sha256=hjUF2Rlty8Hz776yeilhL5auO6SgVUXWXj-LtlIXTb4,583 +torch/include/ATen/ops/poisson_nll_loss_ops.h,sha256=jLRh-re2KEpptvffH4JJKCbY5XYf1DqcYWNnRbceJEo,1287 +torch/include/ATen/ops/poisson_ops.h,sha256=OY8NrkheLAAMNQOtSn3xS5ignCECAwvNyakl8CRQ2YI,1870 +torch/include/ATen/ops/polar.h,sha256=89KDwP0NtDFIGBehReg1kc3tdcoLqQyYJ8I-ab0rs1k,1137 +torch/include/ATen/ops/polar_compositeexplicitautograd_dispatch.h,sha256=63Ox2FepgsSZGwAawSnrPlaH1nEQTMtBTpAqr2jp9Xs,788 +torch/include/ATen/ops/polar_cpu_dispatch.h,sha256=Hi3FYfTFa594PdJqZ_sCnyvcb2ih16bPTEk_VNjBWqk,871 +torch/include/ATen/ops/polar_cuda_dispatch.h,sha256=9OVYb0efmcOF7CGqsy_FZuyciMVwUAixJxU47bG81E0,873 +torch/include/ATen/ops/polar_native.h,sha256=Ujs0pXFH6h5BXR46tjamb2H_XmYzaCAzcI03lBZJN9w,613 +torch/include/ATen/ops/polar_ops.h,sha256=wIjAEuscdl__duBUitC0YyxuiklbojwWIWWRdhlzWRw,1750 +torch/include/ATen/ops/polygamma.h,sha256=aNr2PPySN2EB_TEOS3xe8vhyPnf6xE3_qrToXLXsPxw,1108 +torch/include/ATen/ops/polygamma_compositeexplicitautograd_dispatch.h,sha256=ASsPSw-zfYpT8PQJKUnnvPOEPvfjv0MK1OzTLYIr3ME,775 +torch/include/ATen/ops/polygamma_compositeexplicitautogradnonfunctional_dispatch.h,sha256=n1z83T4C-YPI2lWZLG_piOySec1DdPPhaCu3r9_BO2g,804 +torch/include/ATen/ops/polygamma_cpu_dispatch.h,sha256=LGTvcKphVkyna4BvZbWC-kuBS_iF2-ToySj08uKWr3Q,919 +torch/include/ATen/ops/polygamma_cuda_dispatch.h,sha256=MPsys_kw-m2u9VnJhu-rU4YTkA3eYoIUMNrr29FglYY,921 +torch/include/ATen/ops/polygamma_meta.h,sha256=9uIt0c4xgfC7S2_mpAbHqXkC7YwMY_eq209HjP2_Doc,600 +torch/include/ATen/ops/polygamma_meta_dispatch.h,sha256=3JVEP9XNDBNhwIH6dLGs47YbN5tkBkudjoqDInPrRxU,921 +torch/include/ATen/ops/polygamma_native.h,sha256=cwxuFpCuzT2OpPrbMGDE4NhM94aqbUFlhuRlQeeZ0cE,692 +torch/include/ATen/ops/polygamma_ops.h,sha256=frdUASk6J-ZyZdaiHG8G-EKrCu1-sLBJFiQADWZBR6Y,2263 +torch/include/ATen/ops/positive.h,sha256=DPY2F_tB_NmTdCywtCd6HY5xiAovPHEaorLCKbqHAOA,639 +torch/include/ATen/ops/positive_compositeimplicitautograd_dispatch.h,sha256=WBfoIVm0ikbK7jTxuwyaIIp6dgjxkHQs7DaueD2gshE,766 +torch/include/ATen/ops/positive_native.h,sha256=0Z7xuOlZe913TVT4Hubd-dEhwWf3E-rL2KLpzdifvsI,489 +torch/include/ATen/ops/positive_ops.h,sha256=QOYEd5JNnxuGcWGfMijZK8BbP-HuBWIH0FjvOo_cfyQ,979 +torch/include/ATen/ops/pow.h,sha256=0ubBgoMJkxKG__9NWpkswDtatPC5jlLSeEvhrXRYQaI,2695 +torch/include/ATen/ops/pow_compositeexplicitautogradnonfunctional_dispatch.h,sha256=JPxA_SlRKjv2a00yRoSSTDfQ0ZWgOpga2IgPfZbjhB4,1130 +torch/include/ATen/ops/pow_cpu_dispatch.h,sha256=chd2P9T6nZ32HKiEwa3Q8gdqXNYMuBEs8tehRt_Dh7g,1687 +torch/include/ATen/ops/pow_cuda_dispatch.h,sha256=9wRa2C-ltM77NCSAgchGBl07oBXPnEERms3hj2Mc7Ss,1689 +torch/include/ATen/ops/pow_meta.h,sha256=YgsHXLgWJ1xGcAmlv879-Ae_IvQs-xyoTc8Wq8gEBZc,935 +torch/include/ATen/ops/pow_meta_dispatch.h,sha256=qdZqUESwksiWvJPwZ1DmvRZQuUmZbl059u5bmS16pOI,1689 +torch/include/ATen/ops/pow_native.h,sha256=AT0Z3WNyxVIHwCEZh0ZLEp3gTAnjRbgGwmnp8r_GJ7A,1237 +torch/include/ATen/ops/pow_ops.h,sha256=3g8V_t_egj5CKHj6K-mFyG68Mu8mvIN0Qop-8rIFPSQ,5901 +torch/include/ATen/ops/prelu.h,sha256=TsbpoXk3a1tedMr3i8BNrNCUHDg1Q0TlrHN-JRG7LY4,671 +torch/include/ATen/ops/prelu_compositeimplicitautograd_dispatch.h,sha256=DHiEZxoXkNYDxzuO5hTycax7fG_Y533mk3Gos-Vrmbg,790 +torch/include/ATen/ops/prelu_native.h,sha256=5rWCHOBi2piCpykojvBchURNi8vqlA4iGfL-e_jzR2E,513 +torch/include/ATen/ops/prelu_ops.h,sha256=UKGuljOYQo1vi7zXIY42KuaIdfgQuHALEFSm9t_lZGo,1053 +torch/include/ATen/ops/prod.h,sha256=x_6OuQ_vc1KwzpHmOKjjGJOTJtzLq8WT1hmOC2tIamk,3264 +torch/include/ATen/ops/prod_compositeexplicitautograd_dispatch.h,sha256=RndJYHr7TNK6_fPRbqpVd-HYze4f0XOL-TFe1bRyjP4,950 +torch/include/ATen/ops/prod_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XHU1t3sIhnveEmULuefmRwYYUlJRPcdzmp8dihw6VPA,871 +torch/include/ATen/ops/prod_compositeimplicitautograd_dispatch.h,sha256=I5GSEpiugMXtpa2lCZxiTQ4dsIBPUFo9Obm4ACmvUgQ,1157 +torch/include/ATen/ops/prod_cpu_dispatch.h,sha256=dUUWh7XAx0kqNA56s3fM3ZT3WtEVNHQIAVLRi2cvXjs,1203 +torch/include/ATen/ops/prod_cuda_dispatch.h,sha256=hVzoaCiVVgZr3n2NYqxOmjc6oELdSG9eVp-GnXJNGgc,1205 +torch/include/ATen/ops/prod_meta.h,sha256=tsNCC6XPjHr-X1U1Ql90qgXAJcWDFBNm2191BWAmoVo,656 +torch/include/ATen/ops/prod_meta_dispatch.h,sha256=Cm70wLCP05_Ykl2e38GIwOsOxwp-0TAA-qccruKLkKo,1103 +torch/include/ATen/ops/prod_native.h,sha256=HefCQGyjlJ_4aO2ZxFDe1Evozb48EILRa8djRtr5vN4,1171 +torch/include/ATen/ops/prod_ops.h,sha256=p_FkJ2f2s9NBvQlecHu9BrEDCwkKyh5GIkjnsegwRQw,5167 +torch/include/ATen/ops/promote_types.h,sha256=PBmPBFIutFemxFOeJqzFV6jD9LbmRaAidYnMYL8ddHE,711 +torch/include/ATen/ops/promote_types_compositeimplicitautograd_dispatch.h,sha256=PXydHUCkUBtxwqqijy44jDt3ON4oHNWn46NmYrto8Vc,794 +torch/include/ATen/ops/promote_types_native.h,sha256=UoXEdVmVWNwNQ3ZZ6_2EkTEQcQR-MIr4DSRmbUzQt3M,517 +torch/include/ATen/ops/promote_types_ops.h,sha256=xrMb3PGNArw2UWdzt-rJErJibmT1lNNEzfvUNVdSaPI,1077 +torch/include/ATen/ops/put.h,sha256=77AiW9GfVnc_VYivaaFU9AqyuyoxrsSJZWtric1FBoc,1444 +torch/include/ATen/ops/put_compositeexplicitautograd_dispatch.h,sha256=l_DGfdycUKgZmXB8dpRWMDuxdT_D5SbzcRmFYE-hwxw,1134 +torch/include/ATen/ops/put_cpu_dispatch.h,sha256=4w1kldOr0MjApINC2y1DTQKALWKSfnDGX3tRAfhZT7M,790 +torch/include/ATen/ops/put_cuda_dispatch.h,sha256=tO-ABuc3BLcp3EqlSCNDFWFnmnMw4czDZV1opfZlGtQ,792 +torch/include/ATen/ops/put_meta_dispatch.h,sha256=lDUgR5LgSZNlJfh8fguKabnS806cl8m5aMUWhhJcCqc,792 +torch/include/ATen/ops/put_native.h,sha256=g3Ui7u9MfEUQOhc_zIKL9OsTPvmjgoVY1indqMeTV6I,829 +torch/include/ATen/ops/put_ops.h,sha256=rsuj47IP6n5jj_hiyOOvE0WHBe5cHp7g_QrBSzuAqXU,2809 +torch/include/ATen/ops/q_per_channel_axis.h,sha256=Mrx7GR076FT7QFXHBzB6u0_FBL5aaQ0Mzy6Z2NHuT6I,667 +torch/include/ATen/ops/q_per_channel_axis_native.h,sha256=MmuKHucG7nsaAzFyZmwsax7e36722XqBHC_Cat467Z8,496 +torch/include/ATen/ops/q_per_channel_axis_ops.h,sha256=owMMXDT6kKAtDzprj67BLgOu3SAVbzTYEbFDr8atRac,991 +torch/include/ATen/ops/q_per_channel_scales.h,sha256=JCRDs73IZ0cuJ86oomULEOEnjYXc2eiS_2i96B_i2r0,1155 +torch/include/ATen/ops/q_per_channel_scales_compositeexplicitautograd_dispatch.h,sha256=BdNy2NLW_IbfCFGdVTgfHs0DoPyvBCpTG8Y-we51VN0,895 +torch/include/ATen/ops/q_per_channel_scales_native.h,sha256=vxRmYiVpfirFqQ7i88_l70_RyImchpr5krSW7rBs2rA,593 +torch/include/ATen/ops/q_per_channel_scales_ops.h,sha256=JHJtC7-FGhcKP0OPmc2EUyLYwZH-QlUsTQUUyiN90HQ,1674 +torch/include/ATen/ops/q_per_channel_zero_points.h,sha256=EWRqHJnslACyKkXgZEaL92ysZtp2TLHOxdA6LnktIWQ,1205 +torch/include/ATen/ops/q_per_channel_zero_points_compositeexplicitautograd_dispatch.h,sha256=zyI61O2nyKl0qwm8xCWSLW-f43wbuolZhFGWwP8ZEOY,905 +torch/include/ATen/ops/q_per_channel_zero_points_native.h,sha256=fK97xD8upHoTOz7nwl3y4BaMxeJc8GU2UAIum8cKMqE,603 +torch/include/ATen/ops/q_per_channel_zero_points_ops.h,sha256=yo8odfnwtz6Ei7Oy0KsLdTnblWiWvcy2azwINZyWlDE,1704 +torch/include/ATen/ops/q_scale.h,sha256=nSySnIIIBQsKYOlfiWue3UaB5bJ9N2B_i3i1ht0qYWQ,624 +torch/include/ATen/ops/q_scale_native.h,sha256=uWJBYOI7C_-JFbN181X2WdQLGE_Qdf7wbDpjMuZ82CI,490 +torch/include/ATen/ops/q_scale_ops.h,sha256=L-sXz8Q00PTN1kJUP673OlU9uoqRa9hHMJ3hRH3Vqxg,957 +torch/include/ATen/ops/q_zero_point.h,sha256=9EUVhJIguEeh8U8z3j6-o93XZedcWjF_cE53AYvxIug,643 +torch/include/ATen/ops/q_zero_point_native.h,sha256=w6SctW6CXeoydhZvUJv9WDpDTVXIiO9BA2Mmtnb9R0Q,496 +torch/include/ATen/ops/q_zero_point_ops.h,sha256=u9qk8NMb6XABWxBJmPU8ssGaNY7I3xQS3M1GVlHDN_E,973 +torch/include/ATen/ops/qr.h,sha256=ofZ53HuG_W8k2rWAzi9MMc6FMV8KTrCZfKDkLXnTU9w,1259 +torch/include/ATen/ops/qr_compositeimplicitautograd_dispatch.h,sha256=_HiiHYUpG2P_4m5PgJQoKRjKXlhj5zint8T9Dw-pyDY,1059 +torch/include/ATen/ops/qr_native.h,sha256=kEif-d-GQX7tcHNBlL6T8X_nn72W3HXO12BN0BKZWHY,650 +torch/include/ATen/ops/qr_ops.h,sha256=gfm5ZyMMMkFdDkgFXFXHPDA7Jpjg78FfBE18UBcsxSc,1890 +torch/include/ATen/ops/qscheme.h,sha256=rvLFYq37tPawyjesyylyASKbJx_fF40QA3tGU9UV6Pc,492 +torch/include/ATen/ops/qscheme_native.h,sha256=PYx9WRBf7qYtQs6f3_2VP6Uq1iIElmF9ARv21uWdJrw,495 +torch/include/ATen/ops/qscheme_ops.h,sha256=OI093FcA0gtkJcUSM52gBH3GgP3T9QKGn2kwUR4oIrs,974 +torch/include/ATen/ops/quantile.h,sha256=n4iqUEdy8dzzZqRWYopO9My67JuZjNAv64S1iJ32Pis,2905 +torch/include/ATen/ops/quantile_compositeimplicitautograd_dispatch.h,sha256=p__kKkizh3G5Rq7iMSHOV-i4LPhTvUzMPjjiYDx5HV0,1796 +torch/include/ATen/ops/quantile_native.h,sha256=evAKUxKbVaFF8xtSpYCfXIAzv9YYN3kYN2iAe3Jl5cc,1121 +torch/include/ATen/ops/quantile_ops.h,sha256=eDLxbXu_6Dfwj5J1FsOR2kFRfzZAPBbOdJ28N95suMY,4075 +torch/include/ATen/ops/quantize_per_channel.h,sha256=T7upjvKQW-sER52F5wuj75ZLHIydJmUvKeoMSNybuNw,1731 +torch/include/ATen/ops/quantize_per_channel_compositeexplicitautograd_dispatch.h,sha256=ickXjBuswE9V6JsJxytriK8dIwcmVSB_9xIm4fsYWVo,1085 +torch/include/ATen/ops/quantize_per_channel_cpu_dispatch.h,sha256=NaFKeju7p7cM_QrueHErPKxLyxqDHLEKBAdoB-RxWSU,829 +torch/include/ATen/ops/quantize_per_channel_cuda_dispatch.h,sha256=JIBPdR5Uc1MVf0MfcsdrjtPmQPNe51Yf8gfjGUNP8t4,831 +torch/include/ATen/ops/quantize_per_channel_native.h,sha256=MBxqqwmGjJnCKA3hNJvjC5DBAi9lNqUWLTMFsmF0WW0,783 +torch/include/ATen/ops/quantize_per_channel_ops.h,sha256=9qWyZZTYBQgb1wyZzqHFhb46fwzi5pixEbeyHv5YDlU,2310 +torch/include/ATen/ops/quantize_per_tensor.h,sha256=9GuK06e80qrUCPVUQO_R0e33XPvxDBNs_IduOs1IxBI,3922 +torch/include/ATen/ops/quantize_per_tensor_compositeexplicitautograd_dispatch.h,sha256=34H0NkvyD9s6dCwKQq2jiYB0XdkKWm33xFAaVYmiV6s,1677 +torch/include/ATen/ops/quantize_per_tensor_cpu_dispatch.h,sha256=QdydgcSmRkv_QespwhuE_vrXSRS-fnfVeKeIdsbTkuY,1097 +torch/include/ATen/ops/quantize_per_tensor_cuda_dispatch.h,sha256=UsMtktdrp4usMxFc-Ow1sMAmftneuH463NbGL6-8C2k,937 +torch/include/ATen/ops/quantize_per_tensor_dynamic.h,sha256=_16_CQh_nXxdLW546u3-KW6pCkiGwLfXimBHk3hpZGQ,1522 +torch/include/ATen/ops/quantize_per_tensor_dynamic_compositeexplicitautograd_dispatch.h,sha256=ZYH0mlVOHbiGw-yaWCD6t1m3-4VAjXTN2ruaMlMEz5I,991 +torch/include/ATen/ops/quantize_per_tensor_dynamic_cpu_dispatch.h,sha256=1eJnnQqid2OO88F2-eDS4MYR-WkvOnHRAFp7hAiWk1I,782 +torch/include/ATen/ops/quantize_per_tensor_dynamic_cuda_dispatch.h,sha256=-7hnghli2hQCNRS_ZQ85qAkgLBNFFb3bMXVKwfmeiMI,784 +torch/include/ATen/ops/quantize_per_tensor_dynamic_native.h,sha256=yeUNjeFdOYBjo5jrrCoWbai4BW-j-qI5DgzK_YHCDxA,689 +torch/include/ATen/ops/quantize_per_tensor_dynamic_ops.h,sha256=M7rDTT19KxpuT91-xBQrYKX9n3Xt7-PlWxgxHexb0yQ,1998 +torch/include/ATen/ops/quantize_per_tensor_native.h,sha256=CAbvNmK4QCJRBsX25_yi2Ie9JB37xgDsYhmmey3-Ef8,1393 +torch/include/ATen/ops/quantize_per_tensor_ops.h,sha256=AZPzabwZFGwgQpf2-qLNi9GAnxq1nG5suzNtwvmVndI,5749 +torch/include/ATen/ops/quantized_batch_norm.h,sha256=E2dBZllNAV1onCqSYGAwFUJgE-gPm_A3bAROoDlzIxY,2253 +torch/include/ATen/ops/quantized_batch_norm_compositeexplicitautograd_dispatch.h,sha256=CY-197vRMz9OqxpOTMEJj5ZVgyeDpNy8UHv1xcUqAqg,1279 +torch/include/ATen/ops/quantized_batch_norm_native.h,sha256=zM1-TZfBsKtpltw4CMLLbDaTLbKAVP6CaGFcWHP9eqk,977 +torch/include/ATen/ops/quantized_batch_norm_ops.h,sha256=Nzzp8ZoulfHLCmzPN0zA9ycjg_rD_oZrVc3oNmpw2fw,2932 +torch/include/ATen/ops/quantized_gru_cell.h,sha256=sWm42nFyVwp-1KuMjzcC2_D8WwTEF5DkJRwo6odomk4,1410 +torch/include/ATen/ops/quantized_gru_cell_compositeimplicitautograd_dispatch.h,sha256=mye9ElBjpdgd6Utk2WKGA8JdetNzbrgjRAGA12Jxv4M,1156 +torch/include/ATen/ops/quantized_gru_cell_native.h,sha256=o0D9wgMO_F5zW1gaF9CXO1eMDAUhYje5lcrSmUsP9zw,879 +torch/include/ATen/ops/quantized_gru_cell_ops.h,sha256=4eduLwKeUYz_482sFPbmKQcHdEkA3P_FaMfIyRCmhns,2247 +torch/include/ATen/ops/quantized_lstm_cell.h,sha256=1OxmNLoHRuRggjKm6wePnCZ3G7KKUI87eFlGztUfr2U,1447 +torch/include/ATen/ops/quantized_lstm_cell_compositeimplicitautograd_dispatch.h,sha256=CHd94WfD-LLTc15yqjg8dg90n2DTA2ah_Sk-jCMj4Lw,1178 +torch/include/ATen/ops/quantized_lstm_cell_native.h,sha256=RFKEekTB2WI-psKcTPs2A1Xo-HogZA6WCZofIYjIUZQ,901 +torch/include/ATen/ops/quantized_lstm_cell_ops.h,sha256=VaDEw0u5PyqJUKf-5UnW0sl94AWrRrY9ASSBQXNahiA,2325 +torch/include/ATen/ops/quantized_max_pool1d.h,sha256=2pznUUFS0myFrIZGz_zlwk6P54MedivEUiQcNzjReYs,1985 +torch/include/ATen/ops/quantized_max_pool1d_compositeexplicitautograd_dispatch.h,sha256=nTpmlgbJPKzjSKB7TzdnAbX8fP4ozzrZfxz2tQ5GNLs,1148 +torch/include/ATen/ops/quantized_max_pool1d_native.h,sha256=Y_v1jJ_pXOQuXqh9QXG1ChHxqU7dE4T5IKeLAVwvQm4,846 +torch/include/ATen/ops/quantized_max_pool1d_ops.h,sha256=PgdH6ZrXeCIHEBTICy8Fa6Phms58O3nPdY4m9jvf66g,2496 +torch/include/ATen/ops/quantized_max_pool2d.h,sha256=LeY5xA3a6BmhmktykwreuWUIOw-_2svFLva3QhPWjIk,1985 +torch/include/ATen/ops/quantized_max_pool2d_compositeexplicitautograd_dispatch.h,sha256=_mAEwP7G_qANjqlEsnm_cHcW9OrEv9tKx4_Pr3OGjZA,1148 +torch/include/ATen/ops/quantized_max_pool2d_native.h,sha256=mE8nls_NdBrUeCW75dxyf0tNNOiGeQg0b1m9brI4Bx4,1053 +torch/include/ATen/ops/quantized_max_pool2d_ops.h,sha256=P91dAE-kITQy9TDQqf0SMIc2Gnj58Hym-zrLZ6Xw9L4,2496 +torch/include/ATen/ops/quantized_max_pool3d.h,sha256=jm7CD0esIs8Yk7GRYpPXCv-56zJLm-QngwwCSfv65pc,1985 +torch/include/ATen/ops/quantized_max_pool3d_compositeexplicitautograd_dispatch.h,sha256=Ah4TkNI_CfYqSXg7NFT_JOgS5mW3XQxy_CwmZ4HBXEE,1148 +torch/include/ATen/ops/quantized_max_pool3d_native.h,sha256=PL-_xVdcglTvjuU0oeQbq5nG-KiWt0e5aGzzVLn6bBE,846 +torch/include/ATen/ops/quantized_max_pool3d_ops.h,sha256=TUjS0fibXUHRk5ViSXIodazh7n8sMxzF0_TvssspN_w,2496 +torch/include/ATen/ops/quantized_rnn_relu_cell.h,sha256=yc985eYjCO74Ze49FKFvHjNZaI0mGzo12EpiQPNLwJA,1430 +torch/include/ATen/ops/quantized_rnn_relu_cell_compositeimplicitautograd_dispatch.h,sha256=_NTM5Jv2skraZVsgLwRmYOXHo0HdGdQLdSo5fmFHr2Y,1161 +torch/include/ATen/ops/quantized_rnn_relu_cell_native.h,sha256=oD6PcEuguPw7G63wK-_dAcFU7o2VxEdq8iZ224kUGfs,884 +torch/include/ATen/ops/quantized_rnn_relu_cell_ops.h,sha256=Fvik37AemYR03T5F7Wvw0r6yPsV8u7HkBY5nTQFVtV8,2262 +torch/include/ATen/ops/quantized_rnn_tanh_cell.h,sha256=X5lB-uOn7Q-S6G3weEczhPbQXUnNjns3gfuNTIYqp5I,1430 +torch/include/ATen/ops/quantized_rnn_tanh_cell_compositeimplicitautograd_dispatch.h,sha256=hdXVManL2nYQGh-VksacdcyqKPGjaFuUZOYPX2vbkN4,1161 +torch/include/ATen/ops/quantized_rnn_tanh_cell_native.h,sha256=LD1riOoaFvY_GVSJTMcutsyn6dlNmDQAhl6S2b8CN5Y,884 +torch/include/ATen/ops/quantized_rnn_tanh_cell_ops.h,sha256=FStdBWGSBfrZvBgIHIFPLW7Cvfa_0HuZnRKKunQ94K8,2262 +torch/include/ATen/ops/rad2deg.h,sha256=jxNJT4e4HM5TbeFu3O_xJyit8quIRtsD2-oAjHbTV4s,1170 +torch/include/ATen/ops/rad2deg_compositeexplicitautograd_dispatch.h,sha256=rP60qflK5pdHdkhb17SLZSnBZb9bEXGr5_XPgc2Ix-g,976 +torch/include/ATen/ops/rad2deg_native.h,sha256=JaVKPAW4rOG1R1tH7Rn7_C4ypyGps-Mpn_nvt2bdbPs,1045 +torch/include/ATen/ops/rad2deg_ops.h,sha256=AKth119jXGDhdmxNEQAPGd-Jsn85zK_Pm6nN4RkELH4,2131 +torch/include/ATen/ops/rand.h,sha256=irERDcVL7B5g8353md79hMqgiThpBV_x5wtj0NP-LGE,24656 +torch/include/ATen/ops/rand_compositeexplicitautograd_dispatch.h,sha256=aoImpZxt-6cM7_CdQJfe27yvAgSumS-yLLbleiNXyJs,4954 +torch/include/ATen/ops/rand_compositeimplicitautograd_dispatch.h,sha256=HR285QEXXCRoQ9j2zfZQPdQw-YvoxFYdsRlVYlXCG4s,1186 +torch/include/ATen/ops/rand_like.h,sha256=IANBfBk0GHoRnXtPVDqHa_rJHa8wzjguMcuR1R9vLlA,2176 +torch/include/ATen/ops/rand_like_compositeexplicitautograd_dispatch.h,sha256=TbVFNgNrqYAgRswjulgqWwLqGU7o3PWn2VPw0GLsVY0,1368 +torch/include/ATen/ops/rand_like_native.h,sha256=0XtrruIGSVVbcFSYAG_THHUv-Acmc6knrJ8EJ6ryfTw,827 +torch/include/ATen/ops/rand_like_ops.h,sha256=h0sh5pqr3MfhlssJnEZ_7FM8SidpPjYxrLrLMPdmIOk,2402 +torch/include/ATen/ops/rand_native.h,sha256=d3ljyQFJi5npsz-K6r9v4yCIZ2EFuWxofFvhBEt8xlo,1878 +torch/include/ATen/ops/rand_ops.h,sha256=4GdXRhtUNKYFEj-PEZRBHdOZIUHSy64v6UEOHCOz2_I,8189 +torch/include/ATen/ops/randint.h,sha256=BWpGVlK3OwZjp8lN9tVpJkzIFJQp8kHxKVXBUJjvBgg,25963 +torch/include/ATen/ops/randint_compositeexplicitautograd_dispatch.h,sha256=THawTUcKaDVa0BkBx8V57_J-uybF3IftPK3Z4FELf3w,5726 +torch/include/ATen/ops/randint_like.h,sha256=0pRhKOzA-PtfMyM9Q6KsXwiXYU8LGxv0TWNP8cSwHrs,15352 +torch/include/ATen/ops/randint_like_compositeexplicitautograd_dispatch.h,sha256=NtStNz2kMedJ_5c9bOLkrTRhN26VMarkdV_-_v9Dd9A,3822 +torch/include/ATen/ops/randint_like_native.h,sha256=y54cEwgXjWvp_BgHpZ2Ddh1NUbOVexqt2EhA8omx8uI,1351 +torch/include/ATen/ops/randint_like_ops.h,sha256=CgMqn5Sd7WVJODKKeUlCXO09YC-mHuGRhR97cW-lEtU,4831 +torch/include/ATen/ops/randint_native.h,sha256=Z1ohQVBSqEIKylnM7sBhIjT0k3XLEtoe6I1GmKu2Jzo,1865 +torch/include/ATen/ops/randint_ops.h,sha256=yTRqkCcV5qzf7UCWmIkskw9WlDjReFR-EQZo1ZZCKjc,8435 +torch/include/ATen/ops/randn.h,sha256=XynLQPHoANclCWm_ZUz5V4wWW430eXZV_3P2nVAIG0E,24817 +torch/include/ATen/ops/randn_compositeexplicitautograd_dispatch.h,sha256=MI6MBfKcHMeZ4HKVjXYeZycpg9SRUR2QR2t8LqyN0TA,4662 +torch/include/ATen/ops/randn_compositeimplicitautograd_dispatch.h,sha256=AUf8QX2h7xkjv-Obdiq9tRWn1eyuX_JDQuj0Pwnzwws,1510 +torch/include/ATen/ops/randn_like.h,sha256=_-51na_57i2Ud840NMolzXWwwAYdaof9Fp1kfkv8z1E,2189 +torch/include/ATen/ops/randn_like_compositeexplicitautograd_dispatch.h,sha256=-XvmoGunk1Ya66RfDcB58rIUjjyBVZ_spuEfWnjY0H0,1372 +torch/include/ATen/ops/randn_like_compositeimplicitautogradnestedtensor_dispatch.h,sha256=eHLHbc_UokO1e_Y9JX5UB8QdbDuxIZwXqFFF0TO5rTQ,1124 +torch/include/ATen/ops/randn_like_native.h,sha256=JAlnTrF3WcWJoOgQJ9xcwV81P_C3YVzw7hTeHy6bBTo,829 +torch/include/ATen/ops/randn_like_ops.h,sha256=DHMQB5Tp1HNBIRfLYCBpa5U1d7Hcz4W2jEB6KelolSU,2408 +torch/include/ATen/ops/randn_native.h,sha256=Zse2pOwvw6PF_XmQw02A0Im3ldx4eRYGsptvKJ3yiYc,1886 +torch/include/ATen/ops/randn_ops.h,sha256=EORW5OC0YWr0Y58Mcyi_M5pTGRowLDiEhnIrcEPwixY,8213 +torch/include/ATen/ops/random.h,sha256=1M9pZw_RkyT7zYqKz5eA4JPXBWv4R0TVohZSUZpUfZc,3184 +torch/include/ATen/ops/random_compositeexplicitautograd_dispatch.h,sha256=hcIBZwJQgmYLMJ3waAm9x9VcQgQtEfH9rqBdBWV32Hs,1940 +torch/include/ATen/ops/random_cpu_dispatch.h,sha256=8AYQYnOgsEyfAALxGlny6hsri0Cqtn2-zwgCRaKBptE,1031 +torch/include/ATen/ops/random_cuda_dispatch.h,sha256=SQPwcDSuESv3fTKvTE6g0xcqpzyY2MHiGEkyybdag4E,1033 +torch/include/ATen/ops/random_meta_dispatch.h,sha256=H67WyIhvzvABOxxkvDdcz4K_Kgf4YuB0Lio7lUN49fw,1033 +torch/include/ATen/ops/random_native.h,sha256=i5nogNhA2gIwE9aRmI528Ww9wgc36y-wRmWbOQ6Bn8A,1967 +torch/include/ATen/ops/random_ops.h,sha256=f11MbJQ7thke0E7o5vqSEewsqQp7fy2-LdwgarYe9_I,7342 +torch/include/ATen/ops/randperm.h,sha256=K5XNKI4CCrzXFuut34Lvrvah6zIvzHD3rByXd9LTm_I,10940 +torch/include/ATen/ops/randperm_compositeexplicitautograd_dispatch.h,sha256=vKQgk6uI9EU4r2VTDy6polTC6wruhxdctHp-ISgUXf8,2234 +torch/include/ATen/ops/randperm_cpu_dispatch.h,sha256=s8ks_QAkEE8LPgdlZuftgndrmQ8pISD-9wSahXBh3qE,1114 +torch/include/ATen/ops/randperm_cuda_dispatch.h,sha256=9LM6-eouCmUBgcldfTy_118LjJWfFFCA7XaxlbGT9VA,1116 +torch/include/ATen/ops/randperm_native.h,sha256=cBlCjm_7PlUxje06Q7nRkBEXeqgmY6pTNz31EZs2z2Y,1142 +torch/include/ATen/ops/randperm_ops.h,sha256=w6sVOsmYsZYz-DnNdpTKNhqCTM3T_iNCJ_5fXIvztQg,3917 +torch/include/ATen/ops/range.h,sha256=ezD8PRDzmjy4IszsI5EOEh0KhPtRZG3v0vuBYtlnnTc,3365 +torch/include/ATen/ops/range_compositeexplicitautograd_dispatch.h,sha256=5hLZ769r04kzV8N10DZReT0NyhquCOjW0VdjNI9y-1E,1613 +torch/include/ATen/ops/range_cpu_dispatch.h,sha256=-1-AMk7WfA1bS1JkZQir3cRFV9O-KyvXZ7CZqNyV-_E,921 +torch/include/ATen/ops/range_cuda_dispatch.h,sha256=gd8fhCREoZUKnkfzzy9bhrkAsw9FGBfv3jpaY2AFcU8,923 +torch/include/ATen/ops/range_meta_dispatch.h,sha256=ZfGyV-T6liGMdi1Z1IBqmzbUS_EKLhIjGWl03akaXO8,923 +torch/include/ATen/ops/range_native.h,sha256=i_clcMV9PRDJwkOtFPMgHdbuqOzV21lCtJw5m-EfB9Q,1283 +torch/include/ATen/ops/range_ops.h,sha256=GoWnMMw0U0qiE2Z7QR7-66HLuctC_RlIUrWfuILJ_LM,4197 +torch/include/ATen/ops/ravel.h,sha256=H5vq7fq5VC9s-r1fL828aIgGwm6PzuRP7NyFb3Ufk88,627 +torch/include/ATen/ops/ravel_compositeimplicitautograd_dispatch.h,sha256=y34AGJ-fC0ir8cxN9PK5iRh3NEVBVyFQpfdj3W1KmCY,763 +torch/include/ATen/ops/ravel_native.h,sha256=ObLL8hhn4LoCbl_D8DJeywyQ5u8j_bOkzKUGDzmGexE,486 +torch/include/ATen/ops/ravel_ops.h,sha256=GEJQStdOtidOMcd0RFKTpQN0lAW0q0X_o_V8_PhLbHs,970 +torch/include/ATen/ops/real.h,sha256=O0VLCesFTxfn5fVSSGCo-hKjdwTLGbbdluuTK_vB0aw,623 +torch/include/ATen/ops/real_compositeimplicitautograd_dispatch.h,sha256=6YNWDH2lAMTG3q3-6sMk-oGOjw_JJKHVoJB2_3UYkfc,762 +torch/include/ATen/ops/real_native.h,sha256=thhSnDY9FEgg2wNLKivxGFGjqCKK8Ya1r0wZSyU5nEA,485 +torch/include/ATen/ops/real_ops.h,sha256=7TNm3m7hKJdFCaTyg5zyUKrOlArw9ktTyFZy1_ZJxuY,967 +torch/include/ATen/ops/reciprocal.h,sha256=clxXczkmG9l_pIAfscv0v7a0k8UVv6vrcV65zYn-ji0,1209 +torch/include/ATen/ops/reciprocal_compositeexplicitautogradnonfunctional_dispatch.h,sha256=J_4RQFUT9KSGXNEDQkJiwN0dTGpeA0Zk6MignB34bTM,849 +torch/include/ATen/ops/reciprocal_cpu_dispatch.h,sha256=dDhXsZ1vOEoOMKD2kbBrBP6OM6QZxFlq5Xxt26h0Dgg,944 +torch/include/ATen/ops/reciprocal_cuda_dispatch.h,sha256=dYwm58iVZsm0GZvrj7v1O7wd9fo7sQb7wg4zuw7BdI8,946 +torch/include/ATen/ops/reciprocal_meta.h,sha256=iY-88cd4Yon00eDn8H_seJpPnmOwhUfPXW1dZ9s0qug,590 +torch/include/ATen/ops/reciprocal_meta_dispatch.h,sha256=tPwqi_RTl-9qeA9HsJoMQp87fRPKA_tpD2AhbCLAZlU,946 +torch/include/ATen/ops/reciprocal_native.h,sha256=WYT8FAIFiuvAddZAMoZn-QJqfoyTExyCg8o_S_VO2Pk,619 +torch/include/ATen/ops/reciprocal_ops.h,sha256=u73LNWR5VoiOOR7gjlKJnGYr_kSg5sfvFkPn5vbBFcQ,2158 +torch/include/ATen/ops/record_stream.h,sha256=Au8Ke7RnxxLZQ1-h1Fx681-c7LD1XyWcIq2X3AUYGvM,498 +torch/include/ATen/ops/record_stream_cuda_dispatch.h,sha256=GPazjuR-Wmnn4PUBOcIDw-vdf5P7Eq9eqL5vCR1K7Rk,731 +torch/include/ATen/ops/record_stream_native.h,sha256=Jqu0o7Odc7auf0HUlykdM6LZ3Eu9rbvz1DXJC2kP5Dw,501 +torch/include/ATen/ops/record_stream_ops.h,sha256=Gh27W0SQZd5rLdx2D5oVsUlXXzIt5grKS_7Gjv_8hok,1002 +torch/include/ATen/ops/refine_names.h,sha256=2dZftYjxZ2TOPIRRqX_GPtwXX6u1vsSF3wxhRgDyXPc,497 +torch/include/ATen/ops/refine_names_compositeimplicitautograd_dispatch.h,sha256=8H9ZnsGXJhB9doMZPEOxAMQ8SvcKB-Ka58LeGL-S63U,793 +torch/include/ATen/ops/refine_names_native.h,sha256=Gck-irvqOyotZ9ma2s1KIuoCm3ufP9oMaxW8DXpV9Ts,516 +torch/include/ATen/ops/refine_names_ops.h,sha256=O2Q2ik7Bm8LOH3--P8gRk6KefNveJWxdoW_CGk8_Ks4,1071 +torch/include/ATen/ops/reflection_pad1d.h,sha256=OBeNExdUHroPlQ5R6nZMt_g0d-A5DA7yVaC_Ebpf7Lk,3915 +torch/include/ATen/ops/reflection_pad1d_backward.h,sha256=pSbd9NVLVzx5OVH-thVUWbXu-MupQGpvXUNRG_KlRZU,5078 +torch/include/ATen/ops/reflection_pad1d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=95aWO_HH8E3qaTZ7MJDPkeYHINT4hQw8M1A3o5J4Pqw,1007 +torch/include/ATen/ops/reflection_pad1d_backward_cpu_dispatch.h,sha256=AEFqDUiMaM2qny8f9ZDyJ4B92irNj7oSVLjQdswsb90,1605 +torch/include/ATen/ops/reflection_pad1d_backward_cuda_dispatch.h,sha256=XJxhGgNrK7Ea3sjjUbObaOE0JfGBavX2-YIdWmky778,1607 +torch/include/ATen/ops/reflection_pad1d_backward_meta.h,sha256=BI403FwsbJXc2IigC0j_S-okXTtKbN8Kxi5jvIpgGJY,668 +torch/include/ATen/ops/reflection_pad1d_backward_meta_dispatch.h,sha256=Sn2aR1y1iboVxz0C1yEMw_MEbBHgxbSmLpbH2nb2KU0,1607 +torch/include/ATen/ops/reflection_pad1d_backward_native.h,sha256=lKGVDD5QAPUg2j-_YThrKgO6PXWKc7Oty8eQ_dgpxyE,992 +torch/include/ATen/ops/reflection_pad1d_backward_ops.h,sha256=KSxmevPRjZ7Mf-USkgIODc3x0E7jA_FhMN8NVmwTieA,2150 +torch/include/ATen/ops/reflection_pad1d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=I-LHGrJ1CA0q5q1062boCYDLfbpXVJZI8UOaU6uTUiE,925 +torch/include/ATen/ops/reflection_pad1d_cpu_dispatch.h,sha256=somMZblKAyhJAOaq6vDkT4EXtAlkptnsVJTCGty63sU,1331 +torch/include/ATen/ops/reflection_pad1d_cuda_dispatch.h,sha256=qN_8bcvpwSnl5FHYHY6rvhYWH6jFwCdgE9qUZ6wouX8,1333 +torch/include/ATen/ops/reflection_pad1d_meta.h,sha256=xBKVUZj1HkD12XF1HwkUIwYnE4QEiL5pdVZvzARjCL8,627 +torch/include/ATen/ops/reflection_pad1d_meta_dispatch.h,sha256=gDk3u5d3Vpmk6aQe6RYRor9MpXf7pdOk16znJlJ_1Vs,1333 +torch/include/ATen/ops/reflection_pad1d_native.h,sha256=sqwJzy_Xd6SYo9MRyjWdl2vftpY87PwjXPlXdLj8MV0,996 +torch/include/ATen/ops/reflection_pad1d_ops.h,sha256=36Wtp5jW9BA_j0AkbCRHj8qUTPaKdgUnHQ8_ZE0Jdog,1846 +torch/include/ATen/ops/reflection_pad2d.h,sha256=BBCbMluQCIWzhpvsYpkRylbT2dZKwrwhOREYTZrYOWY,3915 +torch/include/ATen/ops/reflection_pad2d_backward.h,sha256=aW3pzyeXIVwOA_NXL4aVfhTPwg9DugRODahweJrN90A,5078 +torch/include/ATen/ops/reflection_pad2d_backward_cpu_dispatch.h,sha256=lQOD4hAqcxjNFI8cd7OiPUPiUdkVbMqxXS2uK87-zsY,1605 +torch/include/ATen/ops/reflection_pad2d_backward_cuda_dispatch.h,sha256=T0fmRINLtZQdJLuUq1d7gxcDCZLBnlMqFgI-N-9GthQ,1607 +torch/include/ATen/ops/reflection_pad2d_backward_native.h,sha256=k3BhsRINY2E2ktojJkxJ7jCQCpp90MYRIuUKjLqXY_g,1033 +torch/include/ATen/ops/reflection_pad2d_backward_ops.h,sha256=eOLZvPMrO6LMXUtIn23e5DaAp4C7j47qI82WJxsmoAM,2150 +torch/include/ATen/ops/reflection_pad2d_cpu_dispatch.h,sha256=NP32RgPsJ-Bglx5Mttvg0DtuhJ4qJObeIkGnpj6gq3g,1331 +torch/include/ATen/ops/reflection_pad2d_cuda_dispatch.h,sha256=OwmJRckbc_C6BGuQlFzanUgBjT4Fs_ennbuQbyFAI6U,1333 +torch/include/ATen/ops/reflection_pad2d_native.h,sha256=4cBVaT-A9265qBmUxkiS471PVmPnp6e8XBisbSutGwc,958 +torch/include/ATen/ops/reflection_pad2d_ops.h,sha256=XeTv5_cln_R_jYoj-9hYsR5QnxJyrST9SIYwlePuQxk,1846 +torch/include/ATen/ops/reflection_pad3d.h,sha256=9Nsltzq792X0T2pkkpxVHGkME--RArTXx1aiFQ_HTjU,3915 +torch/include/ATen/ops/reflection_pad3d_backward.h,sha256=VKvRVA0Asth0lE_HfcCQpxJC64ta9idW3mFCjh52J4Q,5078 +torch/include/ATen/ops/reflection_pad3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=4wjSityiDuFqEswI5ejk4TVRUS9RTUZbI83xfeFBz2c,1007 +torch/include/ATen/ops/reflection_pad3d_backward_cpu_dispatch.h,sha256=WmwR_afgzOhcqnw07Xtu9ytsb08mhBSltOFRWRCes8E,1605 +torch/include/ATen/ops/reflection_pad3d_backward_cuda_dispatch.h,sha256=5VlhwkxKeUXDvUvHodhC7C7xcKMq12I0Ip2-2RnqPpc,1607 +torch/include/ATen/ops/reflection_pad3d_backward_meta.h,sha256=2s4FufWwZWVzcT5o2n5Abx1BEih1BL6tPxKK5vJm054,668 +torch/include/ATen/ops/reflection_pad3d_backward_meta_dispatch.h,sha256=mcyvHJqET-Iv8htPZmEkFXnOwsk0kv_OixcfQnNJmCQ,1607 +torch/include/ATen/ops/reflection_pad3d_backward_native.h,sha256=gv_mjbdYvz1Ovxf6l404-aQFgPhXDRqdFFcJKFB1SG0,992 +torch/include/ATen/ops/reflection_pad3d_backward_ops.h,sha256=J1YTb5byFpKN-GVlBBAFgtKrwjKHfnDnoG2Z4mp2_Yk,2150 +torch/include/ATen/ops/reflection_pad3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Gnd4ekIbrfW0akHtc0zCa7BqxprbYKmxlG8zLxyEvrU,925 +torch/include/ATen/ops/reflection_pad3d_cpu_dispatch.h,sha256=Mo-T70F9YhfSvxKOJBTLq9UbEqENR4LWREQy1t5BTX0,1331 +torch/include/ATen/ops/reflection_pad3d_cuda_dispatch.h,sha256=_UMYGJoet3_HdpKw8PE-zJUYOUXjFNVuT31B3wdS7Zw,1333 +torch/include/ATen/ops/reflection_pad3d_meta.h,sha256=gGy3EvFtzJPJuxpyxX2rgb81H3_258TmOJLVFEGxgRU,627 +torch/include/ATen/ops/reflection_pad3d_meta_dispatch.h,sha256=hVEo5ZqxmmKw-r1suerYQ4HmZ-BkcO5xxTJLE_W_Xvo,1333 +torch/include/ATen/ops/reflection_pad3d_native.h,sha256=PyqUYCcVrZfMZHpPr9nUD53ZHJ77ksAs4ZessPpyvzQ,869 +torch/include/ATen/ops/reflection_pad3d_ops.h,sha256=APQ0BhY7f5cQmYfdIcssu8RYGQ0k1UAKtXcdvxILwug,1846 +torch/include/ATen/ops/relu.h,sha256=_YplI4jrDQgeo6cOIfQDZUS7nwAIt_Oc2lcuHNKtFh0,1131 +torch/include/ATen/ops/relu6.h,sha256=_0EZr1NK_weq4j4sURSjeb_PBsE2yLQ-UKqk8sn6c9Y,760 +torch/include/ATen/ops/relu6_compositeimplicitautograd_dispatch.h,sha256=mBhJc4t_xtPNb7dz4fXdXV_hppGR07QdI9CPd_l9uPU,813 +torch/include/ATen/ops/relu6_native.h,sha256=AGDb9Lag4YDp4z0sASDn-awg-mHTiC5zSaIZWHdex_g,536 +torch/include/ATen/ops/relu6_ops.h,sha256=3lCkm_E-XlaKOj3UV2u4fhbowhRGGgat9lY6_wU9xi8,1493 +torch/include/ATen/ops/relu_compositeexplicitautograd_dispatch.h,sha256=HH80q0NpxEA3ZuNRMMYaMfXVV_aDQbSh_W9lhx7LKaI,863 +torch/include/ATen/ops/relu_cpu_dispatch.h,sha256=lVcL-OUvag-ZLkRP-kSHn9nf-vKxfJUAG3281XbBERg,767 +torch/include/ATen/ops/relu_cuda_dispatch.h,sha256=RUuu-YvFcSRRfugnoQS8ITtE3QMyk1TqT_7w35POrRA,769 +torch/include/ATen/ops/relu_meta_dispatch.h,sha256=bpW3LZOp4PQbvaFxEVHfg9Atzy7-bmPd0KM1Kipg1U8,717 +torch/include/ATen/ops/relu_native.h,sha256=ngtXPl_oswFk59pixLk9vj9kl44sBqIBbLhEXY7m9u8,1350 +torch/include/ATen/ops/relu_ops.h,sha256=dydIgLCn2SnQ6HaQV99rSBMWXnyH03nhUxmKVbse09w,2104 +torch/include/ATen/ops/remainder.h,sha256=IJuIxlRW2lNNFkl3hBCNRF1ajHEtUZ0rETX3TZUWkWw,2740 +torch/include/ATen/ops/remainder_compositeexplicitautograd_dispatch.h,sha256=2uzaypqoap8QoYtG7ImwiStZJQu1PdYCzDctZ_xZNps,1303 +torch/include/ATen/ops/remainder_compositeexplicitautogradnonfunctional_dispatch.h,sha256=zV24m3xE6UJDCRv3eSF3hojV_9JuNV-iHrY1rsxYOpk,899 +torch/include/ATen/ops/remainder_cpu_dispatch.h,sha256=8ySH5a0NLQt6y3Qmw5ZyMVzxjOgWv1rh3IfE-d-Y73s,1127 +torch/include/ATen/ops/remainder_cuda_dispatch.h,sha256=O9fSel-afEwEVp2jdg3MFkEwr1y9uXQJQ0_lOIna23A,1129 +torch/include/ATen/ops/remainder_meta.h,sha256=uOKJmfDXp6R-0cQ3F3_Jbx4Aa9wLOhyLj54TooRNgrs,622 +torch/include/ATen/ops/remainder_meta_dispatch.h,sha256=G8etek_LNqOEEGMnKEwaKKHWg5VEHaIdgU5EU1sW4Do,1046 +torch/include/ATen/ops/remainder_native.h,sha256=VmhYDOVQ95aYMC29ajm9a-9uhSxuCw1gZm-21wtTPDk,1123 +torch/include/ATen/ops/remainder_ops.h,sha256=g_1I-FI5ZtZvW0iYBW-dBmNK7uPt95_YB_I702zRprs,5931 +torch/include/ATen/ops/rename.h,sha256=AsR4-kWbNnbJWgQzRzLHoR_RAWHV8ptbap7kX0OG-xE,491 +torch/include/ATen/ops/rename_compositeimplicitautograd_dispatch.h,sha256=BHV2gTvU-vVe1plQC3eTOBDLNo1bMov1bOpImtU5sDc,891 +torch/include/ATen/ops/rename_native.h,sha256=dF6gkL2TnwAH7tPfVB8w6SeXKQgPl5qkocR-KwULngA,614 +torch/include/ATen/ops/rename_ops.h,sha256=DIPqcYQbJpUEVHk87MgSa4mvFGg7q-9aF5CVHKF8mwk,1757 +torch/include/ATen/ops/renorm.h,sha256=N3Vce4RYjWhjeVHf2xR4QJ-T3Co0LdvS4QmFxliCTlE,1360 +torch/include/ATen/ops/renorm_compositeexplicitautogradnonfunctional_dispatch.h,sha256=QgUBZ9SHYogr9rAbqVqalcWvcVUrSiiB-0hxxBhwnK4,967 +torch/include/ATen/ops/renorm_cpu_dispatch.h,sha256=se6xcBN5LSr4CTKp3cxDGSn0nsvWUqZwKT_TCEtbK4M,1180 +torch/include/ATen/ops/renorm_cuda_dispatch.h,sha256=Y1ZhbG5I9ia_oEqRUKlG0MdLeXIqh7ZCTTZ6virg-es,1182 +torch/include/ATen/ops/renorm_meta.h,sha256=eE0i8axRWA0GU63muCQIRwX2ByFd4m54XVUjbXQlwHk,649 +torch/include/ATen/ops/renorm_meta_dispatch.h,sha256=qIKDnf2I6fDc2c1bIfp5pCIEVnct3M1qw4-Om7rYQeE,1182 +torch/include/ATen/ops/renorm_native.h,sha256=FJorzVN8xGzY2yqHUHUgHwGWCY_WAm-zuc71d2DDRCc,670 +torch/include/ATen/ops/renorm_ops.h,sha256=fO_exIg7vWJFgMWtXHMr_zzOvdvt9bHM6sKNt7qgbRQ,2752 +torch/include/ATen/ops/repeat.h,sha256=mII3UwE00RPAjDOKZNHuD3-8DB0jLdYKReGEKVT-Gvs,3190 +torch/include/ATen/ops/repeat_compositeexplicitautograd_dispatch.h,sha256=oZMOkEWBjGt9qD_Qx4clQL9NOBrebKV_q9hIrsw6qXk,1315 +torch/include/ATen/ops/repeat_interleave.h,sha256=0Cg8OoLTdpzSj_qBJZXm7LX91oWyo-5JG9tM_cU_gJA,8172 +torch/include/ATen/ops/repeat_interleave_compositeexplicitautograd_dispatch.h,sha256=eo5lwDrG78a9XlMdSjUQduud1oJ2QDtPLyYmu9gcb68,1272 +torch/include/ATen/ops/repeat_interleave_compositeimplicitautograd_dispatch.h,sha256=txtlyalj-kMSM3JybaLfylOFjfMUlh60Acthzv8BoFM,1446 +torch/include/ATen/ops/repeat_interleave_cpu_dispatch.h,sha256=NxdDBR_00xomoWGTMwuPvO8VETcVV3oqmgjlwUY4xug,911 +torch/include/ATen/ops/repeat_interleave_cuda_dispatch.h,sha256=xpa3I2ggNdBsnWZ9hWTPx7__WlJxWYqSWG4D-AbhnFU,913 +torch/include/ATen/ops/repeat_interleave_native.h,sha256=rwinDRRtkWNRDtrU401UHwxqnmXLO791QXPYB6c_Qo4,1203 +torch/include/ATen/ops/repeat_interleave_ops.h,sha256=150znwkrQMYYmB1xstjLX40t34gG9099QiSKFN1wqG4,3806 +torch/include/ATen/ops/repeat_native.h,sha256=5nqHWhdxDzBRDbra5kjzlh-BmDCtfdSi9t7XRN4uCnA,626 +torch/include/ATen/ops/repeat_ops.h,sha256=_XVP-5j8S46-LAB_zi0IQ_zLKkJv_2Z0-d2nIxNmU_M,1784 +torch/include/ATen/ops/replication_pad1d.h,sha256=ldX21H3P06F0JsHLXhxoOxMAvizewv9U7rFAxbu4Ae0,3946 +torch/include/ATen/ops/replication_pad1d_backward.h,sha256=0dlOoWHBEckZiHFQyFaHcsceZuQLiHNoz4kmvJTbbIs,5109 +torch/include/ATen/ops/replication_pad1d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=L6biPZEg7OKEe3480KDefz2QY3l9WcUe1SIXuwG0en4,1009 +torch/include/ATen/ops/replication_pad1d_backward_cpu_dispatch.h,sha256=A6bDpsVajw6tiaetLap2fzPNbeUVvtNdfhBvyCAhumc,1611 +torch/include/ATen/ops/replication_pad1d_backward_cuda_dispatch.h,sha256=ahQQ9MuOSif0-tqAdF6C6-Xwu8z6erqEQRqE6pDUxT4,1613 +torch/include/ATen/ops/replication_pad1d_backward_meta.h,sha256=6-LbdXI5xK4TsiG-X66KxrO7uamquKboQQ-RZ-xlcd8,669 +torch/include/ATen/ops/replication_pad1d_backward_meta_dispatch.h,sha256=F_mHlFTrWkGe_deWecmju_tFrQm26x_Q4WuE-RcWMcI,1613 +torch/include/ATen/ops/replication_pad1d_backward_native.h,sha256=sKB3Tbw1dtLa5BwEKHVpEL2ySjIA6trlzOpYurEa2ok,997 +torch/include/ATen/ops/replication_pad1d_backward_ops.h,sha256=r59dd4n1UfHuvjawi3XiJPi9JACZlWQUZES-VHrAaBw,2156 +torch/include/ATen/ops/replication_pad1d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=z56ajy0Aga2UO2SPvQlo-jjMX0pt2HW37Par8tp55p0,927 +torch/include/ATen/ops/replication_pad1d_cpu_dispatch.h,sha256=3eaq6-Ei0_egbV6rj6y49GtHamE9cQ0_rZ-15UfwqGs,1337 +torch/include/ATen/ops/replication_pad1d_cuda_dispatch.h,sha256=8dnyHc6crRC3hb5xMtWecXawiQNXvzYYvmoWSwdHQtI,1339 +torch/include/ATen/ops/replication_pad1d_meta.h,sha256=nJ69PMTGUbVzvF1Dvtq2HTwwhHXsrXdnX5y930vjAiE,628 +torch/include/ATen/ops/replication_pad1d_meta_dispatch.h,sha256=6FzzCkI2IXLRKvEHlpJWJ6jiU3JNdQ1kw3nwZuZySL8,1339 +torch/include/ATen/ops/replication_pad1d_native.h,sha256=WkPndcOMrxqva7ctTB_LszcPG2Mr_4B1NT5LHkUNj9Y,874 +torch/include/ATen/ops/replication_pad1d_ops.h,sha256=YLT28TOwKDXsqAWk0t9woPCh4lBLXU1uiVPurSh9pbs,1852 +torch/include/ATen/ops/replication_pad2d.h,sha256=oId55xCaOjVrGFnk-KsQtyE-nHOrB10wz4uFdS9zl-8,3946 +torch/include/ATen/ops/replication_pad2d_backward.h,sha256=W13ImxR2_J2vJo8g_SYDFjTakLWwrtaGooZvXzoQVWI,5109 +torch/include/ATen/ops/replication_pad2d_backward_cpu_dispatch.h,sha256=wzmv9ZtGaU4aaGXboHPSbXSWJ-oDvTXN1o8CIXr7Ps8,1611 +torch/include/ATen/ops/replication_pad2d_backward_cuda_dispatch.h,sha256=oXbBRAtGaUob0EZEhlf0PP-1uaT8Pi6wBOCA9waB7eM,1613 +torch/include/ATen/ops/replication_pad2d_backward_native.h,sha256=jN7C7k2XeDhNd__wjr0jriy8Tks5C849idBy6rG-d30,1037 +torch/include/ATen/ops/replication_pad2d_backward_ops.h,sha256=cKzfaTSm-KRPCF4ux3En58dXyTwzjDCJrqrGssP0C6c,2156 +torch/include/ATen/ops/replication_pad2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=sSktEXd7PLFY9LUgT2KHGwtDLCMaQAtz-1mjKZHnIBY,927 +torch/include/ATen/ops/replication_pad2d_cpu_dispatch.h,sha256=pQEZB3EbhRcGZYqCajmWBt2YuOLWTpRCThvRiZpc29w,1337 +torch/include/ATen/ops/replication_pad2d_cuda_dispatch.h,sha256=L3xgS_4AWITvrfLUJdcZxWmZioirL7CQibs9tvY4a78,1339 +torch/include/ATen/ops/replication_pad2d_meta.h,sha256=TsxG64kTWc9Lew2OHL49Oz_e1NP89o9QKO6-lWgN0NY,628 +torch/include/ATen/ops/replication_pad2d_meta_dispatch.h,sha256=Ie6ig5u5_MoxPeD-NQt8H8v2ut2-YWOx3H7ZsOeEk4c,1339 +torch/include/ATen/ops/replication_pad2d_native.h,sha256=H5rsWy-0hOwhf7YtM3glu6QOrgjmyF-6ruvbU-m1iFk,874 +torch/include/ATen/ops/replication_pad2d_ops.h,sha256=5bMRqrc1YCSUQmYhu-I2ZEERCSk1xDK_iUPovhShMeE,1852 +torch/include/ATen/ops/replication_pad3d.h,sha256=4hX_UAnP4Q5Lybwek_isig1KCLuDKzbH9N1qCALoF2g,3946 +torch/include/ATen/ops/replication_pad3d_backward.h,sha256=AoeoABoqtaObT_Ui3KcHG987QnAaj89bWGpAHGlMoeU,5109 +torch/include/ATen/ops/replication_pad3d_backward_cpu_dispatch.h,sha256=bvIfvjnpNuI_TkU23qn-AbZHVZZib23cm2_xt3ApOsc,1611 +torch/include/ATen/ops/replication_pad3d_backward_cuda_dispatch.h,sha256=TzedmNakDu0AkJ7a77-VfPwdcUqo2xEUdGvELmhNplw,1613 +torch/include/ATen/ops/replication_pad3d_backward_native.h,sha256=ahEvrrNbEJSVe933kZSuciZ_iAgq2Mz2k0Tw-j6paeo,1037 +torch/include/ATen/ops/replication_pad3d_backward_ops.h,sha256=zw3wioKfamsbEtFHtqK0Dhqf9ezy96MXvPckzcJiEsc,2156 +torch/include/ATen/ops/replication_pad3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Tt8HnZ1OC0jx1MfKp5lUvHk1hWV66M2oX5x7I3ZnLhE,927 +torch/include/ATen/ops/replication_pad3d_cpu_dispatch.h,sha256=HGjUgC8LJ5hKGdIgBS7pQAaOZrzREHXkSpCKpBZJXGw,1337 +torch/include/ATen/ops/replication_pad3d_cuda_dispatch.h,sha256=VXym5ajSji7nIF1jj3H6KV9wf_FD9dPd3pqrZbtCODI,1339 +torch/include/ATen/ops/replication_pad3d_meta.h,sha256=jkKOBpFNTKkbzyA7u3kdyN2t4BSXyoUo62qaew09wfM,628 +torch/include/ATen/ops/replication_pad3d_meta_dispatch.h,sha256=WXwFp4CDgoWvUZudaQl9SYrKZGU9kOTaLDTHVnl0RVk,1339 +torch/include/ATen/ops/replication_pad3d_native.h,sha256=7rhvfsv_ef1nvvYI3duirOLp6OhuME1buUuLr_2ptng,874 +torch/include/ATen/ops/replication_pad3d_ops.h,sha256=L58AO4phGQB0GdZIX637xZstI1uyMNNfZphvWhb6m6Y,1852 +torch/include/ATen/ops/requires_grad.h,sha256=YVo46-GbnKLJUecRP_5pxjz7xm_3Bkw8xD8tT1BO83Q,498 +torch/include/ATen/ops/requires_grad_compositeimplicitautograd_dispatch.h,sha256=JY3EEmTP0X6TiuKaZCpOJysT1agi5ePx5XIq_3MkpHE,793 +torch/include/ATen/ops/requires_grad_native.h,sha256=GERj89OYm0JKaFALI9zCt9BcXrg7oimJ_HNN_OM9yA0,516 +torch/include/ATen/ops/requires_grad_ops.h,sha256=0tIFfJ8-zC8aK9ofyi-XhGM624w8X350a-IPyZOZidQ,1058 +torch/include/ATen/ops/reshape.h,sha256=Ghs6djGLvSumFtxB4PrgHZpggX0PexbKQDIo892quh8,1404 +torch/include/ATen/ops/reshape_as.h,sha256=E4FgFK-jIJLn6g3gclrJwZWUzmyAlQpWQi67BA7LHAw,495 +torch/include/ATen/ops/reshape_as_compositeimplicitautograd_dispatch.h,sha256=tLZKaKQ_EQR_ZMb4h_tmwgqgLDQErSDqS2dEjiqB7Hk,794 +torch/include/ATen/ops/reshape_as_compositeimplicitautogradnestedtensor_dispatch.h,sha256=LZQ44sFn2Y7mmwqFH2GUsHn3oylyRhRT2N7t-7JlUEA,818 +torch/include/ATen/ops/reshape_as_native.h,sha256=ZkizhnQudLXThQt3LJGOD06aOu9k0zVv5JJ-YRYI3js,608 +torch/include/ATen/ops/reshape_as_ops.h,sha256=52WRH7KB3aiEdtQBqT9Tu_iFvnD04NYv9ANO2Lshf_k,1071 +torch/include/ATen/ops/reshape_compositeimplicitautograd_dispatch.h,sha256=EvhmAAjIA54gEVG3l-J8cdGrfHYsaC1AGh2FfV5AB10,877 +torch/include/ATen/ops/reshape_compositeimplicitautogradnestedtensor_dispatch.h,sha256=HigwPxjHEUwWEkIgGmQAH_xX2iYk_03CITv6UIQGKSI,901 +torch/include/ATen/ops/reshape_native.h,sha256=y0PtjyDBFu4Q_5hjROYsATKT_-cYNUcs-HRhoKMVKNs,618 +torch/include/ATen/ops/reshape_ops.h,sha256=ZNDgMIWM1vs2PSw5OpJ6ZIzbm1b0SFD6GBJo-uH8uPo,1067 +torch/include/ATen/ops/resize.h,sha256=9g1fAMstganYFn3aFPOFNI5Fa44i4Qyn44thPvB9aQw,5323 +torch/include/ATen/ops/resize_as.h,sha256=C9o5e1XSap5SHfwD5JyuE6UXHqgfb8IzSWlMM2YEq0A,1933 +torch/include/ATen/ops/resize_as_compositeexplicitautograd_dispatch.h,sha256=ovDJms9zS9i3Tf3pF7-aaOPD47228wWZg1Ofsai8eZc,1379 +torch/include/ATen/ops/resize_as_native.h,sha256=jZPHMvHjNh23EZpz6eJOhgtKKwEFN04Xz9kjw_Yjzac,915 +torch/include/ATen/ops/resize_as_ops.h,sha256=1fyy6B3Ljo0a9xMhX-T-p2GJLjIRX2WA65lS_yeXUQQ,3031 +torch/include/ATen/ops/resize_as_sparse.h,sha256=nh4Xtn0GiQzQ4jitRJBhg6oNEHLWnIVk609FEBEmKkk,1595 +torch/include/ATen/ops/resize_as_sparse_compositeexplicitautograd_dispatch.h,sha256=QwJHx9R70LFmcTuKjLcFref0C94ZIafpD3UitdUo7bs,1074 +torch/include/ATen/ops/resize_as_sparse_meta_dispatch.h,sha256=1zzp20-5piFKDb5bpBXioZ3nBFFsPNifSErixgvrOhM,774 +torch/include/ATen/ops/resize_as_sparse_native.h,sha256=hqpwVOOnkq-DbI_4VxWulO2sDWvDPMborgypVckDCfw,886 +torch/include/ATen/ops/resize_as_sparse_ops.h,sha256=iq1VQBvyKpiNa-sUjutWN4KQnMfTixLdQWIPbAXwE1Y,2605 +torch/include/ATen/ops/resize_compositeexplicitautograd_dispatch.h,sha256=-iEKo2qymhBZZreceOJ0Mzs4wygQ5qkJ89cpQnMGwzw,1679 +torch/include/ATen/ops/resize_cpu_dispatch.h,sha256=c_PI4bu0NQAdDIhsFx_jfHkIXqZBavmIruIbOpI9aIY,967 +torch/include/ATen/ops/resize_cuda_dispatch.h,sha256=43JX4xu4wUzmdIWm1ndjfrVkvdtPefaMygNn7KGM30g,969 +torch/include/ATen/ops/resize_meta_dispatch.h,sha256=9sxV4lSNc9ijKN_gGbfTrxw-42TqJoNGP2BE720xyqo,969 +torch/include/ATen/ops/resize_native.h,sha256=Jy1xSwHK31QtH31xlhpsqaN4zY5BUpdctMmoPBV5wKA,1516 +torch/include/ATen/ops/resize_ops.h,sha256=enGokcaO_seOpcq0WQ0ZaTl0q-xNPYt8gBe7XScTcm8,2947 +torch/include/ATen/ops/resolve_conj.h,sha256=VrO7dc9FvfWMAcGu5AFWSEA4kMRAmIXZUCC9i_Bk8CQ,655 +torch/include/ATen/ops/resolve_conj_compositeimplicitautograd_dispatch.h,sha256=ZmkYQAlc3Apqab1QViSQ1RMQddMmlr51mmOZTGNrwlQ,770 +torch/include/ATen/ops/resolve_conj_native.h,sha256=ZYCiEFrprXERrXgX0j2rH5pS9HOL99EdjJ9TJkBY4xU,493 +torch/include/ATen/ops/resolve_conj_ops.h,sha256=jTmFjOO071P9mMZUoAKJaXBF2sJi4evjvmz-qiAHth8,991 +torch/include/ATen/ops/resolve_neg.h,sha256=o35xOicoc4Uiql_E2SY1BZ-1RI8Yysq8PHZPxQyAnH8,651 +torch/include/ATen/ops/resolve_neg_compositeimplicitautograd_dispatch.h,sha256=11SrCruZeI90vY4Qwnsbj2XCnobYFpqT8xMbscyXtN4,769 +torch/include/ATen/ops/resolve_neg_native.h,sha256=ZNdLAjAViL95jN4RvIp2ZFkgeJ4ZNCnqsCaJzCAb9OQ,492 +torch/include/ATen/ops/resolve_neg_ops.h,sha256=TrfhdG6oYhYPma8CYIkIE2b4YLs39q7ZWEwWqEeugoE,988 +torch/include/ATen/ops/result_type.h,sha256=Jb2JLFLZB55NWBASHSKpv0T1QANIOtFMFDxqwKA4z4E,1435 +torch/include/ATen/ops/result_type_compositeimplicitautograd_dispatch.h,sha256=khmrnKFhxJ1uBKU8OMoPD_OStz5DA0jWhmlVpVRmW3o,1078 +torch/include/ATen/ops/result_type_native.h,sha256=f4qUVrQj0oOJR9QC7aVXEuv9TmbzdF3Lebu3Axw6qZc,801 +torch/include/ATen/ops/result_type_ops.h,sha256=eX62eU_u8qSg2j7kf1qQU2bqfIrtsO1Jm_JkIrwf0Ls,3192 +torch/include/ATen/ops/retain_grad.h,sha256=MK85h3jw0duLClh_2FiEhBt0qftCyx5r6WVEsYCiugo,496 +torch/include/ATen/ops/retain_grad_compositeimplicitautograd_dispatch.h,sha256=w1VMAh6zxvN6UsSRj3UtI-EgSKIZL4YgC0zX4olW7_E,757 +torch/include/ATen/ops/retain_grad_native.h,sha256=s78OeTJE-dCoJSNKNFDKe5Prm6YlDncBdgHWIGb9owI,480 +torch/include/ATen/ops/retain_grad_ops.h,sha256=ljyXOOHWHCJ4OqecmND5Q8AitaSvaYee_LE45LxcnlE,946 +torch/include/ATen/ops/retains_grad.h,sha256=JDT9iSYMdLJfIt6-SGk0DYWXFz9JMF4WIZJ-JK0AklE,497 +torch/include/ATen/ops/retains_grad_compositeimplicitautograd_dispatch.h,sha256=enUUiMkfZIH4mlTJNtUccCS-MentCylWDuXCVRaw-04,764 +torch/include/ATen/ops/retains_grad_native.h,sha256=aNDuhq4tMq5V_X7sSvwGY7eVqYu7gYmH_X8APwY791c,487 +torch/include/ATen/ops/retains_grad_ops.h,sha256=6X3W075uEX5zsQKkH3beA9nsSNkbpBSwUdk4jRbbi20,965 +torch/include/ATen/ops/rnn_relu.h,sha256=ET3bK0xQpk_Lm2FkFaGf3NPvFhiuhWN4SamNOwoMhUA,1595 +torch/include/ATen/ops/rnn_relu_cell.h,sha256=mmuEbRJV__VfEOl7_03qg0tQhQWGT8_2NIvRq4NQ8WM,918 +torch/include/ATen/ops/rnn_relu_cell_compositeimplicitautograd_dispatch.h,sha256=gBC7vX3tO8ADWBIIddI7CdhV7k9TLDLPsARSgT7ot1k,931 +torch/include/ATen/ops/rnn_relu_cell_native.h,sha256=LewrvtABDdisY-Shu-J-oaF6TITD34wx99SjmnzKM6c,654 +torch/include/ATen/ops/rnn_relu_cell_ops.h,sha256=3n1QeEuw9R-3XeQqVz_YT_zzCnSFVRHKVcrhbHT00f0,1502 +torch/include/ATen/ops/rnn_relu_compositeimplicitautograd_dispatch.h,sha256=vvp8xf-n-jkfmnmc-H19KrWJtAgSauCP9LG0-svyghI,1185 +torch/include/ATen/ops/rnn_relu_native.h,sha256=BNUbKliR3h2VwZnQEs1ZdNnVPEO1tdyivF1aCcANOAY,908 +torch/include/ATen/ops/rnn_relu_ops.h,sha256=J6LwPVOZ1pgHnVmIIzZEn__8LfEvP_KL8eCOUIuByA4,2762 +torch/include/ATen/ops/rnn_tanh.h,sha256=-2QIQj4muaeZSBaOACgiTTVSt_XBuL_17TSle1xj_hI,1595 +torch/include/ATen/ops/rnn_tanh_cell.h,sha256=YgjnKYiMfM3F9ExiJ_NgDphYxbogz_CEsDwauJnuzws,918 +torch/include/ATen/ops/rnn_tanh_cell_compositeimplicitautograd_dispatch.h,sha256=SrSIlwQSZcQk1vgbOd_MOFSJgAceT3zs88qkA-wLhqE,931 +torch/include/ATen/ops/rnn_tanh_cell_native.h,sha256=khL_kkGOG35zWvenZ1IGebU1rdYO078QbZja5PNdMu8,654 +torch/include/ATen/ops/rnn_tanh_cell_ops.h,sha256=MR47mm8r5FuHZwbfJSlV7RNg8BslNxUnilQMtmlaLxs,1502 +torch/include/ATen/ops/rnn_tanh_compositeimplicitautograd_dispatch.h,sha256=ZuKpLpwAz0scQRX62m2bFRa7s_Y-JhYpRMrMiZC7fEU,1185 +torch/include/ATen/ops/rnn_tanh_native.h,sha256=6vxTSJ5Ep0275xmlVOQH-iJF13hgIGXROg93kyWuf2s,908 +torch/include/ATen/ops/rnn_tanh_ops.h,sha256=IL50LlyvfkRGYvNqcfdpGLZRThTcodIRIqkyyJsFgsk,2762 +torch/include/ATen/ops/roll.h,sha256=k4y7Mo-VCE4V3CxsUm07fKzTaLDdGoe3g58wGFwo7B8,3969 +torch/include/ATen/ops/roll_compositeexplicitautograd_dispatch.h,sha256=hBh_kkbiLd0M90PjUNrEYzzrjjJvWGihDHqs2kl6Q4Q,1228 +torch/include/ATen/ops/roll_cpu_dispatch.h,sha256=axXRlKC24d29HC0DBLbjdbS34lrRZu-qBSMktf0hkZY,879 +torch/include/ATen/ops/roll_cuda_dispatch.h,sha256=3dpd8y2z6ed-KRLK4ZIbB8waA2n6wzilPdNOzgZij1g,881 +torch/include/ATen/ops/roll_native.h,sha256=I7OCb1cMr0BVDEhI3WYNg3WTToIB7YEirOnIwUubpno,773 +torch/include/ATen/ops/roll_ops.h,sha256=nlXnJXlLiNaSDtWvaMF-akUD0oRnVlkz5wSVyxCij9I,1922 +torch/include/ATen/ops/rot90.h,sha256=mbDA2pEcX4SpgNSyxxxavIlMKyHadRXJUPbmKUghgDM,1228 +torch/include/ATen/ops/rot90_compositeexplicitautograd_dispatch.h,sha256=GFYfZF7RcVShlT_17llI56R8iu2nmXXoqIl5Ba6iKYc,1033 +torch/include/ATen/ops/rot90_native.h,sha256=81RZ_-evoDZbpcxDaHq4uUXYQxVroEAZnnD1EgryqlA,637 +torch/include/ATen/ops/rot90_ops.h,sha256=J6g0A1czyUqj8hIQnHqzbzv5JyW4iNzsH5ENLy4OB7s,1822 +torch/include/ATen/ops/round.h,sha256=NObZb7SduTgCXSqkOdyRZ2WsVD-7wQgM_O_TUYU5Js8,2045 +torch/include/ATen/ops/round_compositeexplicitautogradnonfunctional_dispatch.h,sha256=0V2NnobNWh0sQL1wHRn2TTH4zA3CTepuaCUn6y97NeM,978 +torch/include/ATen/ops/round_cpu_dispatch.h,sha256=vOTwuJ8VF-z9QHhiAnvAF6Q-XMY3FXZ4qz82uwVcj4g,1254 +torch/include/ATen/ops/round_cuda_dispatch.h,sha256=Cuvv4uKSE5Mp4QG_WozfoKgIJUrsnM3TKH6ybMZz-9o,1256 +torch/include/ATen/ops/round_meta.h,sha256=BhrA1575x0W67e7oA4Nyeo3RK_jURooOok1mtcrFNAQ,729 +torch/include/ATen/ops/round_meta_dispatch.h,sha256=SMBB9WAFYFPk8LF8UOJuWZCWtjDvsJyww0jMRYRSiPU,1256 +torch/include/ATen/ops/round_native.h,sha256=pfmvWLcbWbx0k1-uTqAOaZu17JgOFf6cznPQ5KDPpzw,1193 +torch/include/ATen/ops/round_ops.h,sha256=6hMB-on4Yit20s9lDRKHrNxY6BhKsP2YWuv6EsgkOWY,4054 +torch/include/ATen/ops/row_indices.h,sha256=9TrGbVWFhaYtwK7hjSJ5oCeiCIcaoB9nmryv1E2n5Sw,496 +torch/include/ATen/ops/row_indices_compositeexplicitautograd_dispatch.h,sha256=XRkeOOlfX0uG6In8T9KWjC1NzlrLAiT44gKXzuYmlIc,769 +torch/include/ATen/ops/row_indices_copy.h,sha256=lif8YSVgIeNgMF2OAmLrjRwBCvyQqCnEfZTReg7ecEs,1115 +torch/include/ATen/ops/row_indices_copy_compositeexplicitautograd_dispatch.h,sha256=dG-jU5bOeKZfsSoHa-IfF5QpatQOwe7wi3pV0ue4_7c,887 +torch/include/ATen/ops/row_indices_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=774cIYq8ig8CUXei9RCUIpVv02qOBZIdZH3SPDj6aJc,800 +torch/include/ATen/ops/row_indices_copy_native.h,sha256=ih-eJdVCczzwmZzb3yp50PR7xlVQCNc-YfaxZa5xBT4,585 +torch/include/ATen/ops/row_indices_copy_ops.h,sha256=Qxlj6JBm4omJYK1CX8At7hfV1lA7TraxMZb-GwBbapM,1650 +torch/include/ATen/ops/row_indices_native.h,sha256=cmlAKXYM0A5bFrq1YZiaeE7GSwJq7WP5ts9sgUr0g4A,570 +torch/include/ATen/ops/row_indices_ops.h,sha256=LujL-zl07NCnNbMFftiN5FqwRLMSXyrkwhnyBt8cPMs,988 +torch/include/ATen/ops/row_stack.h,sha256=o35sFRPqKUwWDP7CVphJg-gtKgG80d2LtCKkJngoat0,1066 +torch/include/ATen/ops/row_stack_compositeimplicitautograd_dispatch.h,sha256=-TXconVBv4tdpJS53iuXvkOfIA0caAzUdeWWM9YDCXo,927 +torch/include/ATen/ops/row_stack_native.h,sha256=iCOenGF1fXFuwA4Cr1xpK01_Cvi__uCsfzcZX5dvKT8,569 +torch/include/ATen/ops/row_stack_ops.h,sha256=_vTJsAbqZq7QCYTy_l2zuzycUBtly5YohLqoHzMelQU,1606 +torch/include/ATen/ops/rrelu.h,sha256=Nmt3gogOaynMeK2ZIC2BdUa6h9V6UjOQhjCwNB5PWT4,1334 +torch/include/ATen/ops/rrelu_compositeimplicitautograd_dispatch.h,sha256=A5lmJJbuFiEnwXW5HoSxb5mLkEK5T9t5T0WJMcRn99g,1115 +torch/include/ATen/ops/rrelu_native.h,sha256=nNZxxmoJQeikxJvxWtZpZSO7HU5qPCsyTbNx7KWAvJk,838 +torch/include/ATen/ops/rrelu_ops.h,sha256=x80lpPZY4GLx_1lMwL3IopUxHfKkpQMIoC5S8oqonHY,2275 +torch/include/ATen/ops/rrelu_with_noise.h,sha256=KwntCeuQY0jSRwLdK9ZrU8fx1r6Sm7kc0Jw-4n2VJ7g,2579 +torch/include/ATen/ops/rrelu_with_noise_backward.h,sha256=z9ADges4AShZbR4jKN8w1gMRrNTY84pKIWsq6EHTey4,2117 +torch/include/ATen/ops/rrelu_with_noise_backward_compositeexplicitautograd_dispatch.h,sha256=uD68SYGhj86gXjXrfyu3f2towXP0Ya01yLDUj_E_gXU,1416 +torch/include/ATen/ops/rrelu_with_noise_backward_native.h,sha256=GFJfEU7LVywd4GZksYm7tZoJeCggkPkqXa1MYxAHrYs,895 +torch/include/ATen/ops/rrelu_with_noise_backward_ops.h,sha256=XcOxEn-MX1Cfi9m-x9w43ITEGgIM_dZck8q2wsIvIT0,2668 +torch/include/ATen/ops/rrelu_with_noise_cpu_dispatch.h,sha256=-5FtgXImmMyStv3lncXc9jjHLHBf2GL7D7vziSU0L0Y,1632 +torch/include/ATen/ops/rrelu_with_noise_cuda_dispatch.h,sha256=3nH27ZlLbA0EVGOEIBghHCaObgC1AbsguQk1l1TL-Y4,1634 +torch/include/ATen/ops/rrelu_with_noise_meta_dispatch.h,sha256=zVKap_tV9XIEgUg80VlpxZEIpP7zjH5Xap1LKLFncSM,906 +torch/include/ATen/ops/rrelu_with_noise_native.h,sha256=kkHSgvCdlwjIi7O_R4UdDHgemckaKSCItRk_Ygmcl3k,1860 +torch/include/ATen/ops/rrelu_with_noise_ops.h,sha256=i1eb_vR-1gbGXHCIoM7o7vvMxjomJftsAhQLTlXuts8,3643 +torch/include/ATen/ops/rshift.h,sha256=dacO-h6BWoPInYYjUJTokk-m-gJFicI8jwj7ee-hFYQ,1978 +torch/include/ATen/ops/rshift_compositeexplicitautograd_dispatch.h,sha256=MWeyIz9AL6i9msqCJ241dd9oz5P-cxSURc4eXaCcdpc,1144 +torch/include/ATen/ops/rshift_cpu_dispatch.h,sha256=j6s6RFQr6206UMOSBz36xXrtNyzTZrI9YMZ5J54-jdY,996 +torch/include/ATen/ops/rshift_cuda_dispatch.h,sha256=Xf3yEHw8BYpQjKTedmLqTrXiUtydmtCNvhRb7Xi2was,998 +torch/include/ATen/ops/rshift_meta_dispatch.h,sha256=yaz-qqIvrJamkQNjxL8_MvNMUqM6-c2TAAL_vjKvG_E,830 +torch/include/ATen/ops/rshift_native.h,sha256=Z2lm8c_JThLDaqmTuw-oO19GUdROo8uP9a6Rl4iDI20,993 +torch/include/ATen/ops/rshift_ops.h,sha256=H1W93noOghP6stSWJzD6xlFjt0dhefH1uSZZXE_MTVM,4520 +torch/include/ATen/ops/rsqrt.h,sha256=3dR9HRXVStyKZJsgPfneDWh6tzjAbvnXdy2ucsJ15c8,1144 +torch/include/ATen/ops/rsqrt_compositeexplicitautogradnonfunctional_dispatch.h,sha256=fh3O5dkf6iLgqhP6Ka-pYX46GXAm6TZKasT8Wm7YaV0,839 +torch/include/ATen/ops/rsqrt_cpu_dispatch.h,sha256=ghHcwbzWagekZD7IWJrawN9nnqjLtT8fzj7mkwZXPtU,924 +torch/include/ATen/ops/rsqrt_cuda_dispatch.h,sha256=4cXGR1hqEhhL9F0LCgmL5LTGCVYA8JIUcD-e-kkZfX8,926 +torch/include/ATen/ops/rsqrt_meta.h,sha256=x02rdybJvXmpyWrS2ZHHKj4Pa2mMvTZqQkWwta3PC1A,585 +torch/include/ATen/ops/rsqrt_meta_dispatch.h,sha256=v-B-lt4IrnhGaVcmfiXJDbooi6DBtl7ML7CFulA3rl0,926 +torch/include/ATen/ops/rsqrt_native.h,sha256=irTP_j1JoS-bPXPdHNOOoZkQ6rdIHn8gXmerGFwBcOY,604 +torch/include/ATen/ops/rsqrt_ops.h,sha256=wGXLWI-dBhOiDmN0vrFpZWmQXWnhCu68tI-bsB5PWZU,2113 +torch/include/ATen/ops/rsub.h,sha256=W0ye_w20elN1y0KT7b8y0bh6lQDHc3X58Frpm5WKEYo,2173 +torch/include/ATen/ops/rsub_compositeexplicitautograd_dispatch.h,sha256=GRZhj4F30Cf_B3pdhBnM88rAgEkKR-psUEn9RUn3Ux0,1334 +torch/include/ATen/ops/rsub_cpu_dispatch.h,sha256=VNc_G6174WTu0bOkSc4fObglbM5NPVZActMqQ4E83j4,772 +torch/include/ATen/ops/rsub_cuda_dispatch.h,sha256=zD99Ts02VA4iOECeHpHlCP3DCOT95NobE0N_HuA_YdE,774 +torch/include/ATen/ops/rsub_native.h,sha256=vMxCVmZYOOE-05pvLSj-ZCKMdEn26C4o5apnU_ksaRo,915 +torch/include/ATen/ops/rsub_ops.h,sha256=NXAFxwn8-EmaLtZbX2A8hvfRw_jKHDH642QhCzgTYHM,3503 +torch/include/ATen/ops/scalar_tensor.h,sha256=koIgLRox4vqH2i1gGgiucqF69YdbOHRWubRMUADfiyk,1714 +torch/include/ATen/ops/scalar_tensor_compositeexplicitautograd_dispatch.h,sha256=VxgnhEajcNPdawlfPiU5rQDuBlpE4zE3Mqu1CjGTs-E,1158 +torch/include/ATen/ops/scalar_tensor_native.h,sha256=G0Fo0kAfWJ6KTEdacE9fHHEB6mIe-FUhOXEo45fK0Ok,722 +torch/include/ATen/ops/scalar_tensor_ops.h,sha256=7ngp7YEQ3xTp0H8k99vBobk7H4Rn_AMbgen9ogE2UBI,2086 +torch/include/ATen/ops/scaled_dot_product_attention.h,sha256=XcIVW9Sa6qjRAX_bKgEbT9JO1zqIaExK-Kqf_ZoNJgA,1067 +torch/include/ATen/ops/scaled_dot_product_attention_compositeimplicitautograd_dispatch.h,sha256=NzgHSpdF9uMGzf-fWHrTo6IjmrDcXh4y3c_6ZVXsPQk,971 +torch/include/ATen/ops/scaled_dot_product_attention_native.h,sha256=bNCoRhPgLjuboYlydIN3l-r3PUvmkM6kFpTwLBJu4sM,694 +torch/include/ATen/ops/scaled_dot_product_attention_ops.h,sha256=THKtMQwNywwEa6pje3UFYA0s-uJ7u-R7vcs9_ztr9mQ,1579 +torch/include/ATen/ops/scatter.h,sha256=7ATZ-Bjj3qJQe3iQdBMVLunYAuHrYt5m_mpC5snfB8s,5079 +torch/include/ATen/ops/scatter_add.h,sha256=ex23VGhOKm9lniR-oj2dAxesYIBMC3GRDZVYRGe8S3Y,1699 +torch/include/ATen/ops/scatter_add_compositeexplicitautogradnonfunctional_dispatch.h,sha256=m9ZRGQ5-e9ted2n75uGyI8pQyj2r8YvnhZJppfisSQI,977 +torch/include/ATen/ops/scatter_add_compositeimplicitautograd_dispatch.h,sha256=kTHxoN40Eqy0DWatvfY4OnbMZbDD2yzNMeZu4PQ5QQ4,836 +torch/include/ATen/ops/scatter_add_cpu_dispatch.h,sha256=NqBR0dGWODpIP4jns2Zg2AnCe7hAA5yTd9rhi3GuB2o,1200 +torch/include/ATen/ops/scatter_add_cuda_dispatch.h,sha256=NQ_hwDwRJBFMfhsySHaJKXbqR4scjgiJRAxk924FQWk,1202 +torch/include/ATen/ops/scatter_add_meta.h,sha256=yKtPsEHmDiqdqgaY9fgQH6iEP9dRgWz61keOJwe24R8,654 +torch/include/ATen/ops/scatter_add_meta_dispatch.h,sha256=N4qbckPkeQqmGDmZQKkifoYx3lP0ngyFGI6_LnnVoCY,1202 +torch/include/ATen/ops/scatter_add_native.h,sha256=bBwFhrMj-Zh1Yy86_v62ZrqBsyOYxoRTeuce_qCCpDw,807 +torch/include/ATen/ops/scatter_add_ops.h,sha256=BS-haug73qaPcCM3hUXYShzK2VgdqNZUf6P2OtjW1yE,3594 +torch/include/ATen/ops/scatter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oSWi6DoH_X37iafenDTcv72XwWPPONYMrDAWq2aw3cY,1776 +torch/include/ATen/ops/scatter_compositeimplicitautograd_dispatch.h,sha256=-XLZyuVGdwe61bYI2MnKM7SIFi68L9OyUxSXfJ2jWUo,956 +torch/include/ATen/ops/scatter_cpu_dispatch.h,sha256=5QwX_CejBN6WsbaOCFZwe306aR6jItzF1Nx0c5zM7U4,2954 +torch/include/ATen/ops/scatter_cuda_dispatch.h,sha256=Xid702LdxbTSPhBydoFnBULtsdy2rfEjeObx7UmGLtw,2956 +torch/include/ATen/ops/scatter_meta.h,sha256=8lKzCsP6W7M6oZ69rm7OyFXd0bed9ZVfqN-54SAAp68,1280 +torch/include/ATen/ops/scatter_meta_dispatch.h,sha256=9ztDwGQFf1ZSEdOgBRVd1kZ83TzTIAGx5yUBuUPtkEk,2956 +torch/include/ATen/ops/scatter_native.h,sha256=TUFEewWCClvrGt3LLy4H4a6BJy57x-QpCw-WZR1Y9z4,1651 +torch/include/ATen/ops/scatter_ops.h,sha256=yz7XBva2kK4zlAyzvI-G7q-WAd2K9fzQQSWpJqGZnic,12138 +torch/include/ATen/ops/scatter_reduce.h,sha256=WBLhHojBb9LbGhLUH-OzfN0QzRZLEo4_pY3W_Pg50k4,1783 +torch/include/ATen/ops/scatter_reduce_compositeexplicitautogradnonfunctional_dispatch.h,sha256=6mqUFSz2AZR6e56S_5WA0j8SinAIg1MmiOi6po4oMp0,1081 +torch/include/ATen/ops/scatter_reduce_cpu_dispatch.h,sha256=fZM15D2sVXCTL4FOeaicUHCwwJg5txm9aWU-Kqe7tL4,1403 +torch/include/ATen/ops/scatter_reduce_cuda_dispatch.h,sha256=MygIO6BKIsw-SHGUOYrAaEr2-QPBxA74J-cekbMkwiQ,1405 +torch/include/ATen/ops/scatter_reduce_meta.h,sha256=VlRU0VW3nKcouZf3ykt8I-itK9Ug7YlWGDHJnYuVtDg,705 +torch/include/ATen/ops/scatter_reduce_meta_dispatch.h,sha256=5HzJlOg31A6DsoriYqxSjbtyq4x1e8KanRLVJUKgADE,1405 +torch/include/ATen/ops/scatter_reduce_native.h,sha256=TwW-xlh-h9RdLLWvbGVXt_3FYCEGN_EqNamtUZX-Zys,742 +torch/include/ATen/ops/scatter_reduce_ops.h,sha256=AGP-2W5Y6F-oh49qzdSnW5R_guYBjQbRdBGFixvqlo4,3308 +torch/include/ATen/ops/searchsorted.h,sha256=7j8KjPBj1pLlqxBtc3r7BaAKAegTVccd8WrP1D23kqE,3620 +torch/include/ATen/ops/searchsorted_cpu_dispatch.h,sha256=nePCrCSjGrZ0reozqf2el5k2WMv5qlGCzbuPaKBnXns,2100 +torch/include/ATen/ops/searchsorted_cuda_dispatch.h,sha256=RVExGT47Fyb14VwJbSFY4JvQN7wAK1l_kMZA-gydmKI,2102 +torch/include/ATen/ops/searchsorted_native.h,sha256=94nHGhU5UdmVXO04gYyc5RWSD5LPmqO1FtLEuoI7Vbg,2309 +torch/include/ATen/ops/searchsorted_ops.h,sha256=C2z6nAoGayE-1HbkAJw72v5-q4018fXUv5a5iHm8Ty8,4862 +torch/include/ATen/ops/segment_reduce.h,sha256=-SR3CGHnNz_1zecDTSAclJt-GSk3ubD8PI6NdAwb5vY,2397 +torch/include/ATen/ops/segment_reduce_compositeexplicitautograd_dispatch.h,sha256=aDdmcnY4Di8vjS67E9pFNHmX6wsNm96HHhfvnrMnwhA,1361 +torch/include/ATen/ops/segment_reduce_cpu_dispatch.h,sha256=k_qMv8EoXJqQMvsUZ0JgZmSx4xqIcl3msK_taU1UwP0,982 +torch/include/ATen/ops/segment_reduce_cuda_dispatch.h,sha256=ReZGxdQmUAyY8kHsVI2LdoWnmu9sopQDAJuES3TWrgw,984 +torch/include/ATen/ops/segment_reduce_native.h,sha256=GxVYpyUHqFpAE28I4zuwnMDge6hn4VWPohD0RxlA33A,1066 +torch/include/ATen/ops/segment_reduce_ops.h,sha256=90RNE3USc4dRe49Z_N4izjW7M6jOX4QFZ6H2PMcKW4A,3145 +torch/include/ATen/ops/select.h,sha256=Y74V615G8253OyMkgZd6S9a08YmsPVuOPwwJIFvQK5M,1644 +torch/include/ATen/ops/select_backward.h,sha256=1Pn2xniBDhlU2NM9C7nF4AmLr06Hj4VpIDsUPIKMO7E,4850 +torch/include/ATen/ops/select_backward_compositeexplicitautograd_dispatch.h,sha256=aVLl5KjFA6W3K-1jAN7-mxJ99d5ti5seAoejVsSGm_8,1346 +torch/include/ATen/ops/select_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ywf5WDI1JxlJ9Pq0wRErTcivTjxUoSBbD94yu4o9VSM,1005 +torch/include/ATen/ops/select_backward_native.h,sha256=EK9EbsEjo5WU8ggBgQ3ZDJrvfxaX0DASLTuOpKSQf-Y,741 +torch/include/ATen/ops/select_backward_ops.h,sha256=RjdzlR9-O3XccRC6EF5HAOLfPfMVtFqm5BBQFqR4CbI,2122 +torch/include/ATen/ops/select_compositeexplicitautograd_dispatch.h,sha256=DnptFiET-zNkqvxgp5MfPtggpQA9Ie3X1YRJRs3x1ok,885 +torch/include/ATen/ops/select_compositeimplicitautograd_dispatch.h,sha256=Qin5wY6OUza9eU_7AQU4s9VuL0IssPn_BY91alwldq8,796 +torch/include/ATen/ops/select_copy.h,sha256=5QVNFIOMwLgOBe1YKvHrLEJw9BUoP1tckDnmluhk78Y,3772 +torch/include/ATen/ops/select_copy_compositeexplicitautograd_dispatch.h,sha256=nShinM7M8_kqNYs-2E1ZskrTLaHPHO-p_h13mLXXvCg,1178 +torch/include/ATen/ops/select_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=H4YZEjo1Pj4YJOmidZe6rzs3v4ct0LEwwtnLix0GCFg,921 +torch/include/ATen/ops/select_copy_native.h,sha256=LCUE6J509SadmEnfnBGlO2PpIA2vxiMVfIcZ14r4Z3E,755 +torch/include/ATen/ops/select_copy_ops.h,sha256=5ijpkQvZqE7JuHLCX8wpfj99RFZn4qach-eJMJn5ezc,1861 +torch/include/ATen/ops/select_native.h,sha256=O0qORLIusM_V_KkFFwzQfT7MJt6WQgfaIHKYSQpRLs0,794 +torch/include/ATen/ops/select_ops.h,sha256=oEkdMyJLktZaUC0xfG4vkrIyvh3hQEp4ndW9Yk7l8V0,1765 +torch/include/ATen/ops/select_scatter.h,sha256=f_l0xEGvMDf5IEDOjbct5LulCWiQT-L5RCd8_ru95SY,4213 +torch/include/ATen/ops/select_scatter_compositeexplicitautograd_dispatch.h,sha256=x8ioi3LlnaGyLzLXfhluuyal4yC7T22aCV0zUVdhv4c,1286 +torch/include/ATen/ops/select_scatter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=vhYMKNGEITJ1WVIWUKsB0bl-xduMSyxb89cty7LcAqI,975 +torch/include/ATen/ops/select_scatter_native.h,sha256=Q6ftjY_htnyupxcE6CNtJx942unhk5kbEZXAabTPmz4,707 +torch/include/ATen/ops/select_scatter_ops.h,sha256=L2lbRix5yyuxZ6pvJ5P2wMaM0RvsRItbJIV5IprdWRU,2016 +torch/include/ATen/ops/selu.h,sha256=L6rN3fKir8oiSSb8HxYNHymM635SLPalaYEMGr3Ytcg,753 +torch/include/ATen/ops/selu_compositeimplicitautograd_dispatch.h,sha256=feIEgPVppKywSSF1J0UwT2WGtx9Fl8xcApm3uY3F9Y8,811 +torch/include/ATen/ops/selu_native.h,sha256=7vNnZcOb8VSYNv8M_jJjpLnsEJDUWEuqDcNZA62-vIw,534 +torch/include/ATen/ops/selu_ops.h,sha256=SI7dM6vNtooa4egHeMbMj6T4z1mPasE70ryaEo-kSrg,1487 +torch/include/ATen/ops/set.h,sha256=0ziGo2k6vtuGxpShUnQ7SzDctZDF0REqzFe2B3cXRWc,9248 +torch/include/ATen/ops/set_compositeexplicitautograd_dispatch.h,sha256=uffcQLn5cK01e5EMxZKzJJOtVep08CiB8xPQ4Mw0X48,2470 +torch/include/ATen/ops/set_compositeimplicitautograd_dispatch.h,sha256=qLaAXSCm0WXaxN6kyZted1krq9kQ7NX-zxuY1bJhKiI,1025 +torch/include/ATen/ops/set_cpu_dispatch.h,sha256=IQj-xc2kLWSfgH6xH97EyHVjo60kfnsE18Oe9h5o-MI,1158 +torch/include/ATen/ops/set_cuda_dispatch.h,sha256=obDehO4hPNPO7Mb0lwqxPeEIfBb07PRbc24sq5h_zIU,1160 +torch/include/ATen/ops/set_data.h,sha256=M7LkzCqOE_2rLELk5fOcBBlku4_1EBbfplmohHUiBFg,493 +torch/include/ATen/ops/set_data_compositeimplicitautograd_dispatch.h,sha256=yL2R4AodKWpLR5_gj1kDt-pkBcKkOUmz1XXBMZ4HLMQ,783 +torch/include/ATen/ops/set_data_native.h,sha256=eA6dacR1RMVe52YV4FPLmhwXAoYZlJq0t9E0mQ3Stt8,506 +torch/include/ATen/ops/set_data_ops.h,sha256=j67F7fWpSpe5JKWRsk8HJJmzHLTWSZOOwi2Fpl7bbpc,1032 +torch/include/ATen/ops/set_meta_dispatch.h,sha256=k-R5X55oU6GtG0kR_HkHtakdSMWGBNUrP3PIegVB-80,1160 +torch/include/ATen/ops/set_native.h,sha256=TLSZeWbU6eHblzwx0XRJQ9-V7_eg45mHXgA7ScpR4Kc,2425 +torch/include/ATen/ops/set_ops.h,sha256=dtIASNhLKVLQDI-Xnm1rDBuqgYKfsJiMcXFDqi-LGR4,10090 +torch/include/ATen/ops/sgn.h,sha256=vQYiyDO9VJ6vKXTQOAwWAHX9TQliu0ICpqf5HuDQWEw,985 +torch/include/ATen/ops/sgn_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5LZTvBGItXSSEPoj5He0vvDPrxfS51-kWkyZ6o9PjuI,835 +torch/include/ATen/ops/sgn_cpu_dispatch.h,sha256=N8oA9WbFOLV034Ofk9Y_lEoKo8EL_E1gNd6z37s1DH0,916 +torch/include/ATen/ops/sgn_cuda_dispatch.h,sha256=gEHpo5mz-1MJApDpovu2PBGyFHkKgnUGcC1GVKiyPU0,918 +torch/include/ATen/ops/sgn_meta.h,sha256=ZZhR6tWsacXA8l64-9vDCxN7a20iu_Mtzay7AHO5A6E,583 +torch/include/ATen/ops/sgn_meta_dispatch.h,sha256=8yfX_c-0Sgq8Y_pRhnUy4PizSGbyX-pQMdajpHcDrNw,918 +torch/include/ATen/ops/sgn_native.h,sha256=naslk9lAS9-oNPOqgHUfJiQz_F7guJUqUsfVIIH_Ooo,1125 +torch/include/ATen/ops/sgn_ops.h,sha256=ftL5NX6yzjLsxXX3jCcr59mLsFkTJsLqUxwrxetKMtU,2095 +torch/include/ATen/ops/sigmoid.h,sha256=aCq5YuMow5eUk2-6zJpB-vd8eryp-U7WMFamtUW4C0g,1170 +torch/include/ATen/ops/sigmoid_backward.h,sha256=NA2J3XzgJnQ8pmAVN3YmG_FGBoS9Q44j6dIv0oAJa8s,1398 +torch/include/ATen/ops/sigmoid_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KeXoyaLReJobC_434lczR2HcHZ-hbB5pAywmeclxVRg,834 +torch/include/ATen/ops/sigmoid_backward_cpu_dispatch.h,sha256=Z1EoGWZ4eiOSy7lPpI_5qwyzWyFqxY9wC-35gcOLfDo,1023 +torch/include/ATen/ops/sigmoid_backward_cuda_dispatch.h,sha256=6ZRfEflpXl5fpK-du2JcRoDGKNJjB-LydnnY6mq6OXI,1025 +torch/include/ATen/ops/sigmoid_backward_meta.h,sha256=nqyNIXyLl8Pk2s8DPKUMAvGHl7l3htpKLE2CF4P2dfA,630 +torch/include/ATen/ops/sigmoid_backward_meta_dispatch.h,sha256=S4rELKVhE_1DTVGnOsDDb_8rwjqu0gHQwaJQyOuOLHw,1025 +torch/include/ATen/ops/sigmoid_backward_native.h,sha256=B7URH1RtxKQ0WD0WPji92TfOV8GuAgBPfg2jq-z9G3w,678 +torch/include/ATen/ops/sigmoid_backward_ops.h,sha256=vTt1Fk-bEglgV-2LW62kve1XuuopyA8N9vacI2PjSmw,1912 +torch/include/ATen/ops/sigmoid_compositeexplicitautogradnonfunctional_dispatch.h,sha256=PgSe5Gt31ah8_osPFrHYOww8BvxGX1FAB-T6z4sIlSo,843 +torch/include/ATen/ops/sigmoid_cpu_dispatch.h,sha256=9BqLnt0EV_KwajFVFxF7kDs_-hM6m2r-I-s6TA5mIYQ,932 +torch/include/ATen/ops/sigmoid_cuda_dispatch.h,sha256=QVopEHCkwY_JxiodcFYJU0G5YY7ClWLQK0oroxRrFO8,934 +torch/include/ATen/ops/sigmoid_meta.h,sha256=VsvL76FLM-dZz-KWVYpo0Z7KqK65VfBJR8dqKd2TlMo,587 +torch/include/ATen/ops/sigmoid_meta_dispatch.h,sha256=tHMuVNnesOCzw4LWcETtkRJUayW-Y2Mt3UMxT5SgayY,934 +torch/include/ATen/ops/sigmoid_native.h,sha256=-dkBI58GCpi6TZSYgA3AE-JlLPliZN8KIqk1QdCxizU,800 +torch/include/ATen/ops/sigmoid_ops.h,sha256=lzqi6rrhvf061x2LINWNHrKuCUI-SkWBcQG38qsMWAI,2131 +torch/include/ATen/ops/sign.h,sha256=c72wNaIZDLWEwztXaMBx4QXqR9bVu_sjHErW6eZryIE,995 +torch/include/ATen/ops/sign_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3sLCp0R6yinNMOZNmVu3TVD2Kz72SerkQDIQaN_rhLA,837 +torch/include/ATen/ops/sign_cpu_dispatch.h,sha256=dRjDYMA27wsP2uva7J-Kgdy5UvukNUp6IfQthimzXeE,920 +torch/include/ATen/ops/sign_cuda_dispatch.h,sha256=pqJj4CvmdlTDW6JNChQyrKMfUpUrFIobRDu3_I-X5i8,922 +torch/include/ATen/ops/sign_meta.h,sha256=MN51sWvZbLzBpzB2ale08fKk3oY0twxZIyHiWakehRA,584 +torch/include/ATen/ops/sign_meta_dispatch.h,sha256=zTgSWNx26W0SqO2nyrie1VW5-I62rLQKwHVk85ImOnI,922 +torch/include/ATen/ops/sign_native.h,sha256=UwCSlUgSQOrRgrXHuhZ8lKZ_epymAWzo_rMmtcnBPkE,1009 +torch/include/ATen/ops/sign_ops.h,sha256=36fzM7PNMwzYC2f92LfqlLF7SI0Y6jfYOEMJsdrzCDY,2104 +torch/include/ATen/ops/signbit.h,sha256=e65ucj2xLRhsjDMqiYt-sWrKawtLBUbUoj0OS8tDALc,1025 +torch/include/ATen/ops/signbit_compositeexplicitautogradnonfunctional_dispatch.h,sha256=LKAm5dgD5A2eFGCFY4CYUTIl5OTWUm5om6_g5-oBr_4,791 +torch/include/ATen/ops/signbit_cpu_dispatch.h,sha256=rP9ipQWOjXsjCT1FWW15McZXhlElRK-CO_f0m4bDxYI,880 +torch/include/ATen/ops/signbit_cuda_dispatch.h,sha256=FcRfgPia_yIEHt6_4uzob0Cb5Lrew0BvKThRrXioHKU,882 +torch/include/ATen/ops/signbit_meta.h,sha256=81iU5H5qhUpVKsCfezRuSf-8S35aT0agwfMRoPwLUQ0,587 +torch/include/ATen/ops/signbit_meta_dispatch.h,sha256=3TpQ5vHZrP7rtq8vi0ePFzQv_3gu8unuISKA9-JT8ac,882 +torch/include/ATen/ops/signbit_native.h,sha256=yZFX6eEQSqHOKPjcBwdIzy4seys9Jmk9doxzgjHdXdI,914 +torch/include/ATen/ops/signbit_ops.h,sha256=e0CqonP8gaRvpA3w4-pGj4h0rKq1WgvfeCEe200aAy8,1596 +torch/include/ATen/ops/silu.h,sha256=ulFDE1L-rJW7uNv2s8Of_v6_KZKjuUVw-pqAvWPw_Qk,1131 +torch/include/ATen/ops/silu_backward.h,sha256=y5OuDGcW3raq7dyEYRWarSZk3Efn8zJMhUZmmXXL2gY,1350 +torch/include/ATen/ops/silu_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=8YaGB-R4mVUWiIqPoByZJbvej048UGQjTm_O8uBNCeY,829 +torch/include/ATen/ops/silu_backward_compositeimplicitautograd_dispatch.h,sha256=sQm5odhJYhYcckBGh6uwZ68ih5HjuNIIcfDJEQfFfCM,803 +torch/include/ATen/ops/silu_backward_cpu_dispatch.h,sha256=EG_bVXsVJLRVkSi9rLsFGSyu0Tk5y3d79jYiJirYAEI,1008 +torch/include/ATen/ops/silu_backward_cuda_dispatch.h,sha256=JhWuMQ6oEORadSG48Zy1zi_KaNEuhbfYeAtnG5s91Lc,1010 +torch/include/ATen/ops/silu_backward_meta.h,sha256=6AhbxLHQwdFh8pbgbZwncseUASPt-Sga8gd2xDL-Phw,625 +torch/include/ATen/ops/silu_backward_meta_dispatch.h,sha256=mVbl8ejUfC8rCxiW1E7c7S663PjTZUBADWI5m-3D_LA,1010 +torch/include/ATen/ops/silu_backward_native.h,sha256=KPrVkU9l21YJ2a4pxeUFWEhcm1vJNn2nSHcIExIBvDU,865 +torch/include/ATen/ops/silu_backward_ops.h,sha256=fRVpfpQh3xwSo3CeygxZslm-D0cCRkXwkN_nhR2or8c,1882 +torch/include/ATen/ops/silu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=H7Lya-LmVuzj9XLj49GvmeR9pPgteBXanYLuB4TjXB8,837 +torch/include/ATen/ops/silu_cpu_dispatch.h,sha256=VW-LKzanvEolYrQajqECOJSHGJXlc7jhXv3Qc7vDo4Q,920 +torch/include/ATen/ops/silu_cuda_dispatch.h,sha256=xkK0nHdqbsDqgHS3WeyQdxyTOy295H73P6t_RQ8abuM,922 +torch/include/ATen/ops/silu_meta.h,sha256=HCcxchI1FsUcysaN8k94WecIDYUrWS6dNLg2U-vSyxs,584 +torch/include/ATen/ops/silu_meta_dispatch.h,sha256=_RFEFf5hb9lvl-zAckvaGyo213ylhEURqRJSZQgrLUg,922 +torch/include/ATen/ops/silu_native.h,sha256=moP3pInfEc-zh2tem-f_dCRyXvVC6car7RGkSiOh3xk,728 +torch/include/ATen/ops/silu_ops.h,sha256=6RjX3RS8mW-MHGUTeZAJbAj1hA86gaFdLXpGFVY_LfM,2104 +torch/include/ATen/ops/sin.h,sha256=s__O68158yri94PVEkJrBvpO9uz3nGo7Frgb8pboj-k,1118 +torch/include/ATen/ops/sin_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oK8texD6_Mm0uHJLY80EPD2e4B2awH0--EUWVnzkKw8,835 +torch/include/ATen/ops/sin_cpu_dispatch.h,sha256=N2sGALxM13cOEMx_Xw0Z5QpZSz3Z0QB1yv7EF95v5IA,916 +torch/include/ATen/ops/sin_cuda_dispatch.h,sha256=AY7K9iIlZ_AWmzB3s8bQes1AtzQ-Y0J6i8qX1sFlzC4,918 +torch/include/ATen/ops/sin_meta.h,sha256=WGodWvqi8Fu7T3sVG7L1iwiVNJMLYZDDE4hniioup4Y,583 +torch/include/ATen/ops/sin_meta_dispatch.h,sha256=ZXhNfI5oQuNj52zkysQ-oSrQDrUFP-c-_GIv1ZNN8v8,918 +torch/include/ATen/ops/sin_native.h,sha256=EXJKtjltEo7ihKS3TzAAAEHzfrghi3zkWA7bTD_kLNU,1058 +torch/include/ATen/ops/sin_ops.h,sha256=y-pK-1JCIal7xqGP2kZkypyJEEOEs-QLsvyeiVP_yYk,2095 +torch/include/ATen/ops/sinc.h,sha256=hwBkdMJDrrIFkejMncny__tzd9byyr8thQ-tXNrRsvU,1131 +torch/include/ATen/ops/sinc_compositeexplicitautogradnonfunctional_dispatch.h,sha256=EKtHwrscBiEEOnQ1JHHKfTLAH3L0B8F6ALt0WtZqHDQ,837 +torch/include/ATen/ops/sinc_cpu_dispatch.h,sha256=GOS-7yL0DplD2PgWP2CYkwAHuTH1-VvXL5P4HcPu7Lg,920 +torch/include/ATen/ops/sinc_cuda_dispatch.h,sha256=BIV7_Q8rLDcOjtnQjPHdi6q_vtsmByrHmOMUi4olkB4,922 +torch/include/ATen/ops/sinc_meta.h,sha256=WrsO8U80SdHTi0FJHW5qBZzn2Y3hgSHtD-dgmazMhc4,584 +torch/include/ATen/ops/sinc_meta_dispatch.h,sha256=oCzuPzKN9t28M61qlSg8r-8NDD3EQBpEHCXi4dMAHC4,922 +torch/include/ATen/ops/sinc_native.h,sha256=8vucxARdlL4HJvyRUXAPcMp_0CY_oiTb1jaj20SYqfk,601 +torch/include/ATen/ops/sinc_ops.h,sha256=JXWYkZHrllAjNqV22KEGIzhzXcu8Vvu-WrVgInu0zWY,2104 +torch/include/ATen/ops/sinh.h,sha256=zoVS1PkSOe31J07uGtbRIHndUCN23WLrfuKXA-jvy6c,1131 +torch/include/ATen/ops/sinh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Dn9LTkJi_S3ATtf0n85BJ8pNIzMktISmGDnvH8e_WXE,837 +torch/include/ATen/ops/sinh_cpu_dispatch.h,sha256=2XfrxA2i-RFpcoXYAgiDSDF-T2jKMKSn1Re9x-tEZVE,920 +torch/include/ATen/ops/sinh_cuda_dispatch.h,sha256=YTqiAu91XPCxq3bi-2QU5WAJXMOAIJ8XoNE8_Nmsf6c,922 +torch/include/ATen/ops/sinh_meta.h,sha256=OWYnjJLRq9yvElrCTLQhcAKFnV_3ijFWsZ-yPzWzBCc,584 +torch/include/ATen/ops/sinh_meta_dispatch.h,sha256=indTCakEIpKc7xjFjNcUu4CkXNSYnkjFlk0JkzsoNxU,922 +torch/include/ATen/ops/sinh_native.h,sha256=nQDaFm06dab06nGZ1m4UlGakmTwIRmzFvjGM5bErl1g,1009 +torch/include/ATen/ops/sinh_ops.h,sha256=OjUm6RXDu2QTAF-7V_ifwM37k5UoXl3LUvgPGvRcFmQ,2104 +torch/include/ATen/ops/size.h,sha256=Xvi4WwZCvezwWhN_2abVDn8jK5XKMN5GwACfz8yIEP0,831 +torch/include/ATen/ops/size_compositeimplicitautograd_dispatch.h,sha256=lfBzXTWLGOAo9DfG-KPVaOTcT7h5ydQWZqIo3W8vF3k,838 +torch/include/ATen/ops/size_native.h,sha256=JefGYBmJKJWdAw7-WZP417oBERIqZQ-9-dPqfN8uWao,561 +torch/include/ATen/ops/size_ops.h,sha256=GmBa35PoRIDqV9cy1S3w3nJUQ6gT3wQKd0diO5JxrOA,1602 +torch/include/ATen/ops/slice.h,sha256=4zVht5J9RO77kIX_bE8-jwD5QTx8E95fZ78sF0ivDI0,2188 +torch/include/ATen/ops/slice_backward.h,sha256=MhJUNoT-73f-qUQraH5rf2fZPlFEE1qkT9XwGA5MBZE,5473 +torch/include/ATen/ops/slice_backward_compositeexplicitautograd_dispatch.h,sha256=bxgVa7Z0R7s3TzNHNwGTITuhC7ZFeD5qhSlLIj0hrFo,1795 +torch/include/ATen/ops/slice_backward_native.h,sha256=V8fv6W0XmNYQfcnedRYbSfFb-dr5PU8Bw7mD2z-CH7s,786 +torch/include/ATen/ops/slice_backward_ops.h,sha256=YzdSdclWGKkdrs6pWbNfB-HKDn5LBDM2c9zM8Ag6lk4,2358 +torch/include/ATen/ops/slice_compositeexplicitautograd_dispatch.h,sha256=4I4Uz7gsByrkNDr7wTbTxyCS2E4bKqjVQGCNi-ArLIQ,1065 +torch/include/ATen/ops/slice_copy.h,sha256=75WLsBXr96M59a6AzqrXOFDS0EvxsuFeJx4GXSUQJnk,5961 +torch/include/ATen/ops/slice_copy_compositeexplicitautograd_dispatch.h,sha256=lD5PAVq6myk5hEG5w3wm9Cs-CZGOxjheFK2MRbkmZ5s,1478 +torch/include/ATen/ops/slice_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=kmsx8-yJtUQNvN9dYt1HO8fqY4GJRueoBadlFutPnCs,1101 +torch/include/ATen/ops/slice_copy_native.h,sha256=jaDcF6xrz3K2VuFqhCA_7bn9Sg12bwsIIwjrYA9IkiY,825 +torch/include/ATen/ops/slice_copy_ops.h,sha256=L-VzSbZdIaJYg63uyyXoPmztoJRA-3SwO0B3N-KgDY4,2327 +torch/include/ATen/ops/slice_inverse.h,sha256=TzYuWr44-6dvN_qRs4Iz9lrNYLLG3i40g2v4I1GmFKQ,2374 +torch/include/ATen/ops/slice_inverse_compositeexplicitautograd_dispatch.h,sha256=prBRz9-Yott7bG8vmCeM8mQIGv7FUAKLbpnBRXrfg4Q,1129 +torch/include/ATen/ops/slice_inverse_native.h,sha256=8j1Lplf_DjTyHmdSBHCIVEysBzTnUJ2PPKUOwK1RJcY,652 +torch/include/ATen/ops/slice_inverse_ops.h,sha256=KR5DWZ618tC100ZqQJF9kgdqH4Bd2Q7muI2T69CmL7o,1410 +torch/include/ATen/ops/slice_native.h,sha256=TjqEp_9AtzwWEXc6qYNG4CKoOqgU74fkUUVJYV_rBmU,601 +torch/include/ATen/ops/slice_ops.h,sha256=pbOhd5cPAX0N4U9gUZmkbtBFSF2v9J8BXuo53Rio-v4,1326 +torch/include/ATen/ops/slice_scatter.h,sha256=Mkq-8dvpcZ2XhU5GVt7L1IkmnjJUUy3OMx7hHKjQSBM,6348 +torch/include/ATen/ops/slice_scatter_compositeexplicitautograd_dispatch.h,sha256=cyD12fIxbHfex40jD9-lQor2z1w-u9PzX7K9aziGfVs,1586 +torch/include/ATen/ops/slice_scatter_compositeexplicitautogradnonfunctional_dispatch.h,sha256=tRIMpgkkwNkVCy0W4saGkiYwNJxT9dhHcfqkcX2d5ys,1155 +torch/include/ATen/ops/slice_scatter_native.h,sha256=c9-asWe4MjdMOHYfNfkWhn8QwqR8cWIVDRKCcYZdyjk,846 +torch/include/ATen/ops/slice_scatter_ops.h,sha256=--ebtpRj19xN2E0KAzo8JmD1GAiWbLAtokbL_72lafI,2464 +torch/include/ATen/ops/slogdet.h,sha256=OMzMSCFSogpSIhf-iZCKwlBnCyx9q8ZUa5SOAd4-KwY,1307 +torch/include/ATen/ops/slogdet_compositeimplicitautograd_dispatch.h,sha256=dFmaIWSJbfcGLPpGVKU0-g4__WSEsC_xANNcSTF_EiQ,1053 +torch/include/ATen/ops/slogdet_native.h,sha256=IPqe45cfBbf7tXiBGHK-rROY-9o4lPeFMrvICphSwqo,644 +torch/include/ATen/ops/slogdet_ops.h,sha256=CyjUZ3gdow6QoILtRKDNZ7X8UIPd_3nBVbgsKai5mzk,1893 +torch/include/ATen/ops/slow_conv3d.h,sha256=FzIII1vKQ9og7wlFHHLULeX9gvOxg4hIc6k8enTaEJQ,6614 +torch/include/ATen/ops/slow_conv3d_compositeimplicitautograd_dispatch.h,sha256=t6N3YnOjEHz50q7ImVwSzvb0LTHT_VRS_ayG6Kb8PyE,2169 +torch/include/ATen/ops/slow_conv3d_forward.h,sha256=IorxmzrsT2WUVNhHQf3hL9avuOb_Nx8CRWcZSKTryRI,6744 +torch/include/ATen/ops/slow_conv3d_forward_cpu_dispatch.h,sha256=6t5wrfwQC0hebdfcwb-Lw6XV9yC2OE3hOeSa3dcAWCE,2105 +torch/include/ATen/ops/slow_conv3d_forward_native.h,sha256=R_q_Cw00cnfEM3cp2J9LRpp18odaL_V_sI7mqDn1Q9o,892 +torch/include/ATen/ops/slow_conv3d_forward_ops.h,sha256=1mqxxLXESSzliIl24uCinAFweguL8hPS06pKPSf6s_I,2728 +torch/include/ATen/ops/slow_conv3d_native.h,sha256=tfUWNXpi3zvfpWtHyd51HUZbaN6GSLzgWFAdYdSay2w,872 +torch/include/ATen/ops/slow_conv3d_ops.h,sha256=uxtemQaS2ntD5een1tZgdKHnqVEMVmuvr3bWY-XqJZU,2680 +torch/include/ATen/ops/slow_conv_dilated2d.h,sha256=EJTn2Na65hhn539SmBT04dhfJst9jrh63JAI-pSiJe8,7674 +torch/include/ATen/ops/slow_conv_dilated2d_compositeexplicitautograd_dispatch.h,sha256=91dYkAMlVY_npiuqzwFdzGQDjU9iLf2X5cADFa7TVyU,1863 +torch/include/ATen/ops/slow_conv_dilated2d_cpu_dispatch.h,sha256=mAdiCGnMqh2bx-uVSHRFjh4mFmcZN7HZL9xmbvVE2XA,1222 +torch/include/ATen/ops/slow_conv_dilated2d_cuda_dispatch.h,sha256=_aOrW4hOyBTZtuFfmZ3NgCfBaMYiHWovuZUbdEtDj6s,1224 +torch/include/ATen/ops/slow_conv_dilated2d_native.h,sha256=lryslzmcT8YK3sCDozMA3zxYnj2EfD4vVtnyKWxz92A,1221 +torch/include/ATen/ops/slow_conv_dilated2d_ops.h,sha256=ODL5KyzTbFZJp2_2DTYfGodp0uFd9pXnd_e3hoIhLnc,2934 +torch/include/ATen/ops/slow_conv_dilated3d.h,sha256=OAidLgnnUvYm-ktfcVsgMFpmuOM0ipQku4jyCaOoX_0,7674 +torch/include/ATen/ops/slow_conv_dilated3d_compositeexplicitautograd_dispatch.h,sha256=PqQxCj-Ksu5zHCnYAA8OPx5SE0TNt1CRIXWqEPZt3XQ,1863 +torch/include/ATen/ops/slow_conv_dilated3d_cpu_dispatch.h,sha256=fEJGl7kY_dDAerxRZcLAI40NxSTQnlTJMLXmovKqoHI,1222 +torch/include/ATen/ops/slow_conv_dilated3d_cuda_dispatch.h,sha256=l05P1yC1X-6hjq21lIN3q4mTDERFDgYpX_C7axivNro,1224 +torch/include/ATen/ops/slow_conv_dilated3d_native.h,sha256=AWErD5-UVcKEzymlR-OA0zKADb7GKp_K3zxZom6Vjzw,1221 +torch/include/ATen/ops/slow_conv_dilated3d_ops.h,sha256=-qgixYsnvWXqlpGWFbNV6ynt_tWgs4HDHMTNfZMWp1A,2934 +torch/include/ATen/ops/slow_conv_transpose2d.h,sha256=L29lpdyx81NJYyauHYbzC_sNkGqC-1Csl9fJUoQbzAE,8728 +torch/include/ATen/ops/slow_conv_transpose2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=6rzXbRCOtaFvZJ40D3kGpzP5IToGJYvidaLOfciJsgc,1381 +torch/include/ATen/ops/slow_conv_transpose2d_cpu_dispatch.h,sha256=G9wFXjBGSjqKayIYJO8YT28aTS10Xd1RkJGf5nT8jXQ,2625 +torch/include/ATen/ops/slow_conv_transpose2d_cuda_dispatch.h,sha256=V_xeC6GaPQmsGhLu-aVhUAvZaK9S-Ljz0BKOU3ilin4,2627 +torch/include/ATen/ops/slow_conv_transpose2d_meta.h,sha256=My5duHmUU8u0fa3HRaBpO_t4y5sZC8AexQO4mB6oJiM,822 +torch/include/ATen/ops/slow_conv_transpose2d_meta_dispatch.h,sha256=nLtulXVy3TUZg8_8RlPcdI2JmkIodswjSSwnhHORNmo,2627 +torch/include/ATen/ops/slow_conv_transpose2d_native.h,sha256=mn92vu9KnLIOfA-VfNGBmYFD7mymgBnr_xVwPJvODf8,1288 +torch/include/ATen/ops/slow_conv_transpose2d_ops.h,sha256=GZNDESxgdTrSd0G4-3Ek9Ww6hoZhAwoxg02it-x4QRg,3188 +torch/include/ATen/ops/slow_conv_transpose3d.h,sha256=0m-A7O6_HdofCVvXcAhHExFjSmTnunFMxlkz_FiOTgU,8728 +torch/include/ATen/ops/slow_conv_transpose3d_cpu_dispatch.h,sha256=68nk2Phxc0bixxixeoxVgtFLcGe0seoGR-Qdl6Fap7M,2625 +torch/include/ATen/ops/slow_conv_transpose3d_cuda_dispatch.h,sha256=0j99dqy6fdmegYL6jCMdr8OhhRd26lUAs0fZjrkcfu8,2627 +torch/include/ATen/ops/slow_conv_transpose3d_native.h,sha256=hduSIVFrJG5eIAO9qcOql0AUha-oL0yQ4i2AcF-REz4,1609 +torch/include/ATen/ops/slow_conv_transpose3d_ops.h,sha256=1lE5lUFBBOoeOsmsO0-ctHa0i7TlJ_IZJ7QpynPpGBg,3188 +torch/include/ATen/ops/smm.h,sha256=p2AOnHGtBg-d57p0DJ6_T-6q7uY6uKt1xgP33cIc1gw,657 +torch/include/ATen/ops/smm_compositeimplicitautograd_dispatch.h,sha256=zh39RzyV2CfnuPVHLm9WN2xAy1HIvmcNqnC7MHe5zFI,786 +torch/include/ATen/ops/smm_native.h,sha256=1TO0O0-1gfztJZOc3UFrwuoUZB4VuPYPk8PwFXnzNYY,509 +torch/include/ATen/ops/smm_ops.h,sha256=Up4NdZ7cEij5zd95PozfFqph-uPEUVef5Jrfwq1cvdI,1041 +torch/include/ATen/ops/smooth_l1_loss.h,sha256=M0FBMHW0Dj6uM6QlSBP4x5p4t8UmHBHvCWZ6HoRuLNU,1548 +torch/include/ATen/ops/smooth_l1_loss_backward.h,sha256=zdG3nHC5_wJkVxVUQ16_pejOVVzqLxlGj4hnN84Qgh4,1828 +torch/include/ATen/ops/smooth_l1_loss_backward_compositeexplicitautograd_dispatch.h,sha256=vsKgPteWSvoSkOolydVw8wIQi628eQK6CMAGa6Hfqw0,872 +torch/include/ATen/ops/smooth_l1_loss_backward_cpu_dispatch.h,sha256=L1-VS0yBMrCTZThtrofIh7OYl39FeV_fkTRBHRF8mu0,1053 +torch/include/ATen/ops/smooth_l1_loss_backward_cuda_dispatch.h,sha256=S3dEktFSk5jv-cVvrpmgNY-7Tv2Hq0TSpe4upvr_u5w,1055 +torch/include/ATen/ops/smooth_l1_loss_backward_native.h,sha256=AIRjQ6DZtC8KZdg64RIsaY9TPvmIOZkjTn3BMMdOmfw,788 +torch/include/ATen/ops/smooth_l1_loss_backward_ops.h,sha256=N4jIqIJO3UMktU-JrvuLFoZHDXs3Tr-n-vMWcOGpxxg,2336 +torch/include/ATen/ops/smooth_l1_loss_compositeexplicitautogradnonfunctional_dispatch.h,sha256=QFDGg5V9bzZq5wAUY91lhZKYddS5-b-KTRFyH-UraU8,881 +torch/include/ATen/ops/smooth_l1_loss_cpu_dispatch.h,sha256=DdRIZPNl3E3o0ZyHWhe6h4fJRxcoMPF7XYN1KciQEN8,1126 +torch/include/ATen/ops/smooth_l1_loss_cuda_dispatch.h,sha256=D1DeBN2maEeNWynQLkZLW3TJ4YZePPtgrcdTY1uIoBI,1128 +torch/include/ATen/ops/smooth_l1_loss_meta.h,sha256=RIBPPKsXXwK2bdv4ehee8Ou-j3euoT9mg5rMY8ahn50,653 +torch/include/ATen/ops/smooth_l1_loss_meta_dispatch.h,sha256=OK6iuMA73rROWLuzfECUCATHlYFCpFtyw2EV_FsBgeI,1128 +torch/include/ATen/ops/smooth_l1_loss_native.h,sha256=Dp3QfpS1rS70yckRr6rCGEdNnzEaP2vpKnUDDFnDzQc,690 +torch/include/ATen/ops/smooth_l1_loss_ops.h,sha256=Xu7Klz3bVBXAtpuaJozYbK5vLcSqHyvJdOkaoPX7nKY,2050 +torch/include/ATen/ops/soft_margin_loss.h,sha256=NUIc7RbLH3OOPMftHGyZyWGEhFAdLJJFx4lYuk6J0go,1455 +torch/include/ATen/ops/soft_margin_loss_backward.h,sha256=Zy1vHfI0_e02by9HcKUb3LDe6tsaqwVZ4yzj1D--OdY,1755 +torch/include/ATen/ops/soft_margin_loss_backward_compositeexplicitautograd_dispatch.h,sha256=mKz_T200YoVXHwVZm1EYe4W-Ggr1JntbpqZryBzN950,1226 +torch/include/ATen/ops/soft_margin_loss_backward_native.h,sha256=M2wbnatRgS-8HHNRWkhTNC2Jkcj_jPN6Wx9Mam_4j2Q,766 +torch/include/ATen/ops/soft_margin_loss_backward_ops.h,sha256=iuTKyAWTObRfNW6EBy-JyqnVkFsgsIobyMMSKbs_XXY,2256 +torch/include/ATen/ops/soft_margin_loss_compositeexplicitautograd_dispatch.h,sha256=IWQFxzXH4lpRClv65qSSE1EK0XZEPBV2QNpAxW7jZLw,1129 +torch/include/ATen/ops/soft_margin_loss_native.h,sha256=YOU-DQfWwES9x3AVdH5rd9fJ95Djis399ItXIx8Hw7w,697 +torch/include/ATen/ops/soft_margin_loss_ops.h,sha256=AMd6huviPh_w-erho6ztcNIldp1ZSJYuCtcv3js-Z7I,1962 +torch/include/ATen/ops/softmax.h,sha256=TdmY3FQPyUoOT16fgs65-X3w3xAYB4iI15-54PzJEc8,1633 +torch/include/ATen/ops/softmax_compositeexplicitautograd_dispatch.h,sha256=Q-K8P9dGz9fmjMpKnYxPIm0gCKgm_EeRRLorGKBuWTs,982 +torch/include/ATen/ops/softmax_compositeimplicitautograd_dispatch.h,sha256=SW41u0AXh3wzqgCNAMTAigkCSMasoEOi4pX2c4ckkns,950 +torch/include/ATen/ops/softmax_native.h,sha256=aLKlS0HcMcmHh0IlCRqwZncwG0lbQzpDCK-xgloqoeE,802 +torch/include/ATen/ops/softmax_ops.h,sha256=MMYxnafR8BeE7GaOP7mXi65BWY1IlA2CSl7QCxxDgd4,2716 +torch/include/ATen/ops/softplus.h,sha256=QFhsIKPoP1ZSn5gXwloaLR5-lZpI94N5C2x0AKZ_5xA,1369 +torch/include/ATen/ops/softplus_backward.h,sha256=Vigl-TYDPzjRthVhZjqbbzNSru02NR1iWfZfmh7WIfI,1699 +torch/include/ATen/ops/softplus_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=yRyvBXIpd0TxdF7jjYtPtuP6f6DhcJK_jfDlaBnvjaw,888 +torch/include/ATen/ops/softplus_backward_cpu_dispatch.h,sha256=irVg4G8fiE6bKANPwE7laR_bQ1s2ajXO1TCxz1-W9Ck,1185 +torch/include/ATen/ops/softplus_backward_cuda_dispatch.h,sha256=Em2nFwaFRtj0glqW9N0eTAapqi8hL4uSnkXNMTMV4ro,1187 +torch/include/ATen/ops/softplus_backward_meta.h,sha256=D3N1xDiFBI86UYGjIFyMma-9D_MFG7u1o9Bye0KoW74,684 +torch/include/ATen/ops/softplus_backward_meta_dispatch.h,sha256=7h0a9RE6mIXwiyuG1Qidxna_qUKXlmM3KBahwDNVB-w,1187 +torch/include/ATen/ops/softplus_backward_native.h,sha256=s9LL3BVKs5_GdXQ99NQgQmxYO-2Yr1F17hCp7E_dTxY,734 +torch/include/ATen/ops/softplus_backward_ops.h,sha256=C1AqMy3cL4ekYiKZmvtOI6nzUgDDlEhOoVQlBJbyvz4,2268 +torch/include/ATen/ops/softplus_compositeexplicitautogradnonfunctional_dispatch.h,sha256=AxsmNLiuVnwsNx5q0qW15VTu5qb5lRxeNdLH1LIzFWo,852 +torch/include/ATen/ops/softplus_cpu_dispatch.h,sha256=RR3_VIToYt9OWM9n3oi9MXMKX8DoM-EQo6cSM69IDv8,1058 +torch/include/ATen/ops/softplus_cuda_dispatch.h,sha256=pOtF5h-A9QmnyCkkOgC5bhqimw96GuIS5IlT04KVgHI,1060 +torch/include/ATen/ops/softplus_meta.h,sha256=ws6i0pF-4bD3AAJxQ3jZYM0kTVw1r6nzV98z2II38qg,643 +torch/include/ATen/ops/softplus_meta_dispatch.h,sha256=zFKHcO4RG0-KFa8alMQuM9vpEfdctrT8v_9zweG66Cs,1060 +torch/include/ATen/ops/softplus_native.h,sha256=KJEHkmfEO40kzldElwOwaRfqgzYBJsJB4u8f6pRjR7M,668 +torch/include/ATen/ops/softplus_ops.h,sha256=3ZQLfCoQo77YkhbOc8MSl5B8tjAhPhPVGSpZTndI6mY,1974 +torch/include/ATen/ops/softshrink.h,sha256=KbaBhX3af7zQzyIIhRmRYNsVQ8Lgt465T59MdBhaTzQ,1216 +torch/include/ATen/ops/softshrink_backward.h,sha256=rW1INM-rdKUzTs_nIF61gz2yHl64aKgD0ZrqfurYTag,1551 +torch/include/ATen/ops/softshrink_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3wp6BPR3KZD_5wBtv441LjL-OBB9oifbc3gEt2eTY24,861 +torch/include/ATen/ops/softshrink_backward_cpu_dispatch.h,sha256=bLAR1XXgeCw7rD_sahvpKF69olVHZrtcaWagQpp3ooQ,1104 +torch/include/ATen/ops/softshrink_backward_cuda_dispatch.h,sha256=34HDbvTWDXHSe--jDmSWh5ofNMzvGEH4Kp2cBIhORwQ,1106 +torch/include/ATen/ops/softshrink_backward_meta.h,sha256=EKvYOsLLJAAHw9IsDRgMr2tOiZ_loIMWdsl14zZR-kg,657 +torch/include/ATen/ops/softshrink_backward_meta_dispatch.h,sha256=RMrTtetoiE_Yb_tX9scUiwK7d8nLQO0y_L5ijIVAork,1106 +torch/include/ATen/ops/softshrink_backward_native.h,sha256=Szqh19IT2YBulhflFgjovmJqX4m5B7hWte5JBXRjuCg,711 +torch/include/ATen/ops/softshrink_backward_ops.h,sha256=xx3oBlj-88azQAliorEBgpQ7WJCknm2CiqHxaRGoRZA,2090 +torch/include/ATen/ops/softshrink_compositeexplicitautogradnonfunctional_dispatch.h,sha256=s5FhbiA_3ZoBewO0Sk-kh3SROi6CbYuhjf1SfRI5vGM,824 +torch/include/ATen/ops/softshrink_cpu_dispatch.h,sha256=lt20fAFHALyCo2tleiMU_VihjRPcuouBRCnMs8VIFzU,975 +torch/include/ATen/ops/softshrink_cuda_dispatch.h,sha256=1YMOzyji6HWxejuF8e6L7YTrP6WHoHdBYmMiy0KwQYk,977 +torch/include/ATen/ops/softshrink_meta.h,sha256=T13W0XRK36Di2ARp1d5HXrIJXjbdATyPhuvZJdHGvtU,616 +torch/include/ATen/ops/softshrink_meta_dispatch.h,sha256=pGH6GMMP-sbvAxElBzqHkObdJOYA7WUisRru5CFnKt4,977 +torch/include/ATen/ops/softshrink_native.h,sha256=ogHDL9aUc37EtH7smC60fQzUrNxkHxuOVzWNU7fgIyY,645 +torch/include/ATen/ops/softshrink_ops.h,sha256=h3hpYB4xgoFTq5X16z3tMS6tP9PwN_-HW1-MYpIBHe4,1794 +torch/include/ATen/ops/sort.h,sha256=Qqh2kizNi5Zc8vpeREfmlDyDC3uBly7DudWYqHA1cnQ,5252 +torch/include/ATen/ops/sort_compositeexplicitautograd_dispatch.h,sha256=OLvtUB29TbaRQl1_YxyXDxJEFQaW3oZqE3qb45HwbXg,1152 +torch/include/ATen/ops/sort_compositeexplicitautogradnonfunctional_dispatch.h,sha256=UZTC-mNfCQ5fem2rDC3zSauo1BpCszPGP_k3qBxHRE4,880 +torch/include/ATen/ops/sort_compositeimplicitautograd_dispatch.h,sha256=LnIEfy6NDJkaOEzY3bYm2tdywUNPuiovuXCMngNlbx4,1690 +torch/include/ATen/ops/sort_cpu_dispatch.h,sha256=RM4T4YKu-yZS5-DcjBBeCSw9z58pbBxRdBFoXast_TY,1192 +torch/include/ATen/ops/sort_cuda_dispatch.h,sha256=82rVC2zmYFu0yUUnr5pWjUZbF1xbBM0jOsma6MXOPhw,1194 +torch/include/ATen/ops/sort_meta.h,sha256=xcylBUsy3mEXPUH-6A3P5u1pwT6VE5wwjd9cLYpom9I,649 +torch/include/ATen/ops/sort_meta_dispatch.h,sha256=y55mPrl9TpzCLReeXmuTuoEIVNQ-8TR4gBtKGejr_j8,1194 +torch/include/ATen/ops/sort_native.h,sha256=diZbv7zsPcLwUfdsroERwC6ruaqNUvzNBPx3nZ2XU60,1757 +torch/include/ATen/ops/sort_ops.h,sha256=TFy5xGQNtBnvFvhd4ba7rMQGaNizTG96e0S1hNh98Vo,7713 +torch/include/ATen/ops/sparse_bsc_tensor.h,sha256=80LvSLI0fU9OruXpBOYK52V9E7bxzMXFv03VZw1tzFs,2965 +torch/include/ATen/ops/sparse_bsc_tensor_compositeimplicitautograd_dispatch.h,sha256=VvXvVusTFRUafxqLcHYqjetczJusPiEywU032XfR0V0,1610 +torch/include/ATen/ops/sparse_bsc_tensor_native.h,sha256=TJFq0Kz_GpH5-zMVTkZkmX1JfoVbRzn0Txmjgnxrw3E,1017 +torch/include/ATen/ops/sparse_bsc_tensor_ops.h,sha256=BTpMJz7YVhiCHP23GgP5b1sX2Y6BwSgvPcIsXCz9ohM,3122 +torch/include/ATen/ops/sparse_bsr_tensor.h,sha256=yrCJ5_JUA3Faa9RMzhojI7LexVW7JAs9dZ12FS7UUF0,2965 +torch/include/ATen/ops/sparse_bsr_tensor_compositeimplicitautograd_dispatch.h,sha256=RAMsOPks3pnPy2uh3lvo2rSAHwjWaJkhHa8Rc4emd8g,1610 +torch/include/ATen/ops/sparse_bsr_tensor_native.h,sha256=TeeTB_Y0F7c7KiN27u14zd6Jaz0zsM66HJv5sBlLflg,1017 +torch/include/ATen/ops/sparse_bsr_tensor_ops.h,sha256=_dTFgZ2Bd8Q3K2vgTRnqNgbdBkQ-M5IWNmfhN_6Dqf4,3122 +torch/include/ATen/ops/sparse_compressed_tensor.h,sha256=cZ45luPZAg4SehJKXQ76jqD_huCLmsFAFzi5yRgDNBU,6938 +torch/include/ATen/ops/sparse_compressed_tensor_compositeexplicitautograd_dispatch.h,sha256=buSaxxYWDjW2IAkU1P1J36_MHsfi_DOrAamxKKoxY1Y,2194 +torch/include/ATen/ops/sparse_compressed_tensor_native.h,sha256=UBaL6KQnZP1_JDVWudHSD21xY3oTI-Wo_Vjh4c52opw,1047 +torch/include/ATen/ops/sparse_compressed_tensor_ops.h,sha256=dGs41Bh8V45YNL3_o8KvvxEebEnR3Rd4vUEfJ7CWM7g,3239 +torch/include/ATen/ops/sparse_coo_tensor.h,sha256=BBA3qGd1xtMFT6x8cOwbnIk_LfOgvmRfjUuvG21WARU,4233 +torch/include/ATen/ops/sparse_coo_tensor_compositeexplicitautograd_dispatch.h,sha256=9W3PeLTEgDIG29D72Gg5alF9BLaVRpGmSiNZDYPxj6w,1171 +torch/include/ATen/ops/sparse_coo_tensor_compositeimplicitautograd_dispatch.h,sha256=TUIMVL5HEYIKaxPd1HYLMgXtG_9MZ5dR2Qd1_7eEGcY,1630 +torch/include/ATen/ops/sparse_coo_tensor_native.h,sha256=pUuWZlWIKnK-z8y0gCj83I9-m_R5skCWk_SXud_6vak,1339 +torch/include/ATen/ops/sparse_coo_tensor_ops.h,sha256=TO2T0QtYgVw2mGVNC3G21cBDRefmchOaNxWCjcj3akA,4772 +torch/include/ATen/ops/sparse_csc_tensor.h,sha256=aEGqA5BHj2SyYrvXLZBixR08IzqHJrW5MFgKBwty5f4,2965 +torch/include/ATen/ops/sparse_csc_tensor_compositeimplicitautograd_dispatch.h,sha256=bQd9nrTfXAaisRQDMqziJHH2uMc_PaZuLK4QyWPSa0g,1610 +torch/include/ATen/ops/sparse_csc_tensor_native.h,sha256=rl2tqTD1Z18mKHQsh3t9IX4MpdTf7GDOmEuqk1Q6DO8,1017 +torch/include/ATen/ops/sparse_csc_tensor_ops.h,sha256=BtCQrhpc8_QuAEyTes-iXZvNGDCk4Mchjq9ODuekACU,3122 +torch/include/ATen/ops/sparse_csr_tensor.h,sha256=pqZtnuLOEH7bfJRQUmd7IrkyYo9rJXtJRmSBRmPs34A,2965 +torch/include/ATen/ops/sparse_csr_tensor_compositeimplicitautograd_dispatch.h,sha256=6QvCLkbhx4dHdPFacYu8nUEvKFVYf3sWkvMNfpU4jsE,1610 +torch/include/ATen/ops/sparse_csr_tensor_native.h,sha256=h2iQhB83dpolMOGM9iEjJJCqTWnzqEU2wSBNywU-0zk,1017 +torch/include/ATen/ops/sparse_csr_tensor_ops.h,sha256=CkV55aPRrBYs4PrvwHMioCb9Eu7Pn4GSX_WtxTUh3oQ,3122 +torch/include/ATen/ops/sparse_dim.h,sha256=aiCgw5DedqMwauu9YrZ40jsgschG_lYVp7e05bW46xU,495 +torch/include/ATen/ops/sparse_dim_cpu_dispatch.h,sha256=eRclYwa5BKQtRvvQzKdslGJuVXqgZB3V9zACA3VPOWY,721 +torch/include/ATen/ops/sparse_dim_cuda_dispatch.h,sha256=pKStkhAQQWuWQPwZ_jjhHA9oXNB_s1HVhm96_9-3ZvY,723 +torch/include/ATen/ops/sparse_dim_native.h,sha256=GdrzFnjYh23KpcJjYaoxqI0Eoee5eFyZEd4JSRdu4Ak,624 +torch/include/ATen/ops/sparse_dim_ops.h,sha256=rUJnBEHQgb4RrLw2RaoZb0OCnKX-uy2zA2F7zes7sHk,967 +torch/include/ATen/ops/sparse_mask.h,sha256=lB8uooslANf4UF6gu5_ODRMBU_YrKV2sbZzpeM-8VvM,1003 +torch/include/ATen/ops/sparse_mask_compositeexplicitautograd_dispatch.h,sha256=lZZ8zflSDKJfLpXu_gdweD8WAC1Dx_sysbqpu161Rl4,927 +torch/include/ATen/ops/sparse_mask_native.h,sha256=aKCEq51Efpjz7QT52ByKhQxOJveIsxepOiY6LUKXL2o,727 +torch/include/ATen/ops/sparse_mask_ops.h,sha256=u6I6w_lbYdBbW9TAql2rG6-5HcMgeX-gD-cJNIsO1V4,1786 +torch/include/ATen/ops/sparse_resize.h,sha256=slOaoxoAu7hF9HaYPpANR3utIOAHOGQFr5NO19v4oTg,1508 +torch/include/ATen/ops/sparse_resize_and_clear.h,sha256=voZfO0xM9ucBWzZ7yTajzI8v-Ae7nApC1QstLXenRPA,1608 +torch/include/ATen/ops/sparse_resize_and_clear_compositeexplicitautograd_dispatch.h,sha256=Ls6kS5ml4uGfjC8K_A38ow6ICk7nNTWQCrnhD03DJEk,1179 +torch/include/ATen/ops/sparse_resize_and_clear_meta_dispatch.h,sha256=Km3K7YrJCKVTiJ0gwwqE2nwwLTBhECQcFGYHRg9zdcA,809 +torch/include/ATen/ops/sparse_resize_and_clear_native.h,sha256=C3fxDgfigv2j8LvRoqWLnDOv4zxYvsbrL_oTycT6-_o,874 +torch/include/ATen/ops/sparse_resize_and_clear_ops.h,sha256=hoRh3_Qo02RYuw2cvRBa4k9WFq5DhfYieE3dFn5b9SY,2947 +torch/include/ATen/ops/sparse_resize_compositeexplicitautograd_dispatch.h,sha256=n_ZcqJ29w16qtM-k4Cpydy8AXe696IkrSfxNiXrxO68,1149 +torch/include/ATen/ops/sparse_resize_meta_dispatch.h,sha256=TIW_sMk1jfmUGdgJQGhLs8nk-zLUkVj68Rdgvrr8sfA,799 +torch/include/ATen/ops/sparse_resize_native.h,sha256=IPhgB_NCsqGzXuYNNCrsvepfmO1yQevWnv-DeYhgKlw,844 +torch/include/ATen/ops/sparse_resize_ops.h,sha256=xaB_SUGzP1fmFJ5QZVpsq9P5korOx8Kp_AGZI0MWB3Y,2857 +torch/include/ATen/ops/sparse_sampled_addmm.h,sha256=pZjBGePos7KkoZ82bw0caXY_YSiDhXP0LMYl_ggh6BI,1715 +torch/include/ATen/ops/sparse_sampled_addmm_native.h,sha256=FitxHJc0Kd2tS5HeYKWq5vI234LnUvl6oOTHyIWSeRc,1227 +torch/include/ATen/ops/sparse_sampled_addmm_ops.h,sha256=1PHsPSkKEBdWyqh6uLl3sxC41WOpnKezmTi9oTqrOiA,2355 +torch/include/ATen/ops/special_airy_ai.h,sha256=gt07VkiCTf3Lz7IsRYcxj6KwGJndaMrpwLBWFjS2C0g,1078 +torch/include/ATen/ops/special_airy_ai_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wXLDK7Z1CclTtHXRXETveaiueJ9157ffmycygpScvQ4,796 +torch/include/ATen/ops/special_airy_ai_cpu_dispatch.h,sha256=5eQjksGWxSERuaWFRpjU31bFZsmTRZQBxMC0IHO0v4U,895 +torch/include/ATen/ops/special_airy_ai_cuda_dispatch.h,sha256=2TW-ozb54TT126PSh6oF_e1X_bH_t79z6Fm4RipvYTQ,897 +torch/include/ATen/ops/special_airy_ai_meta.h,sha256=iRil3Qop8fJvNuD2xZD3FmB1SRzrolIIL_LqF6tyicM,592 +torch/include/ATen/ops/special_airy_ai_meta_dispatch.h,sha256=NmhGhErGzoVEo213-MT8hjnQ-Cm_svGG81-JHCOvp5w,897 +torch/include/ATen/ops/special_airy_ai_native.h,sha256=xlqmxn_2RWGy5BuB5Am2BCHb_ZMVxwaT869vnRkfgvY,631 +torch/include/ATen/ops/special_airy_ai_ops.h,sha256=AIYe-2JeFHayAhhoe66l3CKv630FqhAS9GjF_23rh4Q,1626 +torch/include/ATen/ops/special_bessel_j0.h,sha256=p5OWnXlhAKYdSwBj7sDAPJZAUdgEqjQiNLrCdiCE828,1125 +torch/include/ATen/ops/special_bessel_j0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=sUN_-xH6BJrL6zS4TgVstPSH0E3pwzo9MZNAdRWF6fQ,801 +torch/include/ATen/ops/special_bessel_j0_cpu_dispatch.h,sha256=md-EpgEyXeXiy_mvwyWT4yJDS19AqOjGpjVwmJJ48Kg,910 +torch/include/ATen/ops/special_bessel_j0_cuda_dispatch.h,sha256=Q7HboI7OlqdoCdybyuVMqtNP2XRV2Y2UnmZLG6sUaUo,912 +torch/include/ATen/ops/special_bessel_j0_meta.h,sha256=jhkd34OABI2cN5FVE6kCI_0NKQa8B1-txjPb9Kz_R6I,597 +torch/include/ATen/ops/special_bessel_j0_meta_dispatch.h,sha256=4uQZkdZ072Iv32obwR3IqoBqZGG0Cik43tI4jMRfy54,912 +torch/include/ATen/ops/special_bessel_j0_native.h,sha256=2qC1w105NO5VP4l7Z6kqQEQzkRm4ggMHdzJ3gcpVIhk,640 +torch/include/ATen/ops/special_bessel_j0_ops.h,sha256=cy--dhlatCGaB78du1l01I-tP-eb2vaXgLcVUG_rfxI,1656 +torch/include/ATen/ops/special_bessel_j1.h,sha256=m9tS7t3Tfwk9qg0rgn94QbUZjaTqvEEs-7avxsqdgW8,1125 +torch/include/ATen/ops/special_bessel_j1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ErD3nUgCo-p6Mp4VCz45ATz-DlKhU8fuxhmZEyewvI8,801 +torch/include/ATen/ops/special_bessel_j1_cpu_dispatch.h,sha256=8TOzZvWYktdR2TZMd4LK26IiLRQgKhLNmYQFYiY05-8,910 +torch/include/ATen/ops/special_bessel_j1_cuda_dispatch.h,sha256=hqBs8c0fMmyeml0Jr9AapvDNe2qzynZL9RTSr3xGvMQ,912 +torch/include/ATen/ops/special_bessel_j1_meta.h,sha256=-3zVOe-8Z9OLNHjaG-q04_XMKujkCDinD2v5BYy0Mgg,597 +torch/include/ATen/ops/special_bessel_j1_meta_dispatch.h,sha256=yeICsiXvjKMibwalDoSne8ec9E3uMijJIAyLl8FdZOc,912 +torch/include/ATen/ops/special_bessel_j1_native.h,sha256=X6hkB4KVMTiLl6jpEyh-72L1feeTTHWE70hPYQEX0cc,640 +torch/include/ATen/ops/special_bessel_j1_ops.h,sha256=JWmJAutuBk0bgmt7PqTEGAHs8osimQg6WeITAtZqHVg,1656 +torch/include/ATen/ops/special_bessel_y0.h,sha256=Bp1O5I7C7bdOEJgvTHMKDY05vVyffSzJf_UyKheZmeo,1125 +torch/include/ATen/ops/special_bessel_y0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=yi6XCUAj2a7WKU-aNabw6gk_sjRdkz_Gg-dwijd0n_w,801 +torch/include/ATen/ops/special_bessel_y0_cpu_dispatch.h,sha256=xy4oxo3wDUSeNWnm1X4Cq4EcZZY1Ex1Ybl_tzyfiW1U,910 +torch/include/ATen/ops/special_bessel_y0_cuda_dispatch.h,sha256=LbI3vgcJWlxI0NAdQbexwcYN-eBzFSQbUC1YIjFKoyk,912 +torch/include/ATen/ops/special_bessel_y0_meta.h,sha256=NaDR-35H9sJxHpFNfX_rzhTl39k53Vkw5qFbSgK69Ag,597 +torch/include/ATen/ops/special_bessel_y0_meta_dispatch.h,sha256=6EP2Q1rec2ncPr2f9KnicSI68aC5VcvbxwSlM8WC-Vg,912 +torch/include/ATen/ops/special_bessel_y0_native.h,sha256=kAn1QlefIuyABvzWn8Iwnz18LDnUFFShDv81mnPOXM4,640 +torch/include/ATen/ops/special_bessel_y0_ops.h,sha256=jrC5FsFWgmfVRSqyCDMlHQkNagsoJz_-7VTYnAfd-co,1656 +torch/include/ATen/ops/special_bessel_y1.h,sha256=rWqz3XNXnQYQPGZ5JWsRlaT8rOhXyX4v5e9nZe3JXF0,1125 +torch/include/ATen/ops/special_bessel_y1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WIZS4xuLu5ouddWjpdxEia00so8BiNpaOlUXqm9dnDU,801 +torch/include/ATen/ops/special_bessel_y1_cpu_dispatch.h,sha256=k87LEe8Edev-dG_fp59c_d14FnWlD_yi6mmwvLH8niI,910 +torch/include/ATen/ops/special_bessel_y1_cuda_dispatch.h,sha256=2iNoCFgKh3L0DU7aX-Ig34eKG2qpoBLISuOX8z77BC0,912 +torch/include/ATen/ops/special_bessel_y1_meta.h,sha256=OjZtP3rHz7iUyCX8FzptDIY0MAqxZl976OOjaq3ik3c,597 +torch/include/ATen/ops/special_bessel_y1_meta_dispatch.h,sha256=TI8SUHiOBuSLjevY95zeT1NnmCCMRRhKtlnbmdTml-0,912 +torch/include/ATen/ops/special_bessel_y1_native.h,sha256=0Ma8asgO_YLJg5yoT0OajCpnRQqURsQBn5x7FjI6X5Q,640 +torch/include/ATen/ops/special_bessel_y1_ops.h,sha256=BMo9LV0RmzcsE2BdrirFpnr7QU_ukNeCCSm8AHSedbg,1656 +torch/include/ATen/ops/special_chebyshev_polynomial_t.h,sha256=kbHd6Lvz4eE794VtVI2B8tfmm_jJ98N0aAEcOnMFLSM,3079 +torch/include/ATen/ops/special_chebyshev_polynomial_t_compositeexplicitautograd_dispatch.h,sha256=VpDsIQwFNz9o04cPtTZ2pPp7LbTIgbQ_rmxgVy4KQdM,1390 +torch/include/ATen/ops/special_chebyshev_polynomial_t_compositeexplicitautogradnonfunctional_dispatch.h,sha256=2uRZ8wcT-VRmiclvi7iRTIZzwODjUEn2Ml7F0mPzl1A,833 +torch/include/ATen/ops/special_chebyshev_polynomial_t_cpu_dispatch.h,sha256=Pwops8mIBXgfxvHO9g9TE4CA7JKLBB6rupzSH62rIlM,1006 +torch/include/ATen/ops/special_chebyshev_polynomial_t_cuda_dispatch.h,sha256=3GdWBz8i-WDyvLvim-oiv2zz9ijf7Bo40U6yPyn6wc4,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_t_meta.h,sha256=jlMWbAoqVp3Urdd5nswJzMKDD1cAYKU3k-QeBa3S8sk,629 +torch/include/ATen/ops/special_chebyshev_polynomial_t_meta_dispatch.h,sha256=3rpaIPQMlrDAYT0928BMWPgPLGpCpnCcGTDa3YRYdNs,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_t_native.h,sha256=rCGe5NM3QNco0GAhrXchikheA76ONTWyo3Jp1FR6rBw,1134 +torch/include/ATen/ops/special_chebyshev_polynomial_t_ops.h,sha256=cMOUsI8YCSTJaDxx5Oh2uHkc_XDOWYLyEBdOM_UAreY,4830 +torch/include/ATen/ops/special_chebyshev_polynomial_u.h,sha256=8oEQpxIymdCome9UZuBJn-fwAbsLTaxBs7kylfeMlAo,3079 +torch/include/ATen/ops/special_chebyshev_polynomial_u_compositeexplicitautograd_dispatch.h,sha256=0heZjuv7fa0_5AVSsrmT-P6AJLCiqpvMYHmflp6mY-Y,1390 +torch/include/ATen/ops/special_chebyshev_polynomial_u_compositeexplicitautogradnonfunctional_dispatch.h,sha256=MBfUz24uIavssctq6hpI1-nu8GMYnIIxWxIs2WzJFPA,833 +torch/include/ATen/ops/special_chebyshev_polynomial_u_cpu_dispatch.h,sha256=j_7L8vpq0C99C7cuWaLL6Bpa9WSS51J24ZBD1bhX6XQ,1006 +torch/include/ATen/ops/special_chebyshev_polynomial_u_cuda_dispatch.h,sha256=yvk6Ai46pk8DrABh6vsAXnV5dVvdFRyYqts6Th2FEyc,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_u_meta.h,sha256=-D9fVQWkvdLBaZEPQlKHWJC8mPApd95Bhv6_sBnPWxc,629 +torch/include/ATen/ops/special_chebyshev_polynomial_u_meta_dispatch.h,sha256=7JSc9wJBBM5Wnw0IasGJPrXaT-B5rUFKOSH8iss3AOw,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_u_native.h,sha256=eErrULKwX5mpm928WV7oMtjWRHf6BUeXr_UcpFTwX_I,1134 +torch/include/ATen/ops/special_chebyshev_polynomial_u_ops.h,sha256=bLKWwrqeyACCLugJ-g2oLEkuruLjj7B6J6wxqFMSFko,4830 +torch/include/ATen/ops/special_chebyshev_polynomial_v.h,sha256=Utx9obKGJnD1jRrEQdgVdTb8JK7g4bfhjDqcc9TWnh4,3079 +torch/include/ATen/ops/special_chebyshev_polynomial_v_compositeexplicitautograd_dispatch.h,sha256=6J2FsUG9MKVeATJbjKUtk8z8My8Ph_s3j9j3RxXCSzY,1390 +torch/include/ATen/ops/special_chebyshev_polynomial_v_compositeexplicitautogradnonfunctional_dispatch.h,sha256=9cvNUDRc88CLFGJgbTPmB5VFqI3PA63r6V8N3O0TO00,833 +torch/include/ATen/ops/special_chebyshev_polynomial_v_cpu_dispatch.h,sha256=J7-BFd21sJu1WT5axGZtIttcx_kks55fmQCFeAOC2zA,1006 +torch/include/ATen/ops/special_chebyshev_polynomial_v_cuda_dispatch.h,sha256=U3YvcI9RAhQv7aDOUzvZna8m1Vdezpw3tU6u6RlpxoY,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_v_meta.h,sha256=SeAOK3o7ljl_-iGNKAywcPXTiZcsqQreFbY6IU4eYeQ,629 +torch/include/ATen/ops/special_chebyshev_polynomial_v_meta_dispatch.h,sha256=uOtifp6hnOSb3ckBjqNUxA-hjs0RRxfgRyU5cgb-zrc,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_v_native.h,sha256=-KG9nX3TlYwN8LBTvhXpVlBS759KrqqX6XC6BAm7GTo,1134 +torch/include/ATen/ops/special_chebyshev_polynomial_v_ops.h,sha256=CV8SH3zVzAUpXpelUM1U8Y03pcRk9nogwXo1MIwf5M4,4830 +torch/include/ATen/ops/special_chebyshev_polynomial_w.h,sha256=TIcKgRDpAMGeBPF_uAdE-hkgwe-4J961Fm88wcjDTg4,3079 +torch/include/ATen/ops/special_chebyshev_polynomial_w_compositeexplicitautograd_dispatch.h,sha256=1uYSq3PS-9ey1SThcT-5qEdiDcrf-ecImvEsyZzf3cg,1390 +torch/include/ATen/ops/special_chebyshev_polynomial_w_compositeexplicitautogradnonfunctional_dispatch.h,sha256=u5QPrFza1uFoaT5OaloEFEHLJTjGrqxobHkOM63mfm0,833 +torch/include/ATen/ops/special_chebyshev_polynomial_w_cpu_dispatch.h,sha256=YEvt-BjUt2aS_cqqekfex0HNkwDOQ7vM4e426fYePZM,1006 +torch/include/ATen/ops/special_chebyshev_polynomial_w_cuda_dispatch.h,sha256=9BNxFogiA1iKlXdhkbEHIqPciA8B_o5iUKij2g95jo8,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_w_meta.h,sha256=qm34gQ4ySuQW5swMqmKcNHxkvnG5vgO1UeqC4-uycRk,629 +torch/include/ATen/ops/special_chebyshev_polynomial_w_meta_dispatch.h,sha256=QoBjRSr8ZP5i8nFIyOCdUt3dz9GLBKdXehj65hsnwpw,1008 +torch/include/ATen/ops/special_chebyshev_polynomial_w_native.h,sha256=1Cxxg2qg5yBPFNnVvkAmKI074RDf_EzRBYPSyZMCT-s,1134 +torch/include/ATen/ops/special_chebyshev_polynomial_w_ops.h,sha256=0HDmhkqyXi_7n6Lr9OV304fnJKsrgZygTRJb6p3nXDM,4830 +torch/include/ATen/ops/special_digamma.h,sha256=fImRFybIzgAtR9ezpN5KYqTbaoxOkl_JskZzv-bmRtg,1105 +torch/include/ATen/ops/special_digamma_compositeimplicitautograd_dispatch.h,sha256=6w44bSSTZmKE1ZDj3hDLW4hkMwRlnDMFeP-ewFOcl8g,948 +torch/include/ATen/ops/special_digamma_native.h,sha256=BkQwcNokfT9ljOQELApp5beFqQKAgnlCfwlxIoQ2WM4,583 +torch/include/ATen/ops/special_digamma_ops.h,sha256=zvyNnX6tj-R9vMi9MgjRA3WOPS-EpD4rmmtXpGBSCT8,1644 +torch/include/ATen/ops/special_entr.h,sha256=HGcPkIM3gORuIrc1_dHmgjxpX6KA3n-c1ICdkB8XDbM,1075 +torch/include/ATen/ops/special_entr_compositeexplicitautogradnonfunctional_dispatch.h,sha256=KjDfuVMyVbkHAwN2bSyu2BCmbaYdD8tiG_OjT_P_x6g,796 +torch/include/ATen/ops/special_entr_cpu_dispatch.h,sha256=McR2Tw-PN0ls7ZM9RiN59USoxJnD2IIsfGZCyzwzrCI,895 +torch/include/ATen/ops/special_entr_cuda_dispatch.h,sha256=uTIkz7f9Md5faUax6Vbf_aX3vd4gycNxVcEwaEBhnWY,897 +torch/include/ATen/ops/special_entr_meta.h,sha256=sgigZgf6yYB0uDAkw5iYvnk1K8rXQGGbcDoE4LRlT_Y,592 +torch/include/ATen/ops/special_entr_meta_dispatch.h,sha256=qBJhu0Z-NTtoEhORfsjVO_gy8uXspvtIafFig3bPjhs,897 +torch/include/ATen/ops/special_entr_native.h,sha256=X2d58KY1bK1Bb22ujz2ZLQpacd_APBmzj0c05cCvd_8,625 +torch/include/ATen/ops/special_entr_ops.h,sha256=xVOKZWhRpQNqf1bWHldXPBQvVAp3OJjDNNhBvRDca5E,1626 +torch/include/ATen/ops/special_erf.h,sha256=FDEqxrP8HISwCPYMNmTOqFjk_MGOVmfgXRO2uWJ6SHI,1065 +torch/include/ATen/ops/special_erf_compositeimplicitautograd_dispatch.h,sha256=LXyIpJtkmL8sWHfvO4zyFbhysvzz-HDTaoyOACIdlzg,936 +torch/include/ATen/ops/special_erf_native.h,sha256=9LhOv9DvGjlaKADPxMelj8V2i2XlqB68osTbRUf5gWU,575 +torch/include/ATen/ops/special_erf_ops.h,sha256=uM5_oNMDyUx9hBGHBvRCxlfxqet1y4TtYcZDSpyMG94,1620 +torch/include/ATen/ops/special_erfc.h,sha256=FeWNYd5D2XHfPwF2jA-VQ6F4u7t9L368Atu1gc9oocg,1075 +torch/include/ATen/ops/special_erfc_compositeimplicitautograd_dispatch.h,sha256=7VfX4Vi5s0HJhP1JBbeCaPpfd1ToMQ2CllbU8mMuZoY,939 +torch/include/ATen/ops/special_erfc_native.h,sha256=WNlJduQXwHpfUIEG-5u72D18Yn0cBJZgqnom-w1obSc,577 +torch/include/ATen/ops/special_erfc_ops.h,sha256=vubcDnnx_6VuFANCDUo8CHyuBBfRTmbK8_dyVWebuW0,1626 +torch/include/ATen/ops/special_erfcx.h,sha256=G5W_4EuinCAZBF8EfoiI3g4LBNL2Rrc9c-38N16VCSA,1085 +torch/include/ATen/ops/special_erfcx_compositeexplicitautogradnonfunctional_dispatch.h,sha256=oUGC1DgJYkoP7bsHoaoErmaG2Rh0IJGSw7TkuVdbORM,797 +torch/include/ATen/ops/special_erfcx_cpu_dispatch.h,sha256=-PMyWWGc4qpjY2VsgmVsW2rN3NzjFMJlA24EOBNPbgk,898 +torch/include/ATen/ops/special_erfcx_cuda_dispatch.h,sha256=h64IJWxMneBUlrl1qBI260TcM9-oujtC5gJ-nTKji1I,900 +torch/include/ATen/ops/special_erfcx_meta.h,sha256=vCenG1FKwYQf-albTi1gxd54tIpZGI4z9Q1HmItdTVc,593 +torch/include/ATen/ops/special_erfcx_meta_dispatch.h,sha256=YsnhB4hBJwdoRCUgoZ9GJHp9Zq7w0pkZaD1-TOFpTtY,900 +torch/include/ATen/ops/special_erfcx_native.h,sha256=MShmW0C4dxM28AmoSp-lo7cDBZK29t4eDqQ0B1JhTEA,628 +torch/include/ATen/ops/special_erfcx_ops.h,sha256=cSKw_y-fAPBWI2ksgLe8SNTOh0lPM0sza-Izv_GhnTU,1632 +torch/include/ATen/ops/special_erfinv.h,sha256=dDX4UNcA_OLwp8GCHHBLVxdJS3Z6YsgVvi--V8xhAHQ,1095 +torch/include/ATen/ops/special_erfinv_compositeimplicitautograd_dispatch.h,sha256=RfLsNZLPvJFL_W82R-WqbREDQheGBxutpM2tLKCt-bM,945 +torch/include/ATen/ops/special_erfinv_native.h,sha256=H4rn_6uL4zlBiCi7akks7Ar3SZiSnAbhLO1lX1E4M5g,581 +torch/include/ATen/ops/special_erfinv_ops.h,sha256=LKzCkmIxYOSMCkCOBClyXRDYRMk7y_NI3OWM3NBYtUg,1638 +torch/include/ATen/ops/special_exp2.h,sha256=UjsNH3tDQ6a_JrrY13lYsluDUjt_QAO6uLd5p0Drh48,1075 +torch/include/ATen/ops/special_exp2_compositeimplicitautograd_dispatch.h,sha256=F0aiY7TNNLmvPFPF1kBI-9yw0MfNKAAYJ_iZJb_P1CI,939 +torch/include/ATen/ops/special_exp2_native.h,sha256=WlNB8buS4UP7o8bPsOgUJVFMOsciYlhdYNOHjtsf5KU,577 +torch/include/ATen/ops/special_exp2_ops.h,sha256=hES-uw9i4UNMSv2hkIISLeruKdb5EmVnjun5yZa95Ms,1626 +torch/include/ATen/ops/special_expit.h,sha256=yB3j_5_y-2T4klpy9l3039ktURJK3_i0tfXRxXUVwr0,1085 +torch/include/ATen/ops/special_expit_compositeimplicitautograd_dispatch.h,sha256=zLWyfpT6oltRy4hTiJCODeKw3F4sEl7O6QLlkdPhmRg,942 +torch/include/ATen/ops/special_expit_native.h,sha256=qTnY0GfUmNmJTDl6gb3Ns5ozrpuogmVTqB2k7utu95g,579 +torch/include/ATen/ops/special_expit_ops.h,sha256=4ywvtPRCyTFbpeiuFA3AmwX_fI8-xaPONMqPgoQjT_8,1632 +torch/include/ATen/ops/special_expm1.h,sha256=ZSAJ-Pm4np-tZl96YdbMXG2Yoy4l27CBjtukgXroJH0,1085 +torch/include/ATen/ops/special_expm1_compositeimplicitautograd_dispatch.h,sha256=jbGsPGS3jR9Dw7iHdLF_pwpkyI3JN4QcQvqzCDOE1G8,942 +torch/include/ATen/ops/special_expm1_native.h,sha256=7eWlT5UN4aYHP5ul0VwHLybLVN5Ob56EdzSJwj0HRv0,579 +torch/include/ATen/ops/special_expm1_ops.h,sha256=Ic9IUX5-IvheDCfhGNbAzl1UHicKQeuBxdyApsNiwtM,1632 +torch/include/ATen/ops/special_gammainc.h,sha256=Dm4qHYSZh93qIauiJNUISTdyvf9KMNeV33Kh90U-ydE,1256 +torch/include/ATen/ops/special_gammainc_compositeimplicitautograd_dispatch.h,sha256=UR3bqb2Ns6VYkHEJQTdM31uRgNXNDWEgFIH7aJPJxuw,1029 +torch/include/ATen/ops/special_gammainc_native.h,sha256=k3K1Uckdsktb4RGn393pPXRPCtZQ23qFocaIwzed7JE,637 +torch/include/ATen/ops/special_gammainc_ops.h,sha256=YFoYTS-Vui2IXs3TSDtI97GShGK62Hy6QQlVOh_75Uo,1822 +torch/include/ATen/ops/special_gammaincc.h,sha256=l_LeHIoNi690iG5P6jNf0mgqHP5y-OSL3j1H2GVfM9U,1266 +torch/include/ATen/ops/special_gammaincc_compositeimplicitautograd_dispatch.h,sha256=WjrBNFqp5eMRJMcsGkTf5PfwKYnh7jyVEs7RmKc24Rg,1032 +torch/include/ATen/ops/special_gammaincc_native.h,sha256=nzVqNQtZ18SI3OSjNUpLbc2CU1IXt0D2_ewMEhRkHto,639 +torch/include/ATen/ops/special_gammaincc_ops.h,sha256=15v-RjiX_HMKSmA6OoHGpfMqEjEKo2scQcMIMDPS9rU,1828 +torch/include/ATen/ops/special_gammaln.h,sha256=Ltr3FR40oz4LrOUrpZSeR3CmRMtT1HkvuOTtZARTiuU,1105 +torch/include/ATen/ops/special_gammaln_compositeimplicitautograd_dispatch.h,sha256=hAn1wR_BMq-a8NzzClfSKgaCpw_kjo1LQGEtMyk-8Lc,948 +torch/include/ATen/ops/special_gammaln_native.h,sha256=lUhlNKwPThgD9Ggn-dSf8zgejGo0lEoCjvQsN8C96KA,583 +torch/include/ATen/ops/special_gammaln_ops.h,sha256=scQvLM18aOXzB5AZugfebq7Dy5QkECmdw9MclOgv7FU,1644 +torch/include/ATen/ops/special_hermite_polynomial_h.h,sha256=v-o-in134Idub_xADNS5LRmKfymTouj0LFHvKwr0Nvg,3023 +torch/include/ATen/ops/special_hermite_polynomial_h_compositeexplicitautograd_dispatch.h,sha256=AanUrIkI37hSFJTv10akpZmhHxKqGn_0HsK3h-s6SV4,1378 +torch/include/ATen/ops/special_hermite_polynomial_h_compositeexplicitautogradnonfunctional_dispatch.h,sha256=swBvyPyyLRgoA7CsP3p3he2c5T8-ZIupTO8674pbJB0,831 +torch/include/ATen/ops/special_hermite_polynomial_h_cpu_dispatch.h,sha256=aHvWfOMs6yuooiZy1D0ibSnXiLZVg1ZVvsg0_uV4B2k,1000 +torch/include/ATen/ops/special_hermite_polynomial_h_cuda_dispatch.h,sha256=iG6l52b3uKWMUm33dOgBF0FFgfpdi7YcHuLZcZNyjz8,1002 +torch/include/ATen/ops/special_hermite_polynomial_h_meta.h,sha256=EhP6a3BGaWHVnWzvoNZXXxxcLAcAS51F-zkpwoEbOqY,627 +torch/include/ATen/ops/special_hermite_polynomial_h_meta_dispatch.h,sha256=gXkYp_tbQc_G5MHf3-DktLl8mr2HSVUZ4Vkl954Ircc,1002 +torch/include/ATen/ops/special_hermite_polynomial_h_native.h,sha256=89xU2JFwvQ1CgeZKLRYiCPPQJFC7jneAIF-jUyNBcJs,1120 +torch/include/ATen/ops/special_hermite_polynomial_h_ops.h,sha256=l9G-1UuNOWLPDg9RjqZu87Fey_QJCCc1I7xaI-g15zk,4794 +torch/include/ATen/ops/special_hermite_polynomial_he.h,sha256=42_Zj1_MDKlI4ZqnBsNGzknlRHswwlpmL0sX7LAnK5k,3051 +torch/include/ATen/ops/special_hermite_polynomial_he_compositeexplicitautograd_dispatch.h,sha256=A316dOAobAqpM6DHX8vYkn-UL1bR964IVXUGLTUVFpQ,1384 +torch/include/ATen/ops/special_hermite_polynomial_he_compositeexplicitautogradnonfunctional_dispatch.h,sha256=S_If2JhnUk95N3pFflFSFYixYO_wluYXF4VetvNyuhQ,832 +torch/include/ATen/ops/special_hermite_polynomial_he_cpu_dispatch.h,sha256=EAO8DuqY7mNku7MlGD0WRgJA_tl6oK5jEsUsP3rXZNU,1003 +torch/include/ATen/ops/special_hermite_polynomial_he_cuda_dispatch.h,sha256=z08zVsqCjdwEqxt6yP4ZCpzzebXaVill_eTrbTQw8kM,1005 +torch/include/ATen/ops/special_hermite_polynomial_he_meta.h,sha256=SnGV_sFsNbCu_WRNK4E-PgmHpUQT9vnBhVR5X6gvJIM,628 +torch/include/ATen/ops/special_hermite_polynomial_he_meta_dispatch.h,sha256=IKHgF0NnGFI0g7m81VIBs3Ow7mA6Pqaxa7S9c0yAttM,1005 +torch/include/ATen/ops/special_hermite_polynomial_he_native.h,sha256=-wMYiryCg6XDKaFbY8su3GPms6vqgG6LqwAm1Se7pj0,1127 +torch/include/ATen/ops/special_hermite_polynomial_he_ops.h,sha256=FTrLv8U7BXWNVwxeK9FBN0hROpneh-97Ldpp5LEMmCE,4812 +torch/include/ATen/ops/special_i0.h,sha256=8GjJOQDc9kT_QomiMx6pkO0H3Gvi_M9vywQXyJxmwNs,1055 +torch/include/ATen/ops/special_i0_compositeimplicitautograd_dispatch.h,sha256=ibY7ZlRGRZZ65j7WpN2ayj6wjEb2mfp2NXVoP29m2Ls,933 +torch/include/ATen/ops/special_i0_native.h,sha256=GmHDOaU4TfLiRqGTcOEV3i5b7m07RBHdTmF28LAMQPQ,573 +torch/include/ATen/ops/special_i0_ops.h,sha256=cuIFuamyGK402XKJ75dsKEGyldGU1R2mDyjPPUkxyXI,1614 +torch/include/ATen/ops/special_i0e.h,sha256=y07XsAx_zGMc5LPv-wq1PF4iS4Rf-MBhUxTskzW1ufM,1065 +torch/include/ATen/ops/special_i0e_compositeexplicitautogradnonfunctional_dispatch.h,sha256=NSQBbBZMMw7qtku-SGq3OKeAZtr8G8WeNuLBN6hAbrk,795 +torch/include/ATen/ops/special_i0e_cpu_dispatch.h,sha256=PZYXMweF5rHdNV56LKtYyIhHzQ-d123DOUMVvCgZ0i8,892 +torch/include/ATen/ops/special_i0e_cuda_dispatch.h,sha256=-5xBTZnY-Qq714DWuItlqQgOCuSc4jIYzDvJgqfws70,894 +torch/include/ATen/ops/special_i0e_meta.h,sha256=zGgGFwXsSFt2KOS90YMLH6RuZg6JHzUWLRBCm1FjTug,591 +torch/include/ATen/ops/special_i0e_meta_dispatch.h,sha256=ntwsVqswnn85egNYDVgPU_pEkNWAtNIDrPgaQOWlL4k,894 +torch/include/ATen/ops/special_i0e_native.h,sha256=dtnGUaAhQ2zrWi04dSMmbGX1qlzen7lHwdy7wgYl_pE,622 +torch/include/ATen/ops/special_i0e_ops.h,sha256=EQTREZ-Y7tnd6gXkjMpNB-tPbmAH_C_T5Wr6MZ4Eal4,1620 +torch/include/ATen/ops/special_i1.h,sha256=Y5e8VcEts-cYfOORc62aKn4-qUGZoi5UGDF3iyU49Fc,1055 +torch/include/ATen/ops/special_i1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=fQxWBf1SGPf8nNY2M5yagDETxXeIjGkwUJd4IvdUzDA,794 +torch/include/ATen/ops/special_i1_cpu_dispatch.h,sha256=i4E72MJwNH617AOJcu4xUNqSJJwR32hA6RXpLBkmhVs,889 +torch/include/ATen/ops/special_i1_cuda_dispatch.h,sha256=5s4xuDgy7sscUnwtIPZukrcB9KORrj4iVZTj1Kjxxfk,891 +torch/include/ATen/ops/special_i1_meta.h,sha256=jovIk3YD0vHH_mnLM2N9j9R2HAa6XJ8JMgqIqBqpGik,590 +torch/include/ATen/ops/special_i1_meta_dispatch.h,sha256=HeD0y25IzkJ51K16PQqlKQ5njfSwMRx7XvdYH0LySvs,891 +torch/include/ATen/ops/special_i1_native.h,sha256=Ed2h3HNuo-kwxdZ9ZrjBx8cHA0WQToMb5vxhcKTDETg,619 +torch/include/ATen/ops/special_i1_ops.h,sha256=7Jv716TUciZ-hlfkjph92DhFHWL8DhbW_QXueFybOtE,1614 +torch/include/ATen/ops/special_i1e.h,sha256=IGSmZfHLdmJdba1uvKNBFFnH09pZk3jOJOPXN46fPnM,1065 +torch/include/ATen/ops/special_i1e_compositeexplicitautogradnonfunctional_dispatch.h,sha256=o05RBzmqTnWMQs5ONUUBiCrWUz_T4YvJihoQWInsC7Q,795 +torch/include/ATen/ops/special_i1e_cpu_dispatch.h,sha256=ibSYEnHh7G-MvopZMljLKQy8tpzgSZ3-ZCELTXPooAo,892 +torch/include/ATen/ops/special_i1e_cuda_dispatch.h,sha256=n_Me5OC126v09hW4lrzI1djyAlqp0CchnECh8a5mR5Y,894 +torch/include/ATen/ops/special_i1e_meta.h,sha256=APhaLDcVHV732Pdkb4aKuwMvvqcbDtwbN5n9R3lR0ak,591 +torch/include/ATen/ops/special_i1e_meta_dispatch.h,sha256=i0JPXilT0kpxzILbdUzJrXDA7Z8RzOkh7nr81lOhK0w,894 +torch/include/ATen/ops/special_i1e_native.h,sha256=siaT3y4IWFMtYRuPTnvdhYdc-V5gjrEYyCmdlxe09Zs,622 +torch/include/ATen/ops/special_i1e_ops.h,sha256=Ralx8u0c9kFGZ5vRy7HgyrTi0JQHbv-ID8G2dB6VPn8,1620 +torch/include/ATen/ops/special_laguerre_polynomial_l.h,sha256=CjMYpmNrvWr76z5ekM2WVUTR2IZOwmcjX9--9wRHREw,3051 +torch/include/ATen/ops/special_laguerre_polynomial_l_compositeexplicitautograd_dispatch.h,sha256=oL8oD-J6rBm1bMClvOFWRXtuUXMQPbsfhn3NXSErwv4,1384 +torch/include/ATen/ops/special_laguerre_polynomial_l_compositeexplicitautogradnonfunctional_dispatch.h,sha256=P2AYbfKeZoasu9IA5LnQXYMvKr4mcn4hSSrD9YhfTXA,832 +torch/include/ATen/ops/special_laguerre_polynomial_l_cpu_dispatch.h,sha256=8qWQhqj7r2vrbj4potQdc8xyGKhCzgCUqba-DeNcyC8,1003 +torch/include/ATen/ops/special_laguerre_polynomial_l_cuda_dispatch.h,sha256=xSUPWtXWQkUWh623zTcY-8q3QVW8D7koGmlIc0Pzx-s,1005 +torch/include/ATen/ops/special_laguerre_polynomial_l_meta.h,sha256=Vfh10a9JybYEx1t6vwee6EJhk9bnr9ZITvAcGRG2-_o,628 +torch/include/ATen/ops/special_laguerre_polynomial_l_meta_dispatch.h,sha256=PU-mKJD_HbTwLXZP37dPraUziXr7V7b6j5uQO8Q4Dbw,1005 +torch/include/ATen/ops/special_laguerre_polynomial_l_native.h,sha256=0IbC-YKKjZ7bhNKJ2aSLGj41U4e_ulyiSi2-2yxHY-0,1127 +torch/include/ATen/ops/special_laguerre_polynomial_l_ops.h,sha256=nEHZDgRnXeQVxKeVjffxr4XXkBo-Qmczs-l_AJvXJmY,4812 +torch/include/ATen/ops/special_legendre_polynomial_p.h,sha256=Wb8xW3DP_i4ZeHYnFrCvfaFekz1nrWkdltmu4G-FUT8,3051 +torch/include/ATen/ops/special_legendre_polynomial_p_compositeexplicitautograd_dispatch.h,sha256=v4k_IW3h5mIVXC-Yld3gVAY0ZVSSzorYUEmcCw8zUmo,1384 +torch/include/ATen/ops/special_legendre_polynomial_p_compositeexplicitautogradnonfunctional_dispatch.h,sha256=WJ4NXiY-HODQcIPIeKKIqeCPGUSe-rtKCTG7eOoGJE0,832 +torch/include/ATen/ops/special_legendre_polynomial_p_cpu_dispatch.h,sha256=rMzkXojw_UFEbtv37ljvw39uSwCm_eneOUTSW8_ZPS8,1003 +torch/include/ATen/ops/special_legendre_polynomial_p_cuda_dispatch.h,sha256=6_aBcam1NOo0Rffz-2Onljww770_ifYYEh38tEsTRMc,1005 +torch/include/ATen/ops/special_legendre_polynomial_p_meta.h,sha256=lIyjKH6OP_srsSl-MrMY9RWiyJIDhXgjyaALdrj7UiQ,628 +torch/include/ATen/ops/special_legendre_polynomial_p_meta_dispatch.h,sha256=F31HVELU-CO4jkvo0ia_REk_p1Ah24hHMsvgoF46eu4,1005 +torch/include/ATen/ops/special_legendre_polynomial_p_native.h,sha256=_66kHwTSl5YBefM-MdzfnmwDSQPtxfjqS2UzAOPAuTA,1127 +torch/include/ATen/ops/special_legendre_polynomial_p_ops.h,sha256=u6voIVfiA5l5fif_8H8bbS7RTHIOJCJJ_JCkWZUuFE4,4812 +torch/include/ATen/ops/special_log1p.h,sha256=0iiEaypeCyvT8eq10b9dww1ztKarbbSf-x4vQkyK7B0,1085 +torch/include/ATen/ops/special_log1p_compositeimplicitautograd_dispatch.h,sha256=dA5Md7NFpvtf9_Eq2S6Z9ZHG4BbGMp2mTOrtfv0WOCo,942 +torch/include/ATen/ops/special_log1p_native.h,sha256=MqP3wL3mqP9ZZU48tbMdXe0RdgJcgmyGY9HmVQhom0w,579 +torch/include/ATen/ops/special_log1p_ops.h,sha256=ZaDyVd5p5twXVmIescoEiJXVIKOsHpLKRhtWNSfVdYQ,1632 +torch/include/ATen/ops/special_log_ndtr.h,sha256=0JSr9Ku3-mWv4YTZ3Pl3766SLpemIoZFfwUdFosIoGU,1115 +torch/include/ATen/ops/special_log_ndtr_compositeexplicitautogradnonfunctional_dispatch.h,sha256=iiv-Xu799BLI1CcYa-xBmNh87WmM9YBYQlvxx22cz1k,800 +torch/include/ATen/ops/special_log_ndtr_cpu_dispatch.h,sha256=aZ-t2T-N3-IKF47DPQGKE0Yg65l-z09ds7aRJahEN2o,907 +torch/include/ATen/ops/special_log_ndtr_cuda_dispatch.h,sha256=ll7Pxu5LEo4IsYAvHiG5wNe7nRSJSxiAtboO4iagr1Q,909 +torch/include/ATen/ops/special_log_ndtr_meta.h,sha256=oBbz-y9tD506-mJ-rMlhiZaDKUJii2abVajXWVBoRGo,596 +torch/include/ATen/ops/special_log_ndtr_meta_dispatch.h,sha256=p-cV0kYYDijY4J1dmWjtKEdAey60AsndLeWH5pL7VNc,909 +torch/include/ATen/ops/special_log_ndtr_native.h,sha256=hvWK3tpTFLtMiX2n9RL2ukE0HCONIWkMwBvEzilrZHk,637 +torch/include/ATen/ops/special_log_ndtr_ops.h,sha256=VA5Ev0Y-PPunDfyPGDdWOQPvz1t13z0-svB0Ktj66zk,1650 +torch/include/ATen/ops/special_log_softmax.h,sha256=z0eP7rRxl61GuYxp3MYJKb3HBV-ZF1mK6zBtYEeed4o,788 +torch/include/ATen/ops/special_log_softmax_compositeimplicitautograd_dispatch.h,sha256=NCUT7p3I2mY7DPvGov9cyJ2PadXOuInWYlNuRVkf63I,840 +torch/include/ATen/ops/special_log_softmax_native.h,sha256=nQzh2arDULStwQwmgrtkKEWFLUIbQNjM9UG6tL_oL3Y,563 +torch/include/ATen/ops/special_log_softmax_ops.h,sha256=yKAP0iYIAteqzkEvvL6ahPehqNFMsIKL6JuWusCj0SA,1182 +torch/include/ATen/ops/special_logit.h,sha256=Tp50lfi-uh0EVL_iiMmLC8-a8iFrM5KwsGhvMZXmqiM,1258 +torch/include/ATen/ops/special_logit_compositeimplicitautograd_dispatch.h,sha256=RP8UCYxROesJLmJ9tZZp7U9Y5QXNFUuY-Lheeh3KSc4,1049 +torch/include/ATen/ops/special_logit_native.h,sha256=vbHm7MLxJaZ8yZnFvLEOeg9UTl_lKJSUc59gvwih9K0,646 +torch/include/ATen/ops/special_logit_ops.h,sha256=hAlomd0iKbFvmejwEeNmvwrirF-urTDge_6gfqpW5Wg,1820 +torch/include/ATen/ops/special_logsumexp.h,sha256=IpjkvHHsJQKJMte-yyoXVDCAP5obwMs1WRrsyfCNmWE,1380 +torch/include/ATen/ops/special_logsumexp_compositeimplicitautograd_dispatch.h,sha256=mNTT1HyXqJ0v9CGT387VGXuERWo_ZOgAaGSt6rbUydw,1071 +torch/include/ATen/ops/special_logsumexp_native.h,sha256=yjXRxo9-gSOZAq8KrLjdCZhH0ZdRWZypBFJp5bpggmw,663 +torch/include/ATen/ops/special_logsumexp_ops.h,sha256=KwxWCg8W37ocQ8ZvrRzwi-e6ICenu2h3yluGAY7mhkE,1906 +torch/include/ATen/ops/special_modified_bessel_i0.h,sha256=pvHHsq5v61yU3LYj3Qv5YWi7X1pYBEnO761jmC3rByk,1215 +torch/include/ATen/ops/special_modified_bessel_i0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=pFTxQmlG8pJC5wjAVnCD2hF96-LxD9VhfYzncPFdNLg,810 +torch/include/ATen/ops/special_modified_bessel_i0_cpu_dispatch.h,sha256=OBkfCgQ-NHvj-F4xwBogc5kWLfZmg7iKfX84thPxVpg,937 +torch/include/ATen/ops/special_modified_bessel_i0_cuda_dispatch.h,sha256=ZD6Gc5h0xd2KfPrQu2dhB3lBItRroyDYc03KXiX_SOY,939 +torch/include/ATen/ops/special_modified_bessel_i0_meta.h,sha256=OvI6KRkcr3zi8OlUi_PSuRO8gWg7vjHkZft2ACynuX8,606 +torch/include/ATen/ops/special_modified_bessel_i0_meta_dispatch.h,sha256=afJwqTFPtmST8QP15q0uBie5LuCrxi0Uf7vTKUZ9z0U,939 +torch/include/ATen/ops/special_modified_bessel_i0_native.h,sha256=2Ozgrf6AlxeXVTKiKB5N820zZIldS8Dx6fFh9ovjzMg,667 +torch/include/ATen/ops/special_modified_bessel_i0_ops.h,sha256=0-dA6QjwpRS_Z8Z5DbE_10aiUmtO3dQ4yMyL49SN7s4,1710 +torch/include/ATen/ops/special_modified_bessel_i1.h,sha256=-bKpY19fIas2qIO7FPLWcskj7if9SgFShJQq9yPNiHg,1215 +torch/include/ATen/ops/special_modified_bessel_i1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wM70WeVPkJ6u_izSY-YHTeYkNRsZN7ghmJ_Qgw4krkw,810 +torch/include/ATen/ops/special_modified_bessel_i1_cpu_dispatch.h,sha256=w-6Cr8smBL9DcjILWiwxEpeR0vtpRi5kYPC3SeRdkVY,937 +torch/include/ATen/ops/special_modified_bessel_i1_cuda_dispatch.h,sha256=UOpJamzlZR8zxJXHrsN2YKAi8KZBBxncTvAjGq5mBxo,939 +torch/include/ATen/ops/special_modified_bessel_i1_meta.h,sha256=Bh0Ekm7G7ZobvST7CAryUbqkYEm-3uxFvzfz7WJk42E,606 +torch/include/ATen/ops/special_modified_bessel_i1_meta_dispatch.h,sha256=C-_cMGprsHLXNMaPg0xOHLyHP4a7Q4yzWMAsUqNQxnY,939 +torch/include/ATen/ops/special_modified_bessel_i1_native.h,sha256=xqRDRSW-wuoe2SfsPxUv1ocvW6KK-Cn6zwZL3Q0VmDY,667 +torch/include/ATen/ops/special_modified_bessel_i1_ops.h,sha256=gH0X72KMqEDMf2bRDcjfrwNO7aKHMafK9fZECiiwP_A,1710 +torch/include/ATen/ops/special_modified_bessel_k0.h,sha256=OtrFqL1mOmsltBTdM3IJN4incJFXxFs3Lyms55D1iCA,1215 +torch/include/ATen/ops/special_modified_bessel_k0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=BYumZpNsKhBrXX_J3eMifksgroqksjwnkSec10VPqJI,810 +torch/include/ATen/ops/special_modified_bessel_k0_cpu_dispatch.h,sha256=cE8X1_CwSFgWTO0pUqkHC0L5aNGD-JKFSWbQBCIZLPg,937 +torch/include/ATen/ops/special_modified_bessel_k0_cuda_dispatch.h,sha256=BMacjV3y9H5IY81d42d9SL-gVcas3HALmemIqxWgQ9A,939 +torch/include/ATen/ops/special_modified_bessel_k0_meta.h,sha256=qxU4gkKTepg0o-R5UIZ-FnN8dE-3JYrQgfGKMqoeZmI,606 +torch/include/ATen/ops/special_modified_bessel_k0_meta_dispatch.h,sha256=DgSCw1RtI4P7EFRrwYucRy4DXKZ07fWHts-C97x5qsU,939 +torch/include/ATen/ops/special_modified_bessel_k0_native.h,sha256=kiNwL91XnNxNkqsyPrlKqYZbRe9UW39ajmB4qgqsCMg,667 +torch/include/ATen/ops/special_modified_bessel_k0_ops.h,sha256=VieDG8hQwvO7nsqv535KmvqlwhmsGfCs3r3oAqkHiQA,1710 +torch/include/ATen/ops/special_modified_bessel_k1.h,sha256=1BaKi8A8DmDwoTfJ6YCRJsOJ17YRqElRwtGhc5_Y_50,1215 +torch/include/ATen/ops/special_modified_bessel_k1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=iKZaHnz44a25gWntfGs7NxDc3a4BQL0XmoERC02CRjY,810 +torch/include/ATen/ops/special_modified_bessel_k1_cpu_dispatch.h,sha256=dOLY08GTl629mUEiRTPl_iJO2Hc4TmMu4j_mX3hR_Tg,937 +torch/include/ATen/ops/special_modified_bessel_k1_cuda_dispatch.h,sha256=XKAPyZU2eE0VEQXdGQ5CPpH0twKZV2XzkyeVENoGZXk,939 +torch/include/ATen/ops/special_modified_bessel_k1_meta.h,sha256=FoW_iqt85oAWuRXgphFYDUeTgEVfv1G-BsGfHoKQlok,606 +torch/include/ATen/ops/special_modified_bessel_k1_meta_dispatch.h,sha256=6IJ0EyYaXDwZupjgU6vnnEbrRQl7e-Q51IOkXRMtxyg,939 +torch/include/ATen/ops/special_modified_bessel_k1_native.h,sha256=v8u9bjOGFMLNmdnnT8Os66EwfgG5n2YHRgp835jF-H4,667 +torch/include/ATen/ops/special_modified_bessel_k1_ops.h,sha256=Zd6DmwM6wi7H1-EqHUeOtr0PeFgGjmjQkWL2PTsI7vM,1710 +torch/include/ATen/ops/special_multigammaln.h,sha256=Z4lK83Y5Ltkz__OH51Mg1TKUfQKB_iIpcnkelHYyvNA,1218 +torch/include/ATen/ops/special_multigammaln_compositeimplicitautograd_dispatch.h,sha256=82J93BYLEfBwmbqgSMnFghLX8DMk0T2u0wm_hq0mz-g,996 +torch/include/ATen/ops/special_multigammaln_native.h,sha256=uKTxD7sIJYCg0sEww4mCMxkH10Ks4u72g42hlcHiwgs,615 +torch/include/ATen/ops/special_multigammaln_ops.h,sha256=Et-xQdBBvpXKZUIRviXwOVgGRwrBhTYXGK72IcZWR0I,1750 +torch/include/ATen/ops/special_ndtr.h,sha256=tHu56ZqoenI5K2eXt8YFKyQh8r6xppYhAEiBxSoOzys,1075 +torch/include/ATen/ops/special_ndtr_compositeimplicitautograd_dispatch.h,sha256=H82QwdT47klwN0toZ6bPtyQHFdpO_jWCpYVywACRzrA,939 +torch/include/ATen/ops/special_ndtr_native.h,sha256=kW7ZSEtSfZoGbynfMSfhviZeuLav4RsxqBkuiO9D4fg,577 +torch/include/ATen/ops/special_ndtr_ops.h,sha256=lY5xcactJW_OfmmPJeOhXCRhbBiL01BVBw8S6_2_AUI,1626 +torch/include/ATen/ops/special_ndtri.h,sha256=HVMkBvbPHN0iIpgufFVphDRaMvwtI3hymK4ooNmQx8E,1085 +torch/include/ATen/ops/special_ndtri_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ENAJDN9CjseR0VgQFLywB8a94r20_LeNIsihKRqS0u0,797 +torch/include/ATen/ops/special_ndtri_cpu_dispatch.h,sha256=bM_BCYc949KX-D5eLsQws2ymflbbOvaISmEBAzNIA6I,898 +torch/include/ATen/ops/special_ndtri_cuda_dispatch.h,sha256=f1MFG28KQOXpkuDxKGjaVmtnhHGiyxniq2Qo09HYttU,900 +torch/include/ATen/ops/special_ndtri_meta.h,sha256=LfWwqFoZN0VZDZHrwBDoqoyFfdyg0P6PWkHAh1wD1z0,593 +torch/include/ATen/ops/special_ndtri_meta_dispatch.h,sha256=x6pXJRL1UkZkXRIoJO4Tw6JWpULPkQLcVkFDuw3Cw_I,900 +torch/include/ATen/ops/special_ndtri_native.h,sha256=P0M39iULsbmu17c9K-YvV_eZmNEZcm8FeaBlWfdkMrM,628 +torch/include/ATen/ops/special_ndtri_ops.h,sha256=xR8MRHX7JoROzjQS15_BrpQy0EKO46jb8wiiy3dsOak,1632 +torch/include/ATen/ops/special_polygamma.h,sha256=BJ9RZDICdMA_81Q-8M3tJShpTsRJ-fvK_rMDxuUsdRA,1188 +torch/include/ATen/ops/special_polygamma_compositeimplicitautograd_dispatch.h,sha256=URzm656vMhQ0cEV6jnK988gAb76F7OkveQE-QsELV5I,987 +torch/include/ATen/ops/special_polygamma_native.h,sha256=LPUkZKHhkpZZOh_Ci6fGu3kic7OShv6kxGN1I69hwmI,609 +torch/include/ATen/ops/special_polygamma_ops.h,sha256=QybAlH-13uugMkaQ75HICpWdo7uz6XSViJDGEjbL8Ho,1732 +torch/include/ATen/ops/special_psi.h,sha256=VhQB2b83pBb56d91vl9DJwjnpyQXl_CIojzEkas-rpM,1065 +torch/include/ATen/ops/special_psi_compositeimplicitautograd_dispatch.h,sha256=fV2_XWltrtP-QOC2biahvv4YVPev9VFN_eI2uAskoms,936 +torch/include/ATen/ops/special_psi_native.h,sha256=XAKeoOWnGwyF91XacFDaQgg_CigN1ccS6mpieW5_AwE,575 +torch/include/ATen/ops/special_psi_ops.h,sha256=81QQq0Ph7HeK_cYCDf92KgU6RgXy9qDC2-wI1wYcXyA,1620 +torch/include/ATen/ops/special_round.h,sha256=6BKXxRiftZAFrKekG0GGxYIvmlmjjQUn38MwSEarqMw,1224 +torch/include/ATen/ops/special_round_compositeimplicitautograd_dispatch.h,sha256=sXOLVpyyJ9aGYKDH3QlsyzYM-YujyOZSfYOrp_cPtUQ,1000 +torch/include/ATen/ops/special_round_native.h,sha256=QA-L0BoHXS_bBUYq7SR1CleY8opHEwm1_4HDWzPeeyc,617 +torch/include/ATen/ops/special_round_ops.h,sha256=aFbXqeFC7wZ2PO3o5i3T5f-7uKTkZGbRwv2FrVi_uxs,1757 +torch/include/ATen/ops/special_scaled_modified_bessel_k0.h,sha256=mXFBxSV1TbqjjafWR2icJ1VKnUcOeuFi4hU9HcdhTJ8,1258 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=RVFjNrgqHV1OUgeJLheVcKc-1i6XELYH8u_HR3-8Ewo,814 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_cpu_dispatch.h,sha256=67CKI6AU3pdHE1Q1KgIknBFB8khk4LCIHtFmqOkrLSA,949 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_cuda_dispatch.h,sha256=JRc29qO6gMHQxWPOJswm9IIaOFSd78WcVBdWUOxKrXw,951 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_meta.h,sha256=mOmOXxDKqkiW8JTQ4ceZbnBWlNhJb2Afeye4uqXnW7Y,610 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_meta_dispatch.h,sha256=CH8pvStEioadt1rzmChjQatl4Smzmz8vHxjffF3IGQw,951 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_native.h,sha256=yMPjzr6-D18JW8u8bLbFbV-BHMWQWS5-zGw39KFEBWw,685 +torch/include/ATen/ops/special_scaled_modified_bessel_k0_ops.h,sha256=PN9Au9i31DrMLJTI00EGVe5v_OIQuDS0JYMsm3LhHX0,1734 +torch/include/ATen/ops/special_scaled_modified_bessel_k1.h,sha256=v9_U8lr1DRIawL4hopCYGaZOxpa9ntimbhJO20zwHjQ,1258 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_compositeexplicitautogradnonfunctional_dispatch.h,sha256=ZnQ8DxoZW3sfdE-iZg6iTiQVHvpSsQZpAt6BrDevO-k,814 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_cpu_dispatch.h,sha256=uiB4nmbEBvF3xFj1g9O9aaosYNs9v1HStOJdqkQGbzY,949 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_cuda_dispatch.h,sha256=AQ-F41GWwijoMGAUz1ESa-ClVCz5AZmYDhYhxka4tb4,951 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_meta.h,sha256=sLuQAtySnj4ZeKGtBvxuUD1dhD7QhaSZogiySjLDqbI,610 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_meta_dispatch.h,sha256=DeBURyTBajm0dgXy8ybjKOQXJJCFHiajuxkrejqqQLo,951 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_native.h,sha256=aKlFatzYxHaspYsGFqIRHSXNd81CWIiGM5zGYWEz7-U,685 +torch/include/ATen/ops/special_scaled_modified_bessel_k1_ops.h,sha256=17XsMlWCdmS0OKHqzJ9rbd1vHhv6TXKSzoXcnf0C3Ek,1734 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t.h,sha256=qhbmt9eutYr0M9TN7rQdIi7T6udp9BKaho1nU8BKfF8,3303 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_compositeexplicitautograd_dispatch.h,sha256=6xazY4mCNaB8N5FL__jMJLaZbtH2-igmFbBTW__yMOo,1438 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nZTdl2AAQWxlw7eZrNQZolc2nTeiQogH8xA133xCAPQ,841 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_cpu_dispatch.h,sha256=m_uPktXJzxp12TpOqaFYAUu-mOXt34YvDhpTYHDd_4g,1030 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_cuda_dispatch.h,sha256=E-mdsglRgIQeI5o-C-Jh7LTfJccV8lq0gh0XAuPzdyQ,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_meta.h,sha256=KR7sHG7V9uiIJhuGYdWAFLCVCtgoWAIr5vyC6ZuJ6Xo,637 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_meta_dispatch.h,sha256=fuCarhRt0LrpUs4gDDN8LZ2LxP7HXkJIBeaeyVpBupY,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_native.h,sha256=rePsCUC06Mt_1-22VwggjfHA3O5bOMBtQww5FYbQfTE,1190 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_t_ops.h,sha256=CY5D5T7JkqFFnIde6-tA-ac52vkB36k0XLN7wnToEQk,4974 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u.h,sha256=Jtn7odqjCFZORQRc8vaNNlNvnvMcannNq3B2E6svU64,3303 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_compositeexplicitautograd_dispatch.h,sha256=q6ZDPq87qBHd_kIAnkgH2m2GlLfvkOwfOhv4AeEQI5o,1438 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_compositeexplicitautogradnonfunctional_dispatch.h,sha256=H1cJmN63ef7krFKYeNB4CXq1502TAeBGbp0h5xcqUU8,841 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_cpu_dispatch.h,sha256=5PysWKeTbh34L2PIxpF7ut1WMwR2HC9TKJ-AwaGFWH8,1030 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_cuda_dispatch.h,sha256=vefstgoAY3rLduRsJZLC0OMHefS8G3gqUwy5vyYFoTA,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_meta.h,sha256=drlsWwxZ5lQmtdBTyL4Ee24rIxubYuo4GQLRYD1Fy9c,637 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_meta_dispatch.h,sha256=6xf-klwCMubqJd7TZJmYRCXRDuCX6pLtz_w5d6oAQq4,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_native.h,sha256=OX27nTUiDvjdpyejI3SU-oL3uQ21DMgoITRS0Nou_YU,1190 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_ops.h,sha256=Kl9T7btuYmQP0_QrLxdiQUG7wpiBDT9jX9GXHSAiWuY,4974 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v.h,sha256=r_MyxEyvbgQyqugQ58VzR_N79veVxhGvIhGAJ2h2ko0,3303 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_compositeexplicitautograd_dispatch.h,sha256=sOpTiUvCOsBRzDbDh-lBZvKAqhBVjbmRozzwJrgHV50,1438 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_compositeexplicitautogradnonfunctional_dispatch.h,sha256=N87bt3LEf9gyzJ-RTHCUTPQUexeCjwhQZKr9uAFnoes,841 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_cpu_dispatch.h,sha256=7uzy9rIrtMbiq99L1i67CIVFevYFxr5UTism-DR1Y9A,1030 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_cuda_dispatch.h,sha256=wlY0h1C7igIHnWD7LJss0mUmOpSh8WoqRNJTr1kpErY,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_meta.h,sha256=dJk3onnDc_U6OH4uBNmjpF0KcLAIHZgf4tvPCoyFaSE,637 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_meta_dispatch.h,sha256=IjmVgD6qvGYrncyDyhEJal7PDhovS3lLYsK3gHvg_Gw,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_native.h,sha256=tkoDfMb2fHi9HFVtSmcqG82FnJ6iWxuYuRE62sLY0e8,1190 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_v_ops.h,sha256=hc58yTC0Q5680ChlO7Lv8YbGl351bcPj2mToPwNZUp4,4974 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w.h,sha256=oa-eszkwzQ7dbmjCjj6jkHhHKwy3pPGoluLA505ewhc,3303 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_compositeexplicitautograd_dispatch.h,sha256=qoWodfM9DfmzjEKUE84lF6YTCCCpEPVa3JCz1J7e_P4,1438 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_compositeexplicitautogradnonfunctional_dispatch.h,sha256=trk_qFc1l31k8WiUOYb_slgS0Jn62XaVzUWna9KFMH4,841 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_cpu_dispatch.h,sha256=7k3JzOTdAuc5_yEZ2mCLEALLJU_d6mdHTNTKkZdiJpY,1030 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_cuda_dispatch.h,sha256=hkGprVCTc_LIVGGHfqLNc7kioRiLMkqrw5MD_WOXMdI,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_meta.h,sha256=GApB5c6iAPiqeSf1XqdBMyyut33Bhyg0HHqZBZlySFk,637 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_meta_dispatch.h,sha256=1ahY_gKUyuI3wtsQEzrMQQCu6jA7BRibn0laIxjFTiw,1032 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_native.h,sha256=B7ijzeVFm0PjUvcfNxcDOqi-csgLNxAG5zq2_kdV_XE,1190 +torch/include/ATen/ops/special_shifted_chebyshev_polynomial_w_ops.h,sha256=xEi-OZCMz-CUdRB9ADuHAyjkjkp4kOfuqMEr1Q6ZE1g,4974 +torch/include/ATen/ops/special_sinc.h,sha256=_XyMIL9uv6B82-ABto7FzqBgHTbPnN0uemZOTBp5FZQ,1075 +torch/include/ATen/ops/special_sinc_compositeimplicitautograd_dispatch.h,sha256=-92rIAhFtCSwofQNa9HWSw2WgXE9kPsrQU03c1rULF8,939 +torch/include/ATen/ops/special_sinc_native.h,sha256=uiPntiojaNYBO7ilYsmS-DwcBYrjeflz1iX-Z45q5W8,577 +torch/include/ATen/ops/special_sinc_ops.h,sha256=YV_2ZdBqMcv7DpJ0C0X21ACV7fL8abeVu8u9qsV43FA,1626 +torch/include/ATen/ops/special_softmax.h,sha256=6LZw0-p47O90DCs_m2te4F1AhalcYg41QNQ8ehUJieQ,769 +torch/include/ATen/ops/special_softmax_compositeimplicitautograd_dispatch.h,sha256=s66AYHVeHGl4FAMvN2Mcw40Z511rNGGxcTErXR0PssM,836 +torch/include/ATen/ops/special_softmax_native.h,sha256=_UvrkSOI9wE9QysgQOhoJXq_3_pbtJmZiPGSzTrpN04,559 +torch/include/ATen/ops/special_softmax_ops.h,sha256=ETgkTpi2aeHbHrX3hXFOdR2v1CD5cu-5dcPZWmlcOls,1167 +torch/include/ATen/ops/special_spherical_bessel_j0.h,sha256=4YDAz49GYMVdeWGYjD-4mU_h0TaroSbNBit40OS_oh0,1198 +torch/include/ATen/ops/special_spherical_bessel_j0_compositeexplicitautogradnonfunctional_dispatch.h,sha256=wdGw9ThRcla9vNgNf0M2vn_cjaDxoU5lq20qPUs91Ks,808 +torch/include/ATen/ops/special_spherical_bessel_j0_cpu_dispatch.h,sha256=LZqxP_ytkHZQr0As-PXnIjojscydhpsqcE_AocUMHIM,931 +torch/include/ATen/ops/special_spherical_bessel_j0_cuda_dispatch.h,sha256=s_b49esmXDVuiSBTxspI2M2y5ddtIjV9mWxih20o65g,933 +torch/include/ATen/ops/special_spherical_bessel_j0_meta.h,sha256=yV-oD1amvXQB-jxZvrTQ5eciXkJhbEYSOwZ7Eb7jhg8,604 +torch/include/ATen/ops/special_spherical_bessel_j0_meta_dispatch.h,sha256=UrKP5GGlqlsMDnrdJ0dTSgvBk8b5LRUT8Aal7F59MBc,933 +torch/include/ATen/ops/special_spherical_bessel_j0_native.h,sha256=Nan1k8p6q9AH7dcVVc5GjrPl5X9SAzu3GS1Y6jcLbak,667 +torch/include/ATen/ops/special_spherical_bessel_j0_ops.h,sha256=1CSyxK9Q_7EF1oOj0cx9V_no0dKtr_rfTka5FLrArHE,1698 +torch/include/ATen/ops/special_xlog1py.h,sha256=yEYTQX-xMXk1dnaxAXS-HML1mf-gR97AAEBKDXKTW1Q,2890 +torch/include/ATen/ops/special_xlog1py_compositeexplicitautograd_dispatch.h,sha256=_gDw2kWKn4upryrgw9vOGT8FLgraxtOf5-ZI7wL7MRc,1342 +torch/include/ATen/ops/special_xlog1py_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jxmxbeBWUZyFGaNMAlEhiV6DbgQIXjjPqng0dQkvBgM,825 +torch/include/ATen/ops/special_xlog1py_cpu_dispatch.h,sha256=S3G8lT6TRFjRiRTjwbQdPJlW_6ytAHf2yRC4hTVVpMs,982 +torch/include/ATen/ops/special_xlog1py_cuda_dispatch.h,sha256=yeqY-LOPFXPH7eLHXGSEz3RryazYgXI5NeofG-GT31E,984 +torch/include/ATen/ops/special_xlog1py_meta.h,sha256=rU3Q30X8WrdA8Tw1WdWsfGU5A9O7B1yAlViHLqDgZs0,621 +torch/include/ATen/ops/special_xlog1py_meta_dispatch.h,sha256=Fj4QClUHtvPhmxkaRMzBQfbu0dvQHZN7ONLnN-4gqEo,984 +torch/include/ATen/ops/special_xlog1py_native.h,sha256=2xOSgiKcK7HVcdH_YE2bTPqWcVUblx3-_b3RFaRRVCI,1064 +torch/include/ATen/ops/special_xlog1py_ops.h,sha256=Y5mi0Wvv68J1isuKRLvKRv2s8O5FU00pG6twqwmPLLY,4728 +torch/include/ATen/ops/special_xlogy.h,sha256=gctmVa1S4tWkPnfqQLyP7OXzuZsZqOMCVqSL58Sr33g,2834 +torch/include/ATen/ops/special_xlogy_compositeimplicitautograd_dispatch.h,sha256=BKjKr0lkc6Tva0JTdzlGlx6inXkKWaYKRtu5ucxZ2WY,1640 +torch/include/ATen/ops/special_xlogy_native.h,sha256=hcOVsWkuVGSG48-yP0uN8_L1UwduYB95oI02AxlNHMI,1027 +torch/include/ATen/ops/special_xlogy_ops.h,sha256=_cWDUo6HlRiTm3caug4V_0RHkIuT_syUUh8EaJwoALs,4692 +torch/include/ATen/ops/special_zeta.h,sha256=mcQVbe57y75foZuQkMlQzv3OcuEcTPUZgr5_-G7qscc,2806 +torch/include/ATen/ops/special_zeta_compositeexplicitautograd_dispatch.h,sha256=ehMK90ElYBTqmC1rabkLsK6TIGH8_4dZ_d9gXoVLMF0,1324 +torch/include/ATen/ops/special_zeta_compositeexplicitautogradnonfunctional_dispatch.h,sha256=BrOByt3V3pxs7dPg41B5H3uJdFsiqG9RTvZeiHcuEqo,822 +torch/include/ATen/ops/special_zeta_cpu_dispatch.h,sha256=F9rNT_iWm0DDIsbtMqqpmoEtmFwxtnPwSKlgPacligc,973 +torch/include/ATen/ops/special_zeta_cuda_dispatch.h,sha256=_nRfDkaHmPPaHTKY_cNSr60lkuQh6ydQkZX-dA2M1WA,975 +torch/include/ATen/ops/special_zeta_meta.h,sha256=QjzSzTrBpaCpJE-xMYtAPdPW9ytCDq8urw7EtcaQ7GQ,618 +torch/include/ATen/ops/special_zeta_meta_dispatch.h,sha256=X52eMKbIW19vkkcFnfnYlG_p9gQ5K3XJZnBiBj-P30U,975 +torch/include/ATen/ops/special_zeta_native.h,sha256=3jyK2_ivLuCjxscDanoe_ypfS8x0DzyiPVOcq4q0il4,1043 +torch/include/ATen/ops/special_zeta_ops.h,sha256=U1lPu4oavu_JND0v39MvD_EysiskSHhEjJ9uLZJFE0g,4674 +torch/include/ATen/ops/split.h,sha256=3pL1dei5weJSsM4Yuh0ccjqXpfU93Rt7KB-4muG5VVM,2717 +torch/include/ATen/ops/split_compositeexplicitautograd_dispatch.h,sha256=IoO99_TxuXApxAA34yqo4UwJrz66fF32QSa81-50MLE,927 +torch/include/ATen/ops/split_compositeimplicitautograd_dispatch.h,sha256=yShvDGMSibNucwcyJaMl0Z45poWFlDz77thn-G1i3QE,943 +torch/include/ATen/ops/split_copy.h,sha256=8MkeGTCvZCxnebg6WgCCRK7_kQCk0k61j0qnmXMNoXk,3965 +torch/include/ATen/ops/split_copy_compositeexplicitautograd_dispatch.h,sha256=iePmmIZybJDIg1z3DFLO8Dx-k4TsT2fLne_3zhylJ2Y,1174 +torch/include/ATen/ops/split_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=1Z_ZngoFAPAqvahJuvhzEAYKvqUSiYaBb3sNpmNWecc,963 +torch/include/ATen/ops/split_copy_native.h,sha256=Xun46nmM3zdMa2bvp4gtvkv8OBvrkvJhVOZdXWQNN3Y,675 +torch/include/ATen/ops/split_copy_ops.h,sha256=_h9q5cNLTYh6sPw9wAzfnMtRZi-6mr13YIC3hq-qa0o,1930 +torch/include/ATen/ops/split_native.h,sha256=cXIaiO2mum6MfWywk4MySN7HvELKF-X98AfHfyqc-zA,658 +torch/include/ATen/ops/split_ops.h,sha256=DHadIIvL0NOi1mWRl-zNZQenglCgNQ6FR2qf7pn83MM,1925 +torch/include/ATen/ops/split_with_sizes.h,sha256=upBbKxTISNYxg_lCQ7X1QrPDk9_QWvCnZRXfW52bNfo,1739 +torch/include/ATen/ops/split_with_sizes_compositeexplicitautograd_dispatch.h,sha256=ZLqTTZeLViBbeFfMde3tboq_LN_DM_YorYGmAV0L2XM,967 +torch/include/ATen/ops/split_with_sizes_copy.h,sha256=CJpP6gZPqkpxTBNT8jDPF9fcSfocS6IAI65hmJZh79w,4474 +torch/include/ATen/ops/split_with_sizes_copy_compositeexplicitautograd_dispatch.h,sha256=h8-c2MPRMEgJKMxB2DxkMxvBDItB5arIFhge9AhrpOc,1254 +torch/include/ATen/ops/split_with_sizes_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=voL3MYIKgAW0aOb9BKoQX17weTprRc5tWkdKVJwR00Y,1003 +torch/include/ATen/ops/split_with_sizes_copy_cuda_dispatch.h,sha256=gLuYeUlzigRs6Ris9TvjblyJd6WlSs6FAIxpS1AIwbA,1212 +torch/include/ATen/ops/split_with_sizes_copy_native.h,sha256=06d8eeGMe_KmgqSP7wrRL5YArl5cpHTLV-5sfhKRGKg,835 +torch/include/ATen/ops/split_with_sizes_copy_ops.h,sha256=rT5kIAjoloz8hpNOwT1zlc2FyfzyglMbRGbv14vuSNo,2013 +torch/include/ATen/ops/split_with_sizes_native.h,sha256=f9Nzfjizn_SbFyo_GNhmhQtqiBUD2btZcve5M25hr6g,686 +torch/include/ATen/ops/split_with_sizes_ops.h,sha256=njXSWS7viLFWDJLlDW2DUWeNV9-wcP6E3T_ZfjSheSk,1210 +torch/include/ATen/ops/sqrt.h,sha256=NOPr8BnUS4eIgov73nd8gZkR9usbppFaX-p--AMtYPA,1131 +torch/include/ATen/ops/sqrt_compositeexplicitautogradnonfunctional_dispatch.h,sha256=97jxEw3IBLKh7rAWcVQM4cFD7DYbQSPBouJn6uBZt6c,837 +torch/include/ATen/ops/sqrt_cpu_dispatch.h,sha256=FIzuC9ibPlGlRukNNXHYXwHr4uGhIuJIC3e5oc0MflA,920 +torch/include/ATen/ops/sqrt_cuda_dispatch.h,sha256=AG_H9LxQ22aS-YI9CaAwMdxvOIH-sk2oLT7mkOpkU4I,922 +torch/include/ATen/ops/sqrt_meta.h,sha256=Xj5TUZ6zlp6qbG43oVlzpykVpIGmoran1N6uYheCmTA,584 +torch/include/ATen/ops/sqrt_meta_dispatch.h,sha256=BXqcvxE3iUMNkgelIAUU0UWcfXnMMyXnOFmcqRd_4PE,922 +torch/include/ATen/ops/sqrt_native.h,sha256=nnl_JNg0o9oB5521ChJOB-aIv6LcC0eIS0-tmv2im-w,1009 +torch/include/ATen/ops/sqrt_ops.h,sha256=PYz_jShPifsIuOvfnXyTFumL2FRBpWGFOjRyRIgnGeo,2104 +torch/include/ATen/ops/square.h,sha256=lVWdQtLyZpM86wSk_x8rh0KOAjcbvi8M_F2B7MBeAA4,1157 +torch/include/ATen/ops/square_compositeimplicitautograd_dispatch.h,sha256=ArFyRehnUpDPKiX1cyyjno_6Tyecl6SC4XegaUSR2VY,972 +torch/include/ATen/ops/square_native.h,sha256=EQtHHf__d5shQTh5FK8iUNZjaDU5zwwxSAKrsQnsk_g,616 +torch/include/ATen/ops/square_ops.h,sha256=UDDcO3lEzP7rQGx2GQTKm8blmzd_mUZBOnw3mWAIg9k,2122 +torch/include/ATen/ops/squeeze.h,sha256=eJNDTlP_qBzxsP-Rb6QuMzaJK9w69GW9JWGsBKJH1oQ,1200 +torch/include/ATen/ops/squeeze_compositeexplicitautograd_dispatch.h,sha256=JedZgFF9yVWNAk5y50Ry92u5MBpkVHswD5ZujA-roTw,1099 +torch/include/ATen/ops/squeeze_compositeimplicitautograd_dispatch.h,sha256=S9SO_l3wPUVxsrUVq6U_cIwCZonl40hAe6FNk_UeNAU,851 +torch/include/ATen/ops/squeeze_copy.h,sha256=rYkrhMhFb_WpIUoE08rPQ49rrYAFOttQkUejRdCse_8,2479 +torch/include/ATen/ops/squeeze_copy_compositeexplicitautograd_dispatch.h,sha256=XOOhc9zI2HTk01FwjEtS1cXPWfHlT57Cqqq1c0pGRpo,1285 +torch/include/ATen/ops/squeeze_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=qsoDUAwDFa6Tb6Vh9IYW5iOBp6kM2PgBAZ8i4Fn0KFQ,950 +torch/include/ATen/ops/squeeze_copy_native.h,sha256=BFMlOSWbUuHXV5Sib8v3TkmK4Y8Q96kmf3iliuu-ZSY,951 +torch/include/ATen/ops/squeeze_copy_ops.h,sha256=S9Xy2-18lLkfnbZsRjVF238Ztb_VpT8geC-bWsF_26g,4290 +torch/include/ATen/ops/squeeze_native.h,sha256=HFmPgRZY3PjS7JdVqgvDIOjhv8enzq_Cr6T6wv_9ThA,1420 +torch/include/ATen/ops/squeeze_ops.h,sha256=Cm6tPBW7mDPhjufbXnAeH6OQiYfMt_lpHBWGo-kGydI,5186 +torch/include/ATen/ops/sspaddmm.h,sha256=_bvTYshGegtxxGlpfm_bC5aKQdhZnrxAKZqk6mDFbNc,1595 +torch/include/ATen/ops/sspaddmm_compositeimplicitautograd_dispatch.h,sha256=nr_I9hBUFBQmfZOvwWeH9zLuQyBntS3slyqgcUqB8JY,871 +torch/include/ATen/ops/sspaddmm_cpu_dispatch.h,sha256=nAn1kOw6aJaflPQADEzUEiHtTRMxgKdbLCs6vxwsX28,1033 +torch/include/ATen/ops/sspaddmm_cuda_dispatch.h,sha256=qQrd39YejwtWGJnHD0VRTv1YWLFHgvWsgUpL9ylb9Yk,1035 +torch/include/ATen/ops/sspaddmm_native.h,sha256=LJ42uKMV0AHM0wbTTcMYUVFaAzZMeEACJv6bLH2XH5s,1360 +torch/include/ATen/ops/sspaddmm_ops.h,sha256=ao_4BU-8hQbmR0_552nHOt8XYHas414O-0o0UUez7Lo,2283 +torch/include/ATen/ops/stack.h,sha256=tzEkD4qmA5ii2rB871TQSuNLKvtZAlDAKSRI5yPtU1Q,1117 +torch/include/ATen/ops/stack_compositeexplicitautograd_dispatch.h,sha256=OXt2k3jhQ4jnVGNOl8MbEMQYqXNwA__R6NjcHjIst-U,958 +torch/include/ATen/ops/stack_native.h,sha256=UT1tbJLJzbOOSlArrRlckOKgq7lp91YdD8ctCLtX-Vk,589 +torch/include/ATen/ops/stack_ops.h,sha256=adoswbfBko6mD9hSLQzxIt0hoaif6sGVqNe9BlTSIAM,1674 +torch/include/ATen/ops/std.h,sha256=TS4Pyv23eVlfM46FApK20zWo_Vu7ePiYDgRSue3j6t0,4835 +torch/include/ATen/ops/std_compositeimplicitautograd_dispatch.h,sha256=yQY6X1gzsHUSCfSnPgmDFiWWL_clwFhDDUc7eWaGjW0,2011 +torch/include/ATen/ops/std_cpu_dispatch.h,sha256=_ivez87Sc0lXeZbZKmhBdpKjvM5JfX7pMxRaTIj5l9Y,1199 +torch/include/ATen/ops/std_cuda_dispatch.h,sha256=5MVvgPM0qMPBrs9uEuM1YfypaQ3VRYn__RJbmBfljYU,1201 +torch/include/ATen/ops/std_mean.h,sha256=fAUrNYWyhqQgS7Rgxf-Jrwr6miAfKOCM28HM3BCjU9k,3187 +torch/include/ATen/ops/std_mean_compositeexplicitautograd_dispatch.h,sha256=bVjD8A3A62OsVhhn6u9O0KhRku_cBtiVgHVxik20-bo,1175 +torch/include/ATen/ops/std_mean_compositeimplicitautograd_dispatch.h,sha256=8D2jxSUApDDYRlGzaAdyumyIo3foShWHH9cYK8SbaEM,1269 +torch/include/ATen/ops/std_mean_cpu_dispatch.h,sha256=KT0nbLcmFmrYWyZZEWlH2pa-9pxSt1r0imHqady3-MI,868 +torch/include/ATen/ops/std_mean_cuda_dispatch.h,sha256=4jNJHehrC96pKUYeVvrKLg6XP7FRR9zCcosCTWpNwR8,870 +torch/include/ATen/ops/std_mean_native.h,sha256=gmifqY6oLiEh4rqo-JcjtmqHCZin_5RYJz8Dm76L4CM,1436 +torch/include/ATen/ops/std_mean_ops.h,sha256=wibcasJPjVt_RFgUyzlClezigtRiqWvemhoO9tN9G5E,5853 +torch/include/ATen/ops/std_native.h,sha256=qhhg6pLYjkAS11R4QkkQ60MeyQUfiRt11V6UzpIO9No,2001 +torch/include/ATen/ops/std_ops.h,sha256=KiIZBddYdY8NpJM5135XPinU-g2q9czZQPb5I8XpQpk,7754 +torch/include/ATen/ops/stft.h,sha256=3_WXcp_fSizfyWCI8gHPWbSZDgOfSfUAZs4GRdPWV7o,1830 +torch/include/ATen/ops/stft_compositeimplicitautograd_dispatch.h,sha256=oViqMfJ7T2EpkZHJ4FVF3JZ5bVmXZL4iu7FooCvSC-w,1376 +torch/include/ATen/ops/stft_native.h,sha256=uUsB-ZwQcDlDFZQ8-d6t2JOWxhC_xuwjDPNMOkv1fkE,1134 +torch/include/ATen/ops/stft_ops.h,sha256=upfXV933s29aofQR4dyaIbncR3E_P4gGIOprzSN7DGo,3070 +torch/include/ATen/ops/stride.h,sha256=oGXuNrQiC7SBhBahg6SeOKjwtcGZ5-428npSbhV8b-Q,845 +torch/include/ATen/ops/stride_compositeimplicitautograd_dispatch.h,sha256=PN5dIRTcMD-TajrInu1eREZxjdwEEkE5pCfXJS47R4s,842 +torch/include/ATen/ops/stride_native.h,sha256=BusatXkAF7f9PrPGqH16yUGorCI9XYpC3rbVOn1kbeE,565 +torch/include/ATen/ops/stride_ops.h,sha256=WMy1K7q5CgV0j3ePGUxB4IoUbA_7rPnpMlofRU3ryKs,1614 +torch/include/ATen/ops/sub.h,sha256=t6QZNEfQA-kmjoJGkDyHrAE4VVodyc-__kZLCPWE2bs,2126 +torch/include/ATen/ops/sub_compositeexplicitautograd_dispatch.h,sha256=6okzax7hRp3u7e6DzUg-ZoG_jEUvB2P94CKdfkaW0Ug,1174 +torch/include/ATen/ops/sub_compositeexplicitautogradnonfunctional_dispatch.h,sha256=OxvbKUWEyGxA1fKAq6Nl_M_a9_bzwTGFAgQe42YIjFY,943 +torch/include/ATen/ops/sub_cpu_dispatch.h,sha256=z338yo7XiXwDw1ho7R18dgS9aA0P5fNGfEPMP3s-kD4,1130 +torch/include/ATen/ops/sub_cuda_dispatch.h,sha256=Wmo_-nNh6xa4QvPSGoSWJf9Z2ReGrjwvKyHT5dxk_qc,1132 +torch/include/ATen/ops/sub_meta.h,sha256=CUnxXsw_3_a8xmaj-CO7ZzsZYZF5qPm8OgVEqOlDoqY,642 +torch/include/ATen/ops/sub_meta_dispatch.h,sha256=5HtfxiQj1pfoE2WZFLkUIRgG_3u-X6Iod_SFLsDOQ5E,1132 +torch/include/ATen/ops/sub_native.h,sha256=kSfPlPjRGi2eHqKPVTXlpMjKcD6WDlcExQFXAIPhtF8,1594 +torch/include/ATen/ops/sub_ops.h,sha256=kVSXsQSs8jnCeIxjMjLRjWHW84gEyGg9f6uMGE3JxnA,4907 +torch/include/ATen/ops/subtract.h,sha256=OOQ31tFLDlamgWqbjl0LlkLfSeSkygozDPVSwoo-B7Y,1597 +torch/include/ATen/ops/subtract_compositeimplicitautograd_dispatch.h,sha256=9wHS4xcrqPU8tU7zQcD4_T0hhuiyEbJkB5uquKplJbE,1411 +torch/include/ATen/ops/subtract_native.h,sha256=jsLfv6n9eftQzrPMnMollFQJqk4OQ_CHu654dJRaEHg,999 +torch/include/ATen/ops/subtract_ops.h,sha256=YgFz6qqISkd0ta6BpLk6hDaEQThDicHH2mSSui2mLRg,4173 +torch/include/ATen/ops/sum.h,sha256=gu9JVLI2yZioEV3o8kXvUBeGb_nfV13MnQzfo96JdIQ,3365 +torch/include/ATen/ops/sum_compositeexplicitautograd_dispatch.h,sha256=7kyNab0Nm-ItrTeygdpbE-4o5byh3b_-Fxj6tsJ5_R8,1049 +torch/include/ATen/ops/sum_compositeexplicitautogradnonfunctional_dispatch.h,sha256=pY6FHJOMuukxzvbwRQeZZZS-q3VUYPRnQUQOFNLrpxk,886 +torch/include/ATen/ops/sum_compositeimplicitautograd_dispatch.h,sha256=Yn_xJ36CepVj0B7QFKC4jiWC0jMUT6osc7XI1Djd65I,1166 +torch/include/ATen/ops/sum_cpu_dispatch.h,sha256=5hTY1kMm-2Nax4h61hku5-5U-3s2pR4Tm754lIFgrhA,1146 +torch/include/ATen/ops/sum_cuda_dispatch.h,sha256=Rvua7MGDRUbmkk_M6JL5_wjQ-UfyIf91ImxU8d32dTE,1148 +torch/include/ATen/ops/sum_meta.h,sha256=w0-7naa2SEMi2xULR2LwXu6L5nqu2e0bJhdEpABI7vA,675 +torch/include/ATen/ops/sum_meta_dispatch.h,sha256=sJhoK_Y16UPvPKW1XVjZwrKunpvAG_ZoyMvOrdpZVHo,1148 +torch/include/ATen/ops/sum_native.h,sha256=l_T5A-_LMyYQ3valh2OekkHXS2hzKdhDCMPWSoOAndo,1902 +torch/include/ATen/ops/sum_ops.h,sha256=N-u9ArmqGyifKGTE-nr-QCOP7aDQlk2J-R_mX4nHESI,5331 +torch/include/ATen/ops/sum_to_size.h,sha256=-AQVp5J6H3IWWXLg_lnrgazNEeQrQ_kap2gZMyI2O-8,1005 +torch/include/ATen/ops/sum_to_size_compositeimplicitautograd_dispatch.h,sha256=qcgFze61T-FTH-xR8GflgnxDysSHbyn5bhuF3sRYMrc,883 +torch/include/ATen/ops/sum_to_size_native.h,sha256=fpMQ-fSTQ-gOqLcgcG4crsELgKfdc85g2MDZlyiJeSY,525 +torch/include/ATen/ops/sum_to_size_ops.h,sha256=DoR68dMx2-KbrSQbGaJGOjCIHd5DSDl2HyJNnEBXpMs,1070 +torch/include/ATen/ops/svd.h,sha256=Os82CRlet_Vurbe1Cjurfm0WJqYMxsLlna1p_8f_LgQ,1573 +torch/include/ATen/ops/svd_compositeimplicitautograd_dispatch.h,sha256=o7YTegUFrNQb6keDLJQlhU2YgNLkjn55nfO4OSBRgTA,1192 +torch/include/ATen/ops/svd_native.h,sha256=ZL1SeDd0iGy-F398s1q0EQOjhLf5BXj4SBtNUz8qEv8,731 +torch/include/ATen/ops/svd_ops.h,sha256=NhMjg74VnektOVHPT1G1-EmM7kWyUvbDPvdpv0Y7yNw,2176 +torch/include/ATen/ops/swapaxes.h,sha256=Ctt9AWoyKODHwXYQ2Vn8YayOvrelKr9tcXm2-oPoouA,705 +torch/include/ATen/ops/swapaxes_compositeimplicitautograd_dispatch.h,sha256=QKsdSRsNHmNLZMNM648kl4JIhtblxEy9qUCWiU0Wods,879 +torch/include/ATen/ops/swapaxes_native.h,sha256=sSo6G_hxEZQbdJ0cdzvln7BQDrz5TdVxSjCzCvd8IX4,602 +torch/include/ATen/ops/swapaxes_ops.h,sha256=nHQ3CD6mr_vDvAqpDtdyEYXpAvQz67oPlaM9XrjV9bQ,1717 +torch/include/ATen/ops/swapdims.h,sha256=8D2jj9-CvOqhAH6xv8dpgFRugukDroB9m3nVNPZAPKc,699 +torch/include/ATen/ops/swapdims_compositeimplicitautograd_dispatch.h,sha256=D0IefFV_MtyAO3vvRsnbBUFu9daGc-Mt3sDIyhpo41E,875 +torch/include/ATen/ops/swapdims_native.h,sha256=o5xU2qHLsd-kIrulJtmGUyhga4YqvBa_zjHY4vAoqSk,598 +torch/include/ATen/ops/swapdims_ops.h,sha256=QLQj9WjEeObaKx3V1z7HKHuwFvojmWHHl-cNRGC2izI,1705 +torch/include/ATen/ops/sym_constrain_range.h,sha256=27S9RoJmjMkc8DPRY_7J2P49lNUqjzoRC3k4gXUMHwk,792 +torch/include/ATen/ops/sym_constrain_range_compositeexplicitautograd_dispatch.h,sha256=1ZWh1CcH6Cmpzn_M_zVDaH1qB6z6fWBF3JqtWjuXg3M,853 +torch/include/ATen/ops/sym_constrain_range_for_size.h,sha256=vo0M7oGy2PnytdW5l1Zfp6XW45a_puqRbu85de2CEJU,828 +torch/include/ATen/ops/sym_constrain_range_for_size_compositeexplicitautograd_dispatch.h,sha256=2f2ixjA7jY0ylsDOXtMoYSGkNedx12zT4mJnhqrHyg8,862 +torch/include/ATen/ops/sym_constrain_range_for_size_native.h,sha256=moXLiIL6j9lVJHhuH_auEjJOF0Z4CR_X-8eVcgXTlYk,585 +torch/include/ATen/ops/sym_constrain_range_for_size_ops.h,sha256=8sIOrrtHA7IYcvIYI3lJlWgiAoI9_cxWrCkQdXV98FU,1204 +torch/include/ATen/ops/sym_constrain_range_native.h,sha256=9ps28_soPWprakW72lbUwivZqZZMWslbr9CIKbt_xxE,576 +torch/include/ATen/ops/sym_constrain_range_ops.h,sha256=k5wWamGFW-xCN8mauJ_mfUIZ-sQeSU46tVmYkaW8Dj4,1177 +torch/include/ATen/ops/sym_numel.h,sha256=jO0d0iUigDGjokR4TTXA-NrdYhr36C68oKNTgOTnCjA,649 +torch/include/ATen/ops/sym_numel_compositeimplicitautograd_dispatch.h,sha256=tXTb3_7AIwh0kcLzbKzEuiNbTOaq_j1Kk_xhsNaDAJA,768 +torch/include/ATen/ops/sym_numel_native.h,sha256=D6HjUXOU7PA-wQgBA5UnimEPA9GFlRaLdslUjjIi9hE,491 +torch/include/ATen/ops/sym_numel_ops.h,sha256=ZX9kJT7Rz5NjQ7-_zEZSmwJd0TIj1btRZlXZEnBaEIc,979 +torch/include/ATen/ops/sym_size.h,sha256=Zm6XqiWP8WRuCXYFb3f3Vpl11ydlOLzxW1kMMTlOQXU,680 +torch/include/ATen/ops/sym_size_compositeimplicitautograd_dispatch.h,sha256=BL6mxnuGiOQ05MHhNKLVcNSPHugjuNJZ_I6WwACuLz8,780 +torch/include/ATen/ops/sym_size_native.h,sha256=5zWWsJ3qNx9hZizxOtDaa9la9ODoXqnQ4ss6JOZAUpo,503 +torch/include/ATen/ops/sym_size_ops.h,sha256=Fk3ALHIVSV4Cxpioe24bmgZCTeP2Uy1MKATQdt9V7UI,1031 +torch/include/ATen/ops/sym_storage_offset.h,sha256=obyli4olHv396eQfAN_2Wv17qe-aBmChrv7BxgaID0w,685 +torch/include/ATen/ops/sym_storage_offset_compositeimplicitautograd_dispatch.h,sha256=itfuP6Tt093Zrofo3boMiLhS3W4jNkg5q49PxJfryMU,777 +torch/include/ATen/ops/sym_storage_offset_native.h,sha256=tC4TWxZMem59LbA5kXfbQKD9lxaElCrE47dGZc4iBDA,500 +torch/include/ATen/ops/sym_storage_offset_ops.h,sha256=7mhdeH8eTv8OX2iuRDcC6XzYNiSU21febSSXMWLfGeU,1006 +torch/include/ATen/ops/sym_stride.h,sha256=Y4Hem9BLU9TAcDZ1VRTNIjecu6O_Q88PCOfhPFR18WQ,688 +torch/include/ATen/ops/sym_stride_compositeimplicitautograd_dispatch.h,sha256=z320JcS739xpzhKp45x5gGX8P-RPD0U5yAqnDCNF4pM,782 +torch/include/ATen/ops/sym_stride_native.h,sha256=ij-vRlGjeNdTlW-pOqta_V0guETTPckSZDlIEiacacA,505 +torch/include/ATen/ops/sym_stride_ops.h,sha256=ZuNBlqPv7uxUk5yDbk5BYhafxkOZBmMHtZATTMIZ-Uw,1037 +torch/include/ATen/ops/t.h,sha256=Jlez7GsUM0Rv-K6JN9nDZ9fySx1sylqwVXBGuVMtZdc,611 +torch/include/ATen/ops/t_compositeexplicitautograd_dispatch.h,sha256=zNsOwQ5j1KDg2w1HL2Z4dXWsQQzz1CjOBaA6wNq2oEw,805 +torch/include/ATen/ops/t_copy.h,sha256=msrnKg_vMhXIszS5m-_vNjXHgK0AzXH50x7z6nKFk24,1015 +torch/include/ATen/ops/t_copy_compositeexplicitautograd_dispatch.h,sha256=JmlOfgw8-Q077uwpeK-Qr-l-zLj746wf_GwXU5ykEqM,867 +torch/include/ATen/ops/t_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Tbn5mQk7oks1TQs9P7g977GDweM3MA2JYEKjnB4ztd4,790 +torch/include/ATen/ops/t_copy_native.h,sha256=cg5zMV-0dPaPoHRL9ObuXrGzYc76TCWKkHelC3iMXI0,565 +torch/include/ATen/ops/t_copy_ops.h,sha256=SmjcK6eY8yu-TBm3PyrfttOGS_Ny9m1nbsPZ3Q4KFJQ,1590 +torch/include/ATen/ops/t_native.h,sha256=ncLLSoiW1p1dthXwzWvR38mEr86DQQQ5GMGm9gvYcmM,528 +torch/include/ATen/ops/t_ops.h,sha256=MqVQkBP81lbB2Y7zWOPxKjFcbWPf7Ax04KsqePw778k,1475 +torch/include/ATen/ops/take.h,sha256=xCOBP0-zUWJyovJP27dYe5SA8fxCRZb0dzUifzbpGqg,1136 +torch/include/ATen/ops/take_along_dim.h,sha256=82XOA6RLO2YqnQntSF_ThAeQXegSpoZyMyoAt-O4TUo,1424 +torch/include/ATen/ops/take_along_dim_compositeimplicitautograd_dispatch.h,sha256=3KVhBK8C3t_RirSd-3cAPYsA-DybJY_xG7Ssha27DbY,1139 +torch/include/ATen/ops/take_along_dim_native.h,sha256=IKZ6R0preFJTypVmnyCsW_37eo7ShyBWysqoIv5R7k0,706 +torch/include/ATen/ops/take_along_dim_ops.h,sha256=pGYGAqno7gah23kdiFUz_BiJumtwAAsnPmUdFhR3pMw,2012 +torch/include/ATen/ops/take_cpu_dispatch.h,sha256=hbO7KFlRMYRrW6Z2utqVYJgaOAY-RPfl0c1M4YMm-rA,949 +torch/include/ATen/ops/take_cuda_dispatch.h,sha256=qFDsLb8TP2rQs8mawSUMWLeFm0IgPkGpE7CUuaPIfDc,951 +torch/include/ATen/ops/take_native.h,sha256=tZYtquAsork9Vww3v0Wu95pmBPgI7-0imSTrqEqfks4,613 +torch/include/ATen/ops/take_ops.h,sha256=tckaYmHI1FAwmt8GXvjnOYtD21O-s9BAqhuSeVVwAlM,1750 +torch/include/ATen/ops/tan.h,sha256=su2S2zPglKxXumCFW2s1BoAe4vhVevuZCu6YeY_TKFk,1118 +torch/include/ATen/ops/tan_compositeexplicitautogradnonfunctional_dispatch.h,sha256=9msSFgcRjrg8bX6bNI5kCV6baqM0-A6C6H969OR0Lqs,835 +torch/include/ATen/ops/tan_cpu_dispatch.h,sha256=DimMQnXgY-7pND9M75hivgWEZX8K1ApIJYxXSM9Ue8A,916 +torch/include/ATen/ops/tan_cuda_dispatch.h,sha256=uY_V5HawHgc4ftTPpHtwN3pMEOP6rPQDosiUNLdS_i4,918 +torch/include/ATen/ops/tan_meta.h,sha256=lsGJVU4GNLi7Jiyruyok2KSXMu1-MdLIKqHjyO3WEMU,583 +torch/include/ATen/ops/tan_meta_dispatch.h,sha256=ZHlw9zOpcjvJ0CGDflTwnhbGsY_MzNCMaZkckcrZDto,918 +torch/include/ATen/ops/tan_native.h,sha256=vNlP1UJZ5fdOhnPWfx09GccI4tS9ijS8bciu-scM5rk,1000 +torch/include/ATen/ops/tan_ops.h,sha256=vdU8LtsE1JuPL2kjtFLu2NY8lWXC0WhkBKM-YEul9hc,2095 +torch/include/ATen/ops/tanh.h,sha256=74ATctOqbISn8Axh8SD9g5zuZvhHwV7cCLYgQYg6QyE,1131 +torch/include/ATen/ops/tanh_backward.h,sha256=7z6W1ZHyi8rlm3zLCEMo1SZj9OTZ2E5EvRxpnYssBBc,1368 +torch/include/ATen/ops/tanh_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=cewqqytrQiBMcumo4dIS19Pz-CcDTLuwRMPKd1SZDIw,831 +torch/include/ATen/ops/tanh_backward_cpu_dispatch.h,sha256=bTCDJx_2SfU3SBw37eRkerFIQoxFsr9nABzBG9etGyw,1014 +torch/include/ATen/ops/tanh_backward_cuda_dispatch.h,sha256=87yeDFFt_xrco8MecdA55JhYnFMPnpDr3rhNaZ3JiO0,1016 +torch/include/ATen/ops/tanh_backward_meta.h,sha256=L58Qe-eqQIFFH6YQhtSBV5AFDS-40ddfRaBuXROUpOU,627 +torch/include/ATen/ops/tanh_backward_meta_dispatch.h,sha256=c5hHwffvqGr8pxGIIBCwIvE0v5ZdXWtTnfpsJ5gAexg,1016 +torch/include/ATen/ops/tanh_backward_native.h,sha256=n9gUSh61ZDfHa_dCjrlURVnXdAF8dpbtbti-SoXWiBc,669 +torch/include/ATen/ops/tanh_backward_ops.h,sha256=zVEtG9Vp2xTNzJp8dz2UWt_u-QRNe66Zk4-awKTt_GU,1894 +torch/include/ATen/ops/tanh_compositeexplicitautogradnonfunctional_dispatch.h,sha256=OQVmUti_spPJKlM5JmiXBvOTTJk6sDBboVm7n9Ufv3c,837 +torch/include/ATen/ops/tanh_cpu_dispatch.h,sha256=khq7PUKQ1THXtSJ0J-89jDHoCcUD-swCwAfQTIci5QA,920 +torch/include/ATen/ops/tanh_cuda_dispatch.h,sha256=yrcfdE38ouc1qkOXg1cjWUM-aKAHEPcmVNDPCd8xS2I,922 +torch/include/ATen/ops/tanh_meta.h,sha256=xRARexGOF5uQ-QunwfOzcIp4UqKdQ_qEdxGQGC-fC3E,584 +torch/include/ATen/ops/tanh_meta_dispatch.h,sha256=c9uDlsNwtm-qtf6XIwxdWoyGye5tH3PhTIrJRg7IPKw,922 +torch/include/ATen/ops/tanh_native.h,sha256=aZ-zwoiqM3G0-Pa2KBsitPdXJ6ZC8xfXNm3YxzccLaQ,1317 +torch/include/ATen/ops/tanh_ops.h,sha256=IhWfUvfrLkCGTu7FjNUC62RBjiNX1QzRDyPiwcez4MU,2104 +torch/include/ATen/ops/tensor.h,sha256=isoes7wQlV4GjiBAgES1eu_hDJ5Z7Nn1eDIo-vJTBnY,1631 +torch/include/ATen/ops/tensor_split.h,sha256=-sec-uMSRk4wxtjz-TcyC79fJrj6vhsy5SGKl0p3mkU,3214 +torch/include/ATen/ops/tensor_split_compositeimplicitautograd_dispatch.h,sha256=H5JK7evExo6-K1LJRsox4fWUBFHg8Y_uIHfEe09kWmY,1315 +torch/include/ATen/ops/tensor_split_native.h,sha256=6waXkDEecwXWvudL_J2ayTt0t7Ts6hScTSOXNVHB6SA,832 +torch/include/ATen/ops/tensor_split_ops.h,sha256=0HMJGNvwwiugZsEG2DGfzX0mwqHBzwRPj3RLWmwGXww,2848 +torch/include/ATen/ops/tensordot.h,sha256=jnjDUFTbe0IxhjEnxdvCh7_CfnmHR-phYdmEdLxQFjI,1525 +torch/include/ATen/ops/tensordot_compositeimplicitautograd_dispatch.h,sha256=GKHo5YJ6o4nCJYKxewCITKpRbv-GH9EhEwcssXAv5X4,1173 +torch/include/ATen/ops/tensordot_native.h,sha256=jjL--YUPOll7HbaAVaKEB1KIlpb9UwkKMQN2r4nQhc8,733 +torch/include/ATen/ops/tensordot_ops.h,sha256=xwOsAsz288xmk-aEGOX0yzlBlhEBmoPZHGGYFFki-eQ,2138 +torch/include/ATen/ops/thnn_conv2d.h,sha256=Wy03AHo5-3LSf3vns0ljCXfT4GWC-JGWyuqwXZuYjDE,6614 +torch/include/ATen/ops/thnn_conv2d_compositeimplicitautograd_dispatch.h,sha256=Fc77jZ7f3-xTSVQ9yw6x03kZRWeJlidXK0KvLVDDHEc,2169 +torch/include/ATen/ops/thnn_conv2d_native.h,sha256=IKnr9WoFoAUhaupdBn9dZXKnzzFoudmMCCYSGhCq08c,872 +torch/include/ATen/ops/thnn_conv2d_ops.h,sha256=Zeatn2_56vY4IEMUKxDL098XEfi8AkoENCqreSHhi4M,2680 +torch/include/ATen/ops/threshold.h,sha256=Ly23_zQReB6nxaZlAJtUqXllK39GHN-8AZ7BTP5IxZs,1620 +torch/include/ATen/ops/threshold_backward.h,sha256=TXxoml6-Y-OdDj5IF9Un6eoHMPrbQmyWP6qP6QzLjCM,1577 +torch/include/ATen/ops/threshold_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=plJpzm1z4Vb6Y6LEFRhFuBRpKZhh4sJu71uBs8uKM3g,864 +torch/include/ATen/ops/threshold_backward_cpu_dispatch.h,sha256=3RRYQvqNz0pGBKIpm5GLlDfPm9tYdQEXqpwyWEHpw0M,1113 +torch/include/ATen/ops/threshold_backward_cuda_dispatch.h,sha256=XYavrW3lmvvVr0r_7B56-EhFKrqvHWgrr6X9Oqljafc,1115 +torch/include/ATen/ops/threshold_backward_meta.h,sha256=o-uRYpv7Fn9S69PC-WZCmN6SrlFGtAIFv6OHAlljKag,660 +torch/include/ATen/ops/threshold_backward_meta_dispatch.h,sha256=Io856UNegr-z9rZofa9ul0SVMGHprgfINFefKpXNaLo,1115 +torch/include/ATen/ops/threshold_backward_native.h,sha256=iz89KFj4OGDBLcXTG-CjJ9-p_xfEgqhu3mtHJhrALjk,1602 +torch/include/ATen/ops/threshold_backward_ops.h,sha256=9AA-V5Qegh5fxLtUSS1Kih8T79Uyx85tnSgpFW6UxUc,2108 +torch/include/ATen/ops/threshold_compositeexplicitautogradnonfunctional_dispatch.h,sha256=jI63c68gBq8bfVtw_ycGKPUGhN8DIeWiqrVTPvQRyW8,959 +torch/include/ATen/ops/threshold_cpu_dispatch.h,sha256=rHiezQrfSYXnJn9n68hpVpu__zfxjl-6DWeSY2DvVmc,1164 +torch/include/ATen/ops/threshold_cuda_dispatch.h,sha256=k47K89InvDrRAOHe3yQ39OxOjn1DIpukBrz5zzi5A24,1166 +torch/include/ATen/ops/threshold_meta.h,sha256=Q8w2SMN177lZTJ5HZVXOKtfwBtZV_Pv_H0Arut1N8RI,645 +torch/include/ATen/ops/threshold_meta_dispatch.h,sha256=4hCfmDbySXTjcvz1NmZVFWE0DdFcM5HcIt--ImF8pHU,1166 +torch/include/ATen/ops/threshold_native.h,sha256=dH0xAj1fLpzN041-NELp8M2uQR2RldMtZEz7tm8UxWo,799 +torch/include/ATen/ops/threshold_ops.h,sha256=WRhObMxfCsKb1K9TL9aqwoO65pjazNOGrr_bW70BPKc,2701 +torch/include/ATen/ops/tile.h,sha256=JV6Cm30qxcqzvNHAzskQR46qZV0sj_Klf92MThS5uC8,1349 +torch/include/ATen/ops/tile_compositeimplicitautograd_dispatch.h,sha256=x2Ibfd3Xz2YWbxrJljyuI3hTpdJ7Pq-HRpOznFi5Nes,869 +torch/include/ATen/ops/tile_native.h,sha256=55nA7gCCfNm7no1BlBGeGWdBhFfucaqfbRyxnYBWja4,518 +torch/include/ATen/ops/tile_ops.h,sha256=zkhuW1i2z8v3u0U4LFyOMIIUAUGBq2BlBFwkQ6IuOF4,1049 +torch/include/ATen/ops/to.h,sha256=grBm2JAETXxVNEmEMOdimrwCLiTKfNUY7snQt2l8bJo,487 +torch/include/ATen/ops/to_compositeimplicitautograd_dispatch.h,sha256=kTS7swpV9zYihvaEf2ByZIN47zLVNPZhCXZD7TFc9jc,1701 +torch/include/ATen/ops/to_dense.h,sha256=HqmHPuL6zSiYhYY9aoHNaSsxO3tTPisViHvJ21Foyq4,493 +torch/include/ATen/ops/to_dense_backward.h,sha256=Cf5tqUw1e6N3qtNs4et1YQx93Yelw78G011TrkJsAJI,799 +torch/include/ATen/ops/to_dense_backward_compositeimplicitautograd_dispatch.h,sha256=p4pyGWPEkWDhVNIGwE1U-FoRcAW4xn9x-K7ArHyXZzY,847 +torch/include/ATen/ops/to_dense_backward_native.h,sha256=vfH0PLEJeAiuny6czLGcp1LX2u6iXXQaFb62OhupsuY,570 +torch/include/ATen/ops/to_dense_backward_ops.h,sha256=xBdMiDbf1XM26mLk45nswVMqLl5ST7xtzwIsDTv3xy0,1197 +torch/include/ATen/ops/to_dense_compositeimplicitautograd_dispatch.h,sha256=A-w2FvjXe99_1Oa38_D7raDGmXLempsuj6sAFUTxFdc,862 +torch/include/ATen/ops/to_dense_native.h,sha256=ybEcHosezGVeoGjinmK9ALPv7E6Grkr3lRJq0W9Yil4,585 +torch/include/ATen/ops/to_dense_ops.h,sha256=yT6AJymggKjZdD876fjBHlpvqDxNzWFr4NBZe0Fw6Wg,1216 +torch/include/ATen/ops/to_mkldnn.h,sha256=OgQ58eq9zIhEuPK1x6tk0lZ16cuXGQcEbZbiAPgCrog,1050 +torch/include/ATen/ops/to_mkldnn_backward.h,sha256=X4wGD3cc96NstL22mNO73SO3ndfUr4-0sFU5Mkpleiw,720 +torch/include/ATen/ops/to_mkldnn_backward_compositeimplicitautograd_dispatch.h,sha256=o1U7p_HbsENzQVP_PpmA5ubxRWXo-UpTP8W794QHH7s,802 +torch/include/ATen/ops/to_mkldnn_backward_native.h,sha256=JMOubFopgIWxw1shuIdVADAMVmc6RGwhfbdWE4rXJCE,525 +torch/include/ATen/ops/to_mkldnn_backward_ops.h,sha256=zedYIO6QZXPp0nYymjPxoWQC3rKZamYlKU1pZHxb6Rg,1089 +torch/include/ATen/ops/to_mkldnn_compositeexplicitautograd_dispatch.h,sha256=QuHx280QOuY7h_2t3SMgWbNrC_3Ndp7hZHWXrTk_jxk,960 +torch/include/ATen/ops/to_mkldnn_cpu_dispatch.h,sha256=ouw0kzsrkZql4mGhKiF_bkqeiLOU66rNDUdbLcRA308,773 +torch/include/ATen/ops/to_mkldnn_native.h,sha256=_9ebwiAwulPG7FIXaKbt1AVHiMpqGOAQ37wmn20QSZU,664 +torch/include/ATen/ops/to_mkldnn_ops.h,sha256=csez7AfEl1kuzXBZ-9miGfcHWNQgAlsBX1FAYFuVfVs,1866 +torch/include/ATen/ops/to_native.h,sha256=NXWgKVusf2yHJpBtlEbgTqJPQDMXEITB-tUyQkwmBjE,1279 +torch/include/ATen/ops/to_ops.h,sha256=jncSF0jGa8xRvj8_OgZtL7CHm4xdKtBV_58PqxOdYBo,4513 +torch/include/ATen/ops/to_padded_tensor.h,sha256=0ozILxzoprQiuFjleBjEDK-PrKEvw5KmXTN4fmeNHO8,4333 +torch/include/ATen/ops/to_padded_tensor_compositeexplicitautograd_dispatch.h,sha256=V8gM6wwdfi1uWVRY362NBlTQMNAizjArT8CbInwLHYU,1322 +torch/include/ATen/ops/to_padded_tensor_native.h,sha256=kk6308S3JdJNMc1fsY5ZfmPtjLU5xuTxvFGmQ-MxhNM,883 +torch/include/ATen/ops/to_padded_tensor_ops.h,sha256=_9JDLrYzs3Xr64qcCZVc5nuKIwFXGP0gVCsxz1_Demg,2032 +torch/include/ATen/ops/to_sparse.h,sha256=seGUZi67YBKhEzm10kqPBtJJpgWgvlsoKiYbu7FY4js,494 +torch/include/ATen/ops/to_sparse_bsc.h,sha256=NJz20y2XBjhh6r8FUZ_7KZBRU4DeGmLhzxeMYVXOuEY,498 +torch/include/ATen/ops/to_sparse_bsc_compositeimplicitautograd_dispatch.h,sha256=eDmQe3hy-yBZn6yGd9gFKGYK3rijF7XFQy-oEWuLCns,845 +torch/include/ATen/ops/to_sparse_bsc_native.h,sha256=6MW7XiB6r2xBgrPfsNUCVESkkRZz1ONnxueV7oEYzus,568 +torch/include/ATen/ops/to_sparse_bsc_ops.h,sha256=SiF0t0ArOkGmWuYiK6GjmSaQnpt-78_QAOJle6Rjhnk,1190 +torch/include/ATen/ops/to_sparse_bsr.h,sha256=Ve0CnVnfjrIGltPM3AyXqwMmQ3x1D39KTlHBTPpBFSQ,498 +torch/include/ATen/ops/to_sparse_bsr_compositeimplicitautograd_dispatch.h,sha256=GseeqnGkX8qgWlHGLVv8l2_n8Fg8ifHUX6IS-AXUWPQ,845 +torch/include/ATen/ops/to_sparse_bsr_native.h,sha256=WivTQsCi_uP7qnkzOcfEAmyYLDGZyzcU2MMOqVNygdg,568 +torch/include/ATen/ops/to_sparse_bsr_ops.h,sha256=cd1QQJwcHLSkfPj7FIkI5xQobtfsVFonzkcVH2cXO2I,1190 +torch/include/ATen/ops/to_sparse_compositeimplicitautograd_dispatch.h,sha256=W0JsAYePFCis94_IxipapB4inUavbPGXOYyD3F7-Uf0,986 +torch/include/ATen/ops/to_sparse_csc.h,sha256=BEAGLlDboTbLqhwAnoywpUVpqRu6sqjze_iayamrHmM,498 +torch/include/ATen/ops/to_sparse_csc_compositeimplicitautograd_dispatch.h,sha256=F3gyds4hcnI1GBaeLefiiLTuPKVAsMmFiC8HMZ6CQ_Y,818 +torch/include/ATen/ops/to_sparse_csc_native.h,sha256=L6rURVO9anrau2LWAjwp1ZFtuoz1WTuqP3C9Nn0z6L4,541 +torch/include/ATen/ops/to_sparse_csc_ops.h,sha256=vKHaVDtQ9XqK8luFkleY5nZfg4y4sL-LF_L9TFpLjQI,1101 +torch/include/ATen/ops/to_sparse_csr.h,sha256=vrTNwucbYg2QrstmMmXcM0GKIooe1vh4ESMZqRJBnlk,498 +torch/include/ATen/ops/to_sparse_csr_compositeimplicitautograd_dispatch.h,sha256=FUUhjg1ZV48RKMcb5qNgtgfg2F_Wi3vJupKC7EbOaCw,818 +torch/include/ATen/ops/to_sparse_csr_native.h,sha256=ZeBx8LDl5dmNVBDpC1k7Hml6SNUSdg5qFeCDDzkwywE,541 +torch/include/ATen/ops/to_sparse_csr_ops.h,sha256=cVhetmmSN0OiAOm9xWDEIu6cTJ43U_ej2ZRMCY3LPCc,1101 +torch/include/ATen/ops/to_sparse_native.h,sha256=o8O0EahjiDjCKR7We5xhcU0PyKbK7lj6NnsDb6pgVNo,709 +torch/include/ATen/ops/to_sparse_ops.h,sha256=zCKLu093SfRtZqYdfCqBUKwASvesrweAA_yIQ30-wTk,1966 +torch/include/ATen/ops/topk.h,sha256=4rMVVeKziqV8eyRF5LxhP_prqQAgNymTSM2wQR3sfKk,5141 +torch/include/ATen/ops/topk_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Qu0OyAdcsi7Ks4bmOM93_aOrfJ03amuShm2RqKLcI_k,1029 +torch/include/ATen/ops/topk_cpu_dispatch.h,sha256=ERn1_1XT0uAPbmK1lWlgdyvOj-Hd6_190nRgA4WHx6c,1725 +torch/include/ATen/ops/topk_cuda_dispatch.h,sha256=CD6MfzITyCeasLUBDCXzJlyRHKdInCNM0E7QGmAX_FY,1727 +torch/include/ATen/ops/topk_meta.h,sha256=_Wfz1wUGHzpzT7eORsxifz_iU7XLuMVJe9RTyrdYw4k,635 +torch/include/ATen/ops/topk_meta_dispatch.h,sha256=XCFU7buxPpBvL5pAtkHyRr9GkCzBTWig_VjP03734kg,1727 +torch/include/ATen/ops/topk_native.h,sha256=oYJL6ItKdn5AIqTZgWk9fK5X174c8OAOQ0-iZYMzeJk,1066 +torch/include/ATen/ops/topk_ops.h,sha256=OVlMEXCgUOZLuWFw-C5Ra5GArarNbIoucWSJIMVljqA,2290 +torch/include/ATen/ops/trace.h,sha256=MUxgYN8N2Yp0rWp62jKQNAWDlrA1MAB2f9bwTgjhcOw,1005 +torch/include/ATen/ops/trace_backward.h,sha256=WNzauX7JBN4XgofUxxV55zEZ8BB039dASpbRxv9Mwow,1469 +torch/include/ATen/ops/trace_backward_compositeimplicitautograd_dispatch.h,sha256=tWr4wy15EycscUG1zc67fxftS1dMqw6CNkXOqIvdbpw,891 +torch/include/ATen/ops/trace_backward_native.h,sha256=_OwG6AplpOKt5JUNUA4qAuRgB6q_5szIYFPwL5ia1Mk,529 +torch/include/ATen/ops/trace_backward_ops.h,sha256=JMFandPNxtKUKJ8eJX9xeDYx2_ZbS8vdeb6KR1HJNMg,1082 +torch/include/ATen/ops/trace_compositeexplicitautograd_dispatch.h,sha256=F5a6MKncE7PD2pe2adeoMQ8wAyYfn7Rjwf3OPwOmgbM,865 +torch/include/ATen/ops/trace_cpu_dispatch.h,sha256=JXw0FbDz4QYdluTWpWIuOeS86zits71-T2xImJn-ujE,719 +torch/include/ATen/ops/trace_cuda_dispatch.h,sha256=s1JLCXg53uWtpfvz1nayHb7_NY9kfs6Fa9pkMFLGi-g,721 +torch/include/ATen/ops/trace_native.h,sha256=0WKPJmjk3lL-5XL8ET7AOIo4--m45UldbIhxWGVZGXs,625 +torch/include/ATen/ops/trace_ops.h,sha256=P3-IlZvjpwwx31wm5JI1JPmAD6BTLyh2X7WZ_DYls1k,1584 +torch/include/ATen/ops/transpose.h,sha256=rR15sjRw0gzcD3BaHyNzZp6w2s1Gj9r6Lsb2LsVF6J8,953 +torch/include/ATen/ops/transpose_compositeexplicitautograd_dispatch.h,sha256=agl0kg8AFsNUCam_VNjFJUP0acOTmLhC9ibOP5O8WZg,877 +torch/include/ATen/ops/transpose_compositeimplicitautograd_dispatch.h,sha256=HDXuYGWsSldkOukUY8Jg5ldFKv0l8DBdbrkWhCxF4sw,803 +torch/include/ATen/ops/transpose_copy.h,sha256=5JqZgyi1jC1y3BJ4P07CttFLPQrcxpztr03ONefY3Bw,1299 +torch/include/ATen/ops/transpose_copy_compositeexplicitautograd_dispatch.h,sha256=5j80UW3aOQTbObPFi5YKK6ElrRT-V9cpCi5qdYtfbM8,939 +torch/include/ATen/ops/transpose_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=XNWCxj8jCzhf3rX0tjlrlHn_TbHckzwH4pHBIkhcPLg,826 +torch/include/ATen/ops/transpose_copy_native.h,sha256=yLe118G8oLyc6_-AJTp83WDIAtWGe6sch9tUD7ekRqA,645 +torch/include/ATen/ops/transpose_copy_ops.h,sha256=nUC6D7yTEWFrmAa9-surUCVBpJvNLFqIsDbjaY5XOpE,1849 +torch/include/ATen/ops/transpose_native.h,sha256=pAyfTUTSnWlPFEfGMBv0w5vuQHm2Q7dTkLy9Y-oXInA,785 +torch/include/ATen/ops/transpose_ops.h,sha256=6bkYie968JwSo9pLcqrijkbz_UZ8MUHKEqROQf_oTHo,2419 +torch/include/ATen/ops/trapezoid.h,sha256=aIQa7yTbotF_QVJu5YlEoq9qTKE_kSkl1XuzbSL5woI,922 +torch/include/ATen/ops/trapezoid_compositeimplicitautograd_dispatch.h,sha256=q8UX2QQ2Ad6z46_Rzvu7f8bjed6-3jUa1CbufrObrvA,897 +torch/include/ATen/ops/trapezoid_native.h,sha256=W5sdVAk-bJk-5D_7oJ6OlmF3apa9LOc5BbiH27S-tJI,620 +torch/include/ATen/ops/trapezoid_ops.h,sha256=UMZSCFa_q1IJDZWsxPgWE42TzB6-pNMdALp2PgM6wkg,1766 +torch/include/ATen/ops/trapz.h,sha256=4N3aO2SfuU53GDu3KG0u9dPseeXa_WUE0Xv4mhFtrJY,881 +torch/include/ATen/ops/trapz_compositeimplicitautograd_dispatch.h,sha256=wI6ESJPpPf_y3Z-Bdx9VteUyISKJxG3dmU28mTVKc10,877 +torch/include/ATen/ops/trapz_native.h,sha256=PpMqlhW2onjahh_qKhv3rO3yy8hAVw706i-U8vLS8Vk,600 +torch/include/ATen/ops/trapz_ops.h,sha256=G7QdPGZjes52Kt6S7hQBynpL6sfiWLLKTD86WonjQqI,1705 +torch/include/ATen/ops/triangular_solve.h,sha256=i0Dr3ivSjnd51TNTTah1hT4Tl-jpedVk28oDroaTur0,1939 +torch/include/ATen/ops/triangular_solve_compositeexplicitautogradnonfunctional_dispatch.h,sha256=54BpzwCgBVYaCocIOnfpzoHGSxoeoeY5sxqEmA4PHNY,912 +torch/include/ATen/ops/triangular_solve_cpu_dispatch.h,sha256=4mDBERpVsAd87vv7zmPj38fvhI8oH71PvxnpdqozmEM,1258 +torch/include/ATen/ops/triangular_solve_cuda_dispatch.h,sha256=YGfgPUfS-ShS8mVX6Mgp0us3HTala9o7KfLjQMyBGhE,1260 +torch/include/ATen/ops/triangular_solve_meta.h,sha256=1oJ1VMBHvzr9b0Hr3f6n3ihMNmF_hmSeluzUVpIWN-0,666 +torch/include/ATen/ops/triangular_solve_meta_dispatch.h,sha256=HsmQ_mvLK4TYiDJ6AzbGe-U-kcev6MW76ZZRUl4HVmE,1260 +torch/include/ATen/ops/triangular_solve_native.h,sha256=7_GZIuk0gZxPi2QIFM9TIgZPVdsjmD-NXqWCwaTTfOM,1156 +torch/include/ATen/ops/triangular_solve_ops.h,sha256=_jFSl6Hbvc3v3wEAGrxbbWABtvMpD-93OCx1RV1NYJk,2440 +torch/include/ATen/ops/tril.h,sha256=XIP73wfLdaErGSMFwX9VLNPwuRsq_cPJe7lyYCbMK98,1131 +torch/include/ATen/ops/tril_compositeexplicitautogradnonfunctional_dispatch.h,sha256=5-ohybdX3JN90qOoOeDGCnVmMZHuu6_5-9Z6ujwYU30,877 +torch/include/ATen/ops/tril_cpu_dispatch.h,sha256=j_cPObg-KxVFPU6Y-vIKSj0dozihDnRrV7B3jgqqjHc,998 +torch/include/ATen/ops/tril_cuda_dispatch.h,sha256=miRBJvkWAqXD_TJc29cPccMPu-VDeF6uu6LUSVr4wbI,1000 +torch/include/ATen/ops/tril_indices.h,sha256=ab3SD6BpMR8TZEKbakNsWhVTAN37p55pokfl3rWxpZ8,1940 +torch/include/ATen/ops/tril_indices_compositeexplicitautograd_dispatch.h,sha256=UgI7ZUKrj4gfcTtZKisRtOPfGnksOxjaQNlk368jLcc,915 +torch/include/ATen/ops/tril_indices_cpu_dispatch.h,sha256=DnSvDAREPkcF_vAVbs4zjJ1bO0WmJFIZr6vdnrffrhU,996 +torch/include/ATen/ops/tril_indices_cuda_dispatch.h,sha256=skDIxILRkuHTiS9Qo0Vvh3BPeR_0lIAr75d3cYGVoy4,998 +torch/include/ATen/ops/tril_indices_native.h,sha256=n0F52HYfGft_6LsjxEA-h3xpQimFgjb7UmGVzPgo6zc,999 +torch/include/ATen/ops/tril_indices_ops.h,sha256=fIjwpTUJ4C5Y3kdtkZkBOBXhDIypys_CpkEAp3vFSOo,2218 +torch/include/ATen/ops/tril_meta.h,sha256=hm-R-5tuQNZ3xh3DNrm1o9Ygq0PJ5qA3txW0kLf1Xow,602 +torch/include/ATen/ops/tril_meta_dispatch.h,sha256=PrOhBhmmnHj57L3DJK8aXMf6jwrDSYp39VtAHfBGztQ,1000 +torch/include/ATen/ops/tril_native.h,sha256=LBqVmJLe7BawASyR88ukv3IBvDMAvlmYnPKJRglWfgI,775 +torch/include/ATen/ops/tril_ops.h,sha256=FZqlKS5ozvLTFrcY4RYk-Rk0GWKSJ7-sV2q_ZlNqWXI,2287 +torch/include/ATen/ops/triplet_margin_loss.h,sha256=kj_fWTC7ETTbdVgJpyrH1ZR8PJlz_e4_iW1FghQ4KCE,1016 +torch/include/ATen/ops/triplet_margin_loss_compositeimplicitautograd_dispatch.h,sha256=EMaoyps0TftBzAgskERCPXzYrks9LmGR02cxsBjaSuc,942 +torch/include/ATen/ops/triplet_margin_loss_native.h,sha256=yPHOZxcAVNevXXxbX2yPHo2BAU8NxqZeHsd08YsQwjA,665 +torch/include/ATen/ops/triplet_margin_loss_ops.h,sha256=6Z3gauIedKrICmOAaX4DzQQEj1hbRlr-5XBSUIdiYDc,1458 +torch/include/ATen/ops/triu.h,sha256=YYuVHDyMWi5evygktdEMUBi34BJyccLYdmj252Zqx2U,1131 +torch/include/ATen/ops/triu_compositeexplicitautogradnonfunctional_dispatch.h,sha256=PX9h-oZr-IeA5-SCyd50CqcHOs0RCEjPdxbglUIWNh0,877 +torch/include/ATen/ops/triu_cpu_dispatch.h,sha256=Nd4WAAsCxgo6iW_nybTuUmbAtpgBbF3H3ksogxbNG6w,998 +torch/include/ATen/ops/triu_cuda_dispatch.h,sha256=WP0LKqNl0j_S-p9X53c3UjVUqOxfuNA673ouNfSM92Y,1000 +torch/include/ATen/ops/triu_indices.h,sha256=ffhHzarLI3O-9qPpDqY3Ybq3ogqMpgtwplosPhFBkaU,1940 +torch/include/ATen/ops/triu_indices_compositeexplicitautograd_dispatch.h,sha256=Q0aLJMcY8QNG1bYbVLkKUPuXQX3E-foqOf1YuXn1umA,915 +torch/include/ATen/ops/triu_indices_cpu_dispatch.h,sha256=x_utdFIoXgf3fkkCKmdqkV9MksgA1b3XtNEbzzSJrAM,996 +torch/include/ATen/ops/triu_indices_cuda_dispatch.h,sha256=NYTqXhx2sVkOomzbJkLrnYoM4G3w1SklpfgOnsLtgU4,998 +torch/include/ATen/ops/triu_indices_native.h,sha256=0N1rEtVftLQs9-asBXXcnj_9ioSaZecUqXfRh16APUA,999 +torch/include/ATen/ops/triu_indices_ops.h,sha256=fmirMUmP91twASvviSyIbnU47KFI06p8KJUpAepm66U,2218 +torch/include/ATen/ops/triu_meta.h,sha256=MPCshj0SDUkRYd4sVeq4TF4ZvLiWowwk39-0m4nAEM0,602 +torch/include/ATen/ops/triu_meta_dispatch.h,sha256=zYdPTQ3dJWM0q7JcfWW1HKVpOJlqGtmisHjjVMEgPbI,1000 +torch/include/ATen/ops/triu_native.h,sha256=fqHGhniYaKSTMSuuRoVhpYK5QaA08sP6gAxilsUIWRg,775 +torch/include/ATen/ops/triu_ops.h,sha256=5Fv53MtNBRPos7hHMM24biCweAcfBg0xm4U-EI36sM0,2287 +torch/include/ATen/ops/true_divide.h,sha256=CZ2PotWa89piZ0BWqvtdDDNHurMbOROIlR6ayK9GGL0,1431 +torch/include/ATen/ops/true_divide_compositeimplicitautograd_dispatch.h,sha256=zWjpyEZbtEpfWk7ccj5FH8Q00U1Nb66PiHBunX1ZYLw,1263 +torch/include/ATen/ops/true_divide_native.h,sha256=VG-RWqZF2npaeVKo7YOO-iZojmTjh4s5PUGu1h91bd8,876 +torch/include/ATen/ops/true_divide_ops.h,sha256=sds1tD52MH7QC6EevBZxXzOrGLbY93cRrCuMglHp7sE,3772 +torch/include/ATen/ops/trunc.h,sha256=QjZClYKDxgUQZc1WuTPUBoDk83tVGA-LjcfjzrjbpRk,1144 +torch/include/ATen/ops/trunc_compositeexplicitautogradnonfunctional_dispatch.h,sha256=dCO_GcChs0manJdXYG3KlV6SdApOOhvKj2NYp03Ecqw,839 +torch/include/ATen/ops/trunc_cpu_dispatch.h,sha256=7x287ZQuYusJI-GdJeLu_NOjQ5KwGCgIOUEPdBxqYos,924 +torch/include/ATen/ops/trunc_cuda_dispatch.h,sha256=2KiQVNSCQ77QcAck5fdOsL4p1QfoYrIrYzC_smc0upk,926 +torch/include/ATen/ops/trunc_meta.h,sha256=nCgqk1r2eUEzWo5KkIcadMAANcHi43JB911MlWOj2h4,585 +torch/include/ATen/ops/trunc_meta_dispatch.h,sha256=h1ynWuXUj0jZukKd3czkxuc5o-DmjfnjfAu56MeCzeQ,926 +torch/include/ATen/ops/trunc_native.h,sha256=5vlgxRmFTnqGSPweZwU_c6ox-sK7hgalFc9rPEcCj0o,1018 +torch/include/ATen/ops/trunc_ops.h,sha256=9o8dYlUJGpFbmOqslZXm4XbDBg_g83jZAYUkBgNu0xM,2113 +torch/include/ATen/ops/type_as.h,sha256=_Kqh2buRdf_d71-n_naIZb_8kzNAtBT3g5n9g9MX5qs,492 +torch/include/ATen/ops/type_as_compositeimplicitautograd_dispatch.h,sha256=CWUeUszFQE7v0_E3bA0qmhH94ZNtfbkBe8x6Et0I2gk,791 +torch/include/ATen/ops/type_as_native.h,sha256=OlXgswqHbJQDngM3Q5C2yPIAItLZQyWuiWsTa49m4GQ,514 +torch/include/ATen/ops/type_as_ops.h,sha256=Cwb4P3BnP7QaVb5I18dUJzBpUDKoTGV8FPH0geA9u8g,1056 +torch/include/ATen/ops/unbind.h,sha256=IMWWMoSoWISAxhrGM1h0Ct9Gde_J_ersK378-XLzZBg,906 +torch/include/ATen/ops/unbind_compositeexplicitautograd_dispatch.h,sha256=P5-8u0Hw_MalXZ1LzEQCnVuF13fL9PVqD_ZGryKK5Nk,794 +torch/include/ATen/ops/unbind_compositeimplicitautograd_dispatch.h,sha256=wKmUNYKWbty4rnXxlpkgupeVI0AYPjyCEIF682ucCLs,796 +torch/include/ATen/ops/unbind_copy.h,sha256=4frsQWt6kNu5xzO7QE9DTl6sewV352gS3NWD2fLhRgo,1173 +torch/include/ATen/ops/unbind_copy_compositeexplicitautograd_dispatch.h,sha256=tZcnH7E_Rne2WwO-wZvuXod1gwYNnY9OzaJGbsK0OOQ,893 +torch/include/ATen/ops/unbind_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=BPbMKVtyBGozDLypoJSZ4YT3B0TYkXe8KJr9kPZ0AT4,825 +torch/include/ATen/ops/unbind_copy_native.h,sha256=GqiUsASQIXbLYp63HwwcE1Teij75vdzO-QqWWbgmxA8,620 +torch/include/ATen/ops/unbind_copy_ops.h,sha256=JnEfSgUJ5EQVd2GpdvaJPSJ06h-RapJY1jnxcSU3RP8,1758 +torch/include/ATen/ops/unbind_native.h,sha256=6kf3381R1fRxmZJDwqQ4EjoWvPfB0URUxYmCVmmhF4c,700 +torch/include/ATen/ops/unbind_ops.h,sha256=zdHxDshziLPW4ukER7cKZlOO-g1xRGuADHaVG3oo7b4,1756 +torch/include/ATen/ops/unflatten.h,sha256=UR585KKBZdbJrc1UBuzy4DMdbbKcc6kEXZ0-YgLzQ4A,2789 +torch/include/ATen/ops/unflatten_compositeimplicitautograd_dispatch.h,sha256=zHf393MQjxFSlIYna-UxDi_6z7-sx6qxLCQj7k4xlG8,1158 +torch/include/ATen/ops/unflatten_dense_tensors.h,sha256=CqZe1jx8hpDTiJgwpORZPOrMMnp04bIfgtlrgxlmUx4,761 +torch/include/ATen/ops/unflatten_dense_tensors_compositeimplicitautograd_dispatch.h,sha256=cUSLTgLf47XSILcdecH2hWXx0hB7llik-5PY2Ar8Z90,820 +torch/include/ATen/ops/unflatten_dense_tensors_native.h,sha256=KFhHMw1zLowtxdmuh-xsBtPyi_1VzEsEPywmlAZIF9M,543 +torch/include/ATen/ops/unflatten_dense_tensors_ops.h,sha256=1y2g41DONP_FkCw6yOc29k3IDwCEnTOJPsAShhroWIA,1147 +torch/include/ATen/ops/unflatten_native.h,sha256=sXrsBPxwXAHwtCmyP73cKiEPdBj-Jalwgie5ebH4GfI,676 +torch/include/ATen/ops/unflatten_ops.h,sha256=gSIBZnVNbJRhlnoMhKPYCfJCIyuRjK3asEmlsJ9gcGs,1930 +torch/include/ATen/ops/unfold.h,sha256=3Lai5eT6vk3mVIvQVedLzxptXZTMn5_z-Zth0yErvHM,491 +torch/include/ATen/ops/unfold_backward.h,sha256=mG7wxFrLveYGlIPMEJFAFJ0jh8LtJb8qHG4YlwPgVvE,4958 +torch/include/ATen/ops/unfold_backward_compositeexplicitautograd_dispatch.h,sha256=s21Jla9nR7AByxPwXA2TpPWa3kSZDuKexQsaREH-rEo,1374 +torch/include/ATen/ops/unfold_backward_cpu_dispatch.h,sha256=Cv4Sd5OPcEBovk7cKpvA5aFM2vjRZQ_Thgh3-PNP1Oo,949 +torch/include/ATen/ops/unfold_backward_cuda_dispatch.h,sha256=5CmCi4YmNeHvOoOtkB7yP7IIncUGYTo-rAW7joyHihA,951 +torch/include/ATen/ops/unfold_backward_native.h,sha256=D2rPiuqPoLoVx7bS37_xAILZMlkNLaUfw7OdNDDxinE,740 +torch/include/ATen/ops/unfold_backward_ops.h,sha256=nAqa4yPi_p4zXhVZ3ByaKNeIbk8BFjBrlAX2PWFkncc,2156 +torch/include/ATen/ops/unfold_copy.h,sha256=-qmJo0yBtE9wRdcCx8WCDHgEXuqE8Q68jRJ8s_oKvr0,1380 +torch/include/ATen/ops/unfold_copy_compositeexplicitautograd_dispatch.h,sha256=ZeVZzMP-Ic18S1lxjtH87mfqULiUckew3lODT8e6c24,971 +torch/include/ATen/ops/unfold_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=-LZwhut8sqMT6KgTHomKxgVBStqiFMcrpeOkx2BW9xA,842 +torch/include/ATen/ops/unfold_copy_native.h,sha256=HSA2o5MdcQ7IQ-C4Dzyomt7qYYYWrOOfYdTmLK1VNgw,669 +torch/include/ATen/ops/unfold_copy_ops.h,sha256=BjyS1WbnGMZ_3oeVWsXWLpP52_AmL_wtHu0nO0EnmkU,1932 +torch/include/ATen/ops/unfold_cpu_dispatch.h,sha256=_bfZWQWfJQ8tAT9OpM4rihJ-LvYjSnRWAMe_IlYrnvc,767 +torch/include/ATen/ops/unfold_cuda_dispatch.h,sha256=bB615aoWn898Okd3MLj9w4pqZjqWBhf4rtELvCYCP2A,769 +torch/include/ATen/ops/unfold_meta_dispatch.h,sha256=xQP1zG-31Yy9Y22_jHUHu-gBIUaeutQbSFUAfbUXcIM,769 +torch/include/ATen/ops/unfold_native.h,sha256=Nd9GZaYPCakzdSmxkZ3jZ9rDf58n-phPT2GVlo00RII,534 +torch/include/ATen/ops/unfold_ops.h,sha256=-u6058GVn6JGkHsI9t-GJlatDnsWU_usQ41406wbZ7M,1129 +torch/include/ATen/ops/uniform.h,sha256=ppPNQWWVLevFiiwzsNwLnao9c5orW6Fc-kB_9QelnVc,1476 +torch/include/ATen/ops/uniform_compositeexplicitautograd_dispatch.h,sha256=JxwNSErxJB0IyvJFvlpxBNrW0r54CVboMlbHhPXXpB4,1150 +torch/include/ATen/ops/uniform_cpu_dispatch.h,sha256=MUyEpJUTnmGg0ElahnRVMD-1_Vp9sxpy177jcW-Aseg,799 +torch/include/ATen/ops/uniform_cuda_dispatch.h,sha256=qnWKT23UMUDyIisWUTKh5jQKsI6kbG7crTrhU3QX1pU,801 +torch/include/ATen/ops/uniform_meta_dispatch.h,sha256=kVTNADPGnv3-RCv6YcVD-665Nst_681MqnFDjmqWMWo,801 +torch/include/ATen/ops/uniform_native.h,sha256=hPY6X8qRIdE5x48_t_fve4faGRmkSftNIpMK3vlyZAU,983 +torch/include/ATen/ops/uniform_ops.h,sha256=8nr1aCeYbDGELNtC3X7zLQYzUrrWOe60RJ5KV6XfMI4,2818 +torch/include/ATen/ops/unique_consecutive.h,sha256=sFWBZjO7UCMl4X-CJEGWQ6g4sisa0y4hUooRrNG6hes,2064 +torch/include/ATen/ops/unique_consecutive_compositeexplicitautograd_dispatch.h,sha256=fxYOB-hgAfCXBuyYJa7QFgOg4DCDKCtT0AHEtby0SLs,1212 +torch/include/ATen/ops/unique_consecutive_cpu_dispatch.h,sha256=_vwlJvm4MWUpFNj3aGagw2Jvhm8pziFR-g05LxBN-bg,862 +torch/include/ATen/ops/unique_consecutive_cuda_dispatch.h,sha256=0nR3Rp8JAiRvlgMCXE9QG9Mndg6WxY7PjdhkmtO8sPU,864 +torch/include/ATen/ops/unique_consecutive_native.h,sha256=QkAphXCxsVIq_J1Zm6Ve4ACO97hB_eQwsUwJLsgWBEE,1072 +torch/include/ATen/ops/unique_consecutive_ops.h,sha256=Ie4y0YygSunGO53q8Fct_0FS7p0JCGf4EQ3nZh-PUdM,2559 +torch/include/ATen/ops/unique_dim.h,sha256=c5uBYVNAwhuXto8xQwuStkl_ar5WGzOELwvEuT9oBOw,2022 +torch/include/ATen/ops/unique_dim_compositeexplicitautograd_dispatch.h,sha256=mGvoKTDt91GrTz4tbwndAWq5NtzXbjcBolqf_6HLhrY,1184 +torch/include/ATen/ops/unique_dim_consecutive.h,sha256=UadgmDfMq-Eiu-6-4E2EPfM8Kiai5kaQg-5R3CGo0NQ,2015 +torch/include/ATen/ops/unique_dim_consecutive_compositeexplicitautograd_dispatch.h,sha256=fhDAveSIwKj7Jf2U3akTUpp5YhDdggQwCrof8RgaOAw,1177 +torch/include/ATen/ops/unique_dim_consecutive_cpu_dispatch.h,sha256=nLPzCmjdXHWrskuLfFHHf-luFDHNgmHfBBzH-yxSlDI,838 +torch/include/ATen/ops/unique_dim_consecutive_cuda_dispatch.h,sha256=Oy4vN83UYw6fY0ufd_hxUSYN-ZMLFOuS8Km1sazC3D4,840 +torch/include/ATen/ops/unique_dim_consecutive_native.h,sha256=5X5YfoP7Lu3x9aqT17iz3gsPu7eFOU6aM2DLdEYBOUM,1013 +torch/include/ATen/ops/unique_dim_consecutive_ops.h,sha256=Axgxc3NESLfOVTg7abGm9ZM-_j3yv-dcPoZsO4iSEAo,2481 +torch/include/ATen/ops/unique_dim_cpu_dispatch.h,sha256=YhfPIoL_2AJ2djZBElHEruKQu_nSdIRtU3BL4UpP84Q,844 +torch/include/ATen/ops/unique_dim_cuda_dispatch.h,sha256=wm4zKSt_s3pEMtFyEep_TQDj-2-xGSn1aQ7hDPFdf0g,846 +torch/include/ATen/ops/unique_dim_native.h,sha256=2bGSJTVpwn_GG-5avrfv29rhStU9EPnxByGAIaj4uYY,1026 +torch/include/ATen/ops/unique_dim_ops.h,sha256=R0gJz2e80ErQv6xbXzgEde92h0XqrgorZAPbG21wDD4,2509 +torch/include/ATen/ops/unsafe_chunk.h,sha256=6Mpycqv3IkysdeiM-vd9bzwOkCsV56jYr7UG6veZtWg,733 +torch/include/ATen/ops/unsafe_chunk_compositeimplicitautograd_dispatch.h,sha256=pGS7-Ry2a7G1fkVO_TpKYV9brG-1kwH6wWrt0rWxDRc,816 +torch/include/ATen/ops/unsafe_chunk_native.h,sha256=XnKMFvewJwKK7my8-Owju6bXEwzJCHNYd6UImhGrlRo,539 +torch/include/ATen/ops/unsafe_chunk_ops.h,sha256=i2YvZZ8sqs9QNoN0wQrRZRUq_fFaU7wObzo0xTdgCEs,1131 +torch/include/ATen/ops/unsafe_split.h,sha256=VE4tvXjVMrhu7eKvMK8r-UISysJmqY6rauNrBYlHryw,4027 +torch/include/ATen/ops/unsafe_split_compositeexplicitautograd_dispatch.h,sha256=RrpF52NWxPQsFD6bfk-7I9mVUxBKOj_ItvZ9jw_3t_k,1413 +torch/include/ATen/ops/unsafe_split_native.h,sha256=-eM2aTPJVsW1n8u2asrCV2cIiu2DTO9vQ0R-wv9JlwA,672 +torch/include/ATen/ops/unsafe_split_ops.h,sha256=8PHAIfhDzEVBzGoUCgmtEDs6TeMubmRgd8OO8mtr8_k,1942 +torch/include/ATen/ops/unsafe_split_with_sizes.h,sha256=nF5YEMneQHVQjJ2tJV0olbV2cJ03_tpfQVp8vrCXlWw,4536 +torch/include/ATen/ops/unsafe_split_with_sizes_compositeexplicitautograd_dispatch.h,sha256=06Bb0pwSFzqWLUeRmSWte2QvItAWKEpqenWOcSu22OM,1533 +torch/include/ATen/ops/unsafe_split_with_sizes_native.h,sha256=VbOkRUJ9yzQvXOdr42j8iUnRQdFl1ZhB1OPvAqXaHw0,705 +torch/include/ATen/ops/unsafe_split_with_sizes_ops.h,sha256=ZOdxXR17SPmbWnpnkZJzAzX0Gs0GC2f9auku_ozy6C4,2025 +torch/include/ATen/ops/unsqueeze.h,sha256=jxe_2wGo9aByIaNqTTo58aYk65FjakT9j-42IKXhvA4,670 +torch/include/ATen/ops/unsqueeze_compositeexplicitautograd_dispatch.h,sha256=7lDGAOB3oT4Ws5A116arqp5AbXxIRXGkrbVI1cZN9YI,847 +torch/include/ATen/ops/unsqueeze_copy.h,sha256=KPq64F-diYzhJvg2YYXmdMk_jRUf4ocm9XY6aPNDMPs,1176 +torch/include/ATen/ops/unsqueeze_copy_compositeexplicitautograd_dispatch.h,sha256=kYx0Dtzvdx26dxK07SQbptCeRRwv_db4JR0n1p4tYHw,909 +torch/include/ATen/ops/unsqueeze_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=FCD0pzttX8xpG4LFHpGw5e0Ml2QxY3wPSKaD1s9bkrA,811 +torch/include/ATen/ops/unsqueeze_copy_native.h,sha256=uyYq-v1nApcmE8nnMxabEyvdY-p-b4hssrdilCzjs7E,607 +torch/include/ATen/ops/unsqueeze_copy_ops.h,sha256=Uh7lr8nz9pIBK6lEZKJ3cg_wH5pHJXtZP1X9u1Y6omo,1726 +torch/include/ATen/ops/unsqueeze_native.h,sha256=tVVQ1EWtCT4OEr6GHomA9eje0jSXCx0a7YnAX-n1Tno,804 +torch/include/ATen/ops/unsqueeze_ops.h,sha256=DdYwwAIditYyg2wY8D44BGy-XC-9IZNO0_EAqD8LEss,1611 +torch/include/ATen/ops/upsample_bicubic2d.h,sha256=AZM4gDtCtUZijdBLx_2rQ9bACaVF_IbJNIM0zA6tTjA,7870 +torch/include/ATen/ops/upsample_bicubic2d_backward.h,sha256=eu2aDGlwBgj6qH9Ll-i1K_qIT7et4fbPYP43CO_qqg8,7622 +torch/include/ATen/ops/upsample_bicubic2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=a7mTWdYryHBwlUYtyfdQD8e0SHKYNx9O2255HqI_ANQ,1249 +torch/include/ATen/ops/upsample_bicubic2d_backward_cpu_dispatch.h,sha256=eyNWqatxronDFOOof297Rbnhz3PTqw_d6YZAIcdkgeI,2279 +torch/include/ATen/ops/upsample_bicubic2d_backward_cuda_dispatch.h,sha256=befLvlfpQaNWvKQyQTGyaQGTs6UIItg32kBZZUqetWE,2281 +torch/include/ATen/ops/upsample_bicubic2d_backward_meta.h,sha256=0bq6jp94XzyVCgUOYguZhNgMiLk_u9ysdOTe7rKPWhM,767 +torch/include/ATen/ops/upsample_bicubic2d_backward_meta_dispatch.h,sha256=84-sie0voK7zXpZ6j9wf6zmBgVkxt5UwGu5JdmXRBy8,2281 +torch/include/ATen/ops/upsample_bicubic2d_backward_native.h,sha256=PMcAuyfwZM3ckK9CpiPLzZx8UiWm7D7JFVvsR0cUdGE,1196 +torch/include/ATen/ops/upsample_bicubic2d_backward_ops.h,sha256=c0zGN17PCVJcTne1LzcWtrzOasz1RkYOPZOLTaes15o,2802 +torch/include/ATen/ops/upsample_bicubic2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=STHdoeDlzGGNNZ7aaPJ8kz3pMrR0uNQ7M1ALOfUvMNU,1157 +torch/include/ATen/ops/upsample_bicubic2d_compositeimplicitautograd_dispatch.h,sha256=h3CZ9mU1pZbJKRLFVhK8Gi41fJOoUGVujO8ohO-O0Ok,1070 +torch/include/ATen/ops/upsample_bicubic2d_cpu_dispatch.h,sha256=vvxgf0iUBV1E3p2Nz47jFZdW85VoF2IUFmkgLrTWzdk,1975 +torch/include/ATen/ops/upsample_bicubic2d_cuda_dispatch.h,sha256=4tP-ehdvuIkBsaUpWsq1M2ZvmggqhX7xtlWLMrfSTYw,1977 +torch/include/ATen/ops/upsample_bicubic2d_meta.h,sha256=4-Oqw_fbs2-7tLbkxOcnFcFvpvQyCTtYvdCUpCfWTVk,717 +torch/include/ATen/ops/upsample_bicubic2d_meta_dispatch.h,sha256=Q5n683kitcGLKKOmRAgymumbC1xvQIBD3xJC12HIMTg,1977 +torch/include/ATen/ops/upsample_bicubic2d_native.h,sha256=KY0kNKYQ3PzoH5GAFiKQTIWoATAoReO9SWd4SDdMqBE,1230 +torch/include/ATen/ops/upsample_bicubic2d_ops.h,sha256=HZ_QSdv--UnqNv1tv6kwVBADdXH-wI2eeTUnkWt7OXM,3393 +torch/include/ATen/ops/upsample_bilinear2d.h,sha256=ADFFkWIeK4GxL4jgfEFhaML55r8UBtEMB2vFhr9vPdU,7911 +torch/include/ATen/ops/upsample_bilinear2d_backward.h,sha256=nc6mybPt0GCMfU7FZlQjf3fltVnmrKxvzg2kaRiZ540,7653 +torch/include/ATen/ops/upsample_bilinear2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=1cxf8cBEYveuW4C83_ztuFe_5Kwjmz46R8KD5c6W1LI,1251 +torch/include/ATen/ops/upsample_bilinear2d_backward_cpu_dispatch.h,sha256=8P7blmIkQnWeAfExhFK8l093vGnIo30wGg3bvd2kr_k,2285 +torch/include/ATen/ops/upsample_bilinear2d_backward_cuda_dispatch.h,sha256=aMZvpoEpKAQ9C2Eq574Z3YrkPHRLbsv-uXGIbw1xan8,2287 +torch/include/ATen/ops/upsample_bilinear2d_backward_meta.h,sha256=5DBiJC1ccY_2CfglHRmedEwLB_Pt9WK9mM_tPe0xrW4,768 +torch/include/ATen/ops/upsample_bilinear2d_backward_meta_dispatch.h,sha256=1XBZb4Tp6_6UZf8XQWLVAPZiur6FfQu3s74HLdW56Xg,2287 +torch/include/ATen/ops/upsample_bilinear2d_backward_native.h,sha256=Uezyzh4A3_Qi2tp6rKIK2XI1xmRM9CxeqDnzWtfChoE,1201 +torch/include/ATen/ops/upsample_bilinear2d_backward_ops.h,sha256=yfQCuPNX2X8QjPK7Mku5XG4VeAgjyV7Dhq0AqF8lsLI,2808 +torch/include/ATen/ops/upsample_bilinear2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3pXECwZskaXNJkOOKaY-CLvIQ8_Xla8YXs-WwA8Wg4E,1159 +torch/include/ATen/ops/upsample_bilinear2d_compositeimplicitautograd_dispatch.h,sha256=_ghA7zs7cintggTCxvwIqyD3Jhh7FvcsTp6lqvxOXlA,1072 +torch/include/ATen/ops/upsample_bilinear2d_cpu_dispatch.h,sha256=woTXjF_7uFjbgcbIEum9NH702hSEm1hvufz43YhnCZY,1981 +torch/include/ATen/ops/upsample_bilinear2d_cuda_dispatch.h,sha256=B6c_x9s3ORwGLJcZJWnXML-yQcoQFphfw4yoCx6mDyg,1983 +torch/include/ATen/ops/upsample_bilinear2d_meta.h,sha256=K0sD0T5_eAkgcm-H51JAPdS44dTPfGDvwnQlIl1vqho,718 +torch/include/ATen/ops/upsample_bilinear2d_meta_dispatch.h,sha256=U-uMoCQSDCuaQrrWrS-yeBdnSgeCT0ROoT7lLhkY_lU,1983 +torch/include/ATen/ops/upsample_bilinear2d_native.h,sha256=tQSYhQiO94ZhU_3vbSCWC00i6HkmFxEfGqh0lgbD5z0,1456 +torch/include/ATen/ops/upsample_bilinear2d_ops.h,sha256=NQ0GxNtA4k64PH5JkxwxWNDqOfSAE0nzFbmT_WNFwCQ,3402 +torch/include/ATen/ops/upsample_linear1d.h,sha256=IAQPjQ5Vo3eKHBIQMOr-nW2_-xI5ZINfrwuegmyhR4E,7029 +torch/include/ATen/ops/upsample_linear1d_backward.h,sha256=qlHRfpPxa4vsFBCh_pcn2OzK67eIUD0y8VOMTAYtezM,6791 +torch/include/ATen/ops/upsample_linear1d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=lIG9-BDHQRJaU_bf4_ZxQ1INRoLp1qxSvtcxngpNMDA,1153 +torch/include/ATen/ops/upsample_linear1d_backward_cpu_dispatch.h,sha256=17fjumW2_OHqTv_Qx12WnC8rjQFd8abVZdzuaJPyHJw,2017 +torch/include/ATen/ops/upsample_linear1d_backward_cuda_dispatch.h,sha256=KAjsdo5wU7x3trJHHCCoHh_a696GG9A0j3l5qXE9tTU,2019 +torch/include/ATen/ops/upsample_linear1d_backward_meta.h,sha256=3U2xK4vuuQhAlNBh8fCNxTQzlWMftX2WK7TkWudbN7w,732 +torch/include/ATen/ops/upsample_linear1d_backward_meta_dispatch.h,sha256=4MoIIhCkz7cNDItJcR2mOZMszdSdYBJSNw9-SVL6Uxs,2019 +torch/include/ATen/ops/upsample_linear1d_backward_native.h,sha256=9A759Ic9YCQlvKNLsM_tVH-j1R-AYzA5RO8KQnK39R8,1123 +torch/include/ATen/ops/upsample_linear1d_backward_ops.h,sha256=GlP10mMiRDI_TjwwFNPpGu0CqZ-A6ObhJItfiZ6LySM,2566 +torch/include/ATen/ops/upsample_linear1d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=uj1_OhWNkfR4grQgYzYQ-YEq_4Zt5zxP2ipDrl8aJ0o,1061 +torch/include/ATen/ops/upsample_linear1d_compositeimplicitautograd_dispatch.h,sha256=VypGnCLrlZF1BUXf-3m2hDi_oL6WLt8ke1eLUckAEj0,1068 +torch/include/ATen/ops/upsample_linear1d_cpu_dispatch.h,sha256=1SPfQQeJp88TJDvYieGl-v5eJJGxweUjYAZn0eoEd-A,1713 +torch/include/ATen/ops/upsample_linear1d_cuda_dispatch.h,sha256=DF6MDi2580W3po6SuQ4kZDejZs0vCJsCowJ62EfgXIU,1715 +torch/include/ATen/ops/upsample_linear1d_meta.h,sha256=H76fv4GDCZxtw9JJ3rgkEsA6o-MzYLX16Mmpr0liRoM,682 +torch/include/ATen/ops/upsample_linear1d_meta_dispatch.h,sha256=dfJnqyEypDnejPTwY13f-DNTSDasMyWm9L58CbSQWys,1715 +torch/include/ATen/ops/upsample_linear1d_native.h,sha256=mqHyrZX6wnd_zcVaKs780JxAsHjfRaCdyz9s1M084Jc,1156 +torch/include/ATen/ops/upsample_linear1d_ops.h,sha256=XtxvkS_iy3IK8tG1PywZPIyDzEw8N-Ul0SbVSEPFduU,3154 +torch/include/ATen/ops/upsample_nearest1d.h,sha256=BUtq7VFIQMSlJlH9E_oPgVtW6nS5LonWvwybCFucc4I,6350 +torch/include/ATen/ops/upsample_nearest1d_backward.h,sha256=bEil7XZEbq11o_Op3V80BL6RqcKhsAAeAzj9UsSw0KM,6282 +torch/include/ATen/ops/upsample_nearest1d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=qRfl5OhCv8tx1ySn1yBd433bAYSyddVqsKl5_wml0Ns,1115 +torch/include/ATen/ops/upsample_nearest1d_backward_cpu_dispatch.h,sha256=WSACnJb-vmvg6KHmWiOsnkaT0WE_q1LvC6YM_OLW7Gc,1903 +torch/include/ATen/ops/upsample_nearest1d_backward_cuda_dispatch.h,sha256=SxMfIv0Br496ViL8MiFxXWTb8ZyqxtZ8L7NkETt8-nc,1905 +torch/include/ATen/ops/upsample_nearest1d_backward_meta.h,sha256=BFjtzG-UQKxhvn8HeJw11Jca3JRk1U7-AoA25_6lLms,713 +torch/include/ATen/ops/upsample_nearest1d_backward_meta_dispatch.h,sha256=2m30mCNzkay9ylYCKJEVWGQuO5xm2J6jDGryEQDdfQU,1905 +torch/include/ATen/ops/upsample_nearest1d_backward_native.h,sha256=ZLiqbrO7AD3TtygbaxAO7JCws2F8FT5MQ5J_xlyrgDQ,1088 +torch/include/ATen/ops/upsample_nearest1d_backward_ops.h,sha256=VslE5fDYCtYvo38rTPZ3I4fflgDeWNSJZhUK4cRtgeY,2440 +torch/include/ATen/ops/upsample_nearest1d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=HlSfdxXwNTcpIAxiQ7PTT3mxJX0m7Y981z5XYZ9jMKM,1023 +torch/include/ATen/ops/upsample_nearest1d_compositeimplicitautograd_dispatch.h,sha256=a_iVICgN106IiPH2Wr1f22NWP0YSxzLwCBJR66gNmDg,1030 +torch/include/ATen/ops/upsample_nearest1d_cpu_dispatch.h,sha256=fbXyCGwuzgU40iF0sRao-x5hDKe7-dEijQSdD1N6Bcg,1599 +torch/include/ATen/ops/upsample_nearest1d_cuda_dispatch.h,sha256=5_CQGkjvEgUYjoCKbhEMZykY97fxDcWWN2tEgzFmxLI,1601 +torch/include/ATen/ops/upsample_nearest1d_meta.h,sha256=muHkdayUTUq1ri2npMChfSulIKrVpz1RYRvTqYJQyuM,663 +torch/include/ATen/ops/upsample_nearest1d_meta_dispatch.h,sha256=88ZeMXZ7aD1ubSmtp5o4v4nZyO1YcpTqtP4KbOfaYPo,1601 +torch/include/ATen/ops/upsample_nearest1d_native.h,sha256=MBXLhhVHfQy5-tVcLEpRwstlOZuZdrVCIPeCgMSp4LU,1102 +torch/include/ATen/ops/upsample_nearest1d_ops.h,sha256=wMFiHgzmskWcq0XHwtBbkoQx_UeZ917hIrKATSv1I6E,2965 +torch/include/ATen/ops/upsample_nearest2d.h,sha256=gL8v3nE1oJPEug8gJgPK3SZE05IecWcW7trXRX7u0xs,7150 +torch/include/ATen/ops/upsample_nearest2d_backward.h,sha256=U7_uJf1PfHENZkQZYtNJaiTbBLzbs4hS3RUaggRxen8,7082 +torch/include/ATen/ops/upsample_nearest2d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=leE9qufYWtQdMdSbtxk6m1UCnUzWA7ofa36K8iPSIMo,1209 +torch/include/ATen/ops/upsample_nearest2d_backward_cpu_dispatch.h,sha256=8GPi8moCYpsg2jETrPJ00yRoJnltaF4wnCucqQ_v6cc,2159 +torch/include/ATen/ops/upsample_nearest2d_backward_cuda_dispatch.h,sha256=z2lOVfrUx3gzSFOaRHMVG_mUrlMPzxJXRM4_gdmuh-I,2161 +torch/include/ATen/ops/upsample_nearest2d_backward_meta.h,sha256=CmpiAHZNyAI9ff5jU0hISX2dCIOHEcKt_v2uJBbPje8,747 +torch/include/ATen/ops/upsample_nearest2d_backward_meta_dispatch.h,sha256=t7p5HbwPzji1ivcX5K_Kb1R1h9bRnfBuyKciv3UPuX4,2161 +torch/include/ATen/ops/upsample_nearest2d_backward_native.h,sha256=n9aehZmx0sGLY_RbuVTBkDdqtBuss1fYhgEFzu8ysso,1156 +torch/include/ATen/ops/upsample_nearest2d_backward_ops.h,sha256=pP70uG0S3zXi2R-SbP9oIUzQ7TCKdO-iU0dcELkxiv4,2670 +torch/include/ATen/ops/upsample_nearest2d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=CnDhpUp4l6ExB16z9yR0GOZjyedNAA7s86IF8HffSG4,1117 +torch/include/ATen/ops/upsample_nearest2d_compositeimplicitautograd_dispatch.h,sha256=19PkOH4QForZ-jjiB2P80C4ORloPUfDJwktUmZTtBN4,1030 +torch/include/ATen/ops/upsample_nearest2d_cpu_dispatch.h,sha256=qo-A-i28JpqZnSjZ3eFB9tBZQS3qmMI5zGrOpHyr_ck,1855 +torch/include/ATen/ops/upsample_nearest2d_cuda_dispatch.h,sha256=MlvkOmrfFVhZ87nqDIP93YMC77dTW_n_ScC29vMJbBE,1857 +torch/include/ATen/ops/upsample_nearest2d_meta.h,sha256=oykNrXpu6P0aBMA_yJ5SVTZ4zdLSLP-qtQKyE0pE_8g,697 +torch/include/ATen/ops/upsample_nearest2d_meta_dispatch.h,sha256=IOeFREoVOo025RFyr7fWAL19OKtVddnPNbEQteCFEtM,1857 +torch/include/ATen/ops/upsample_nearest2d_native.h,sha256=Vnhgs1XZrd_cAKtpm5quzQQ72VljaNN6twFItrIac8c,1369 +torch/include/ATen/ops/upsample_nearest2d_ops.h,sha256=ZP3h1mfauImTF3aeXdyQI5paYkwxpUAP5s1iyxTAGiE,3195 +torch/include/ATen/ops/upsample_nearest3d.h,sha256=dJ0Qm1JjrTMiXFOlVzYze21WxvUZA02N-nSOYHg5pxU,7890 +torch/include/ATen/ops/upsample_nearest3d_backward.h,sha256=Fqym5TR92SEE8kllEF-fvSILAr7JSQhkVkahAw7jtNs,7822 +torch/include/ATen/ops/upsample_nearest3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=nCbqT-37xhAMPpmhZHXQgjE3M_rzdwR9CAkIFNou_5Y,1299 +torch/include/ATen/ops/upsample_nearest3d_backward_cpu_dispatch.h,sha256=xrSN5xzoZpzN0dz9BSxfHx4oiB_YLdJvJ4UAu4BmvSQ,2403 +torch/include/ATen/ops/upsample_nearest3d_backward_cuda_dispatch.h,sha256=W_uE-G_Uhm248ljj7wkk3dMVtGmTCClEAtAZNVSKCnU,2405 +torch/include/ATen/ops/upsample_nearest3d_backward_meta.h,sha256=MI_NPM5rpvGkqVM0-XBE0ct1-MfZd55ObmW7heJeBoc,779 +torch/include/ATen/ops/upsample_nearest3d_backward_meta_dispatch.h,sha256=LMweuBrYRceSUOzttG2zyKg9yBHhOXyXw6i53ZrxjZI,2405 +torch/include/ATen/ops/upsample_nearest3d_backward_native.h,sha256=KioMDGLh3USrsJigplhs6EXIdmL8BY6-GY1R-rS4nHQ,1220 +torch/include/ATen/ops/upsample_nearest3d_backward_ops.h,sha256=YcaFDH--Y-pVvJ7H0gUb_wPShA1RsW14UBeiFZqg5Q4,2888 +torch/include/ATen/ops/upsample_nearest3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=3yEXXpcHCFSOzsqQc_78nqd99jSbMhcBrDAUKDSux6c,1207 +torch/include/ATen/ops/upsample_nearest3d_compositeimplicitautograd_dispatch.h,sha256=-Pz-h2lnnfiOf5YRGBRnxHoeXXmc3tz0dp_AOLT9ZMw,1030 +torch/include/ATen/ops/upsample_nearest3d_cpu_dispatch.h,sha256=1yCGzv91EHHcL2kOTWz3_rKvccbOhV7X11SmeJx3FsI,2099 +torch/include/ATen/ops/upsample_nearest3d_cuda_dispatch.h,sha256=9AEbswZUdFnAeFBE2BcxVYT4_RAmztseyDO6wdO7wOg,2101 +torch/include/ATen/ops/upsample_nearest3d_meta.h,sha256=ZCalXidwAXyHTre62UWlhuhtJu7r_d5MHo0QzHBQW6o,729 +torch/include/ATen/ops/upsample_nearest3d_meta_dispatch.h,sha256=FXxzwLKY2fTlggwKhhcUiUwXA3XgbZQO2q1CnyI6PFk,2101 +torch/include/ATen/ops/upsample_nearest3d_native.h,sha256=8grg6mvrtj03Kfw8b0aijo0f0M8o0ihq213hJtScwL8,1478 +torch/include/ATen/ops/upsample_nearest3d_ops.h,sha256=h2OEz2dh6vyXQthub5jr-7P-xK6EL-drmDSD7RWDWYE,3413 +torch/include/ATen/ops/upsample_trilinear3d.h,sha256=VWC0UgQYi63Ci2utl1o6mbDcVapLE_-kW4mDviVUbcs,8692 +torch/include/ATen/ops/upsample_trilinear3d_backward.h,sha256=c450iFA6FBFQpzdoeu2X-NidBzZazNpX836V0eP5QiY,8424 +torch/include/ATen/ops/upsample_trilinear3d_backward_compositeexplicitautogradnonfunctional_dispatch.h,sha256=02QOyOqu6YCzU8pxUtEq5Pp3sNXPeoCOFettyKR5rDk,1343 +torch/include/ATen/ops/upsample_trilinear3d_backward_cpu_dispatch.h,sha256=D1ECtXFbG0cClGveBDJxerDdVpckZa0QE-GKGP7GWTU,2535 +torch/include/ATen/ops/upsample_trilinear3d_backward_cuda_dispatch.h,sha256=gtzZrT2nF3Qd0TsmLDkz_joBxnB1YRvTd3NO5V9ZctM,2537 +torch/include/ATen/ops/upsample_trilinear3d_backward_meta.h,sha256=5luLpvH2JLVe5xLfk-qROpc_1Ye5G16lQQqMLebCk-k,801 +torch/include/ATen/ops/upsample_trilinear3d_backward_meta_dispatch.h,sha256=w5V0FBeoV5SM4TyLmEeN6_C7VXKCJF5trDdLpmz5FQM,2537 +torch/include/ATen/ops/upsample_trilinear3d_backward_native.h,sha256=BCkvFdhTCycS9cABF5r8MJ-gUA0kEUA2ECgqIGogySU,1270 +torch/include/ATen/ops/upsample_trilinear3d_backward_ops.h,sha256=aIfjcerKk2atweE9SN_oNKm7uf74AYpqk-7EWasMYqU,3032 +torch/include/ATen/ops/upsample_trilinear3d_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Fujc3NQo0u8itow2O_93vLczYk5oJNn9hxQ0EPZ3hXU,1251 +torch/include/ATen/ops/upsample_trilinear3d_compositeimplicitautograd_dispatch.h,sha256=AfUc7C3bMFfui6PAQxjTNJn-1XarytwEytnL759r-oo,1074 +torch/include/ATen/ops/upsample_trilinear3d_cpu_dispatch.h,sha256=LXZMZhdKdZh5PgypF2ZB6JrFWGf0CdCyUblVKhnrCq4,2231 +torch/include/ATen/ops/upsample_trilinear3d_cuda_dispatch.h,sha256=3Wfq6uZgA28StQae5YCJHe3UR_naB8gSXDJZQauJ0DU,2233 +torch/include/ATen/ops/upsample_trilinear3d_meta.h,sha256=m3J5mFUYLrOD4GM3pvtcip4Bhy_N-cHhrcsBo5FWV6c,751 +torch/include/ATen/ops/upsample_trilinear3d_meta_dispatch.h,sha256=QpYgWl__8DAMKp1ctf-O59-KybYmPWq17TjPXyU3MMk,2233 +torch/include/ATen/ops/upsample_trilinear3d_native.h,sha256=T_GBJ3vSc8tT1JH1cepy_i3V6kff82Eb4hMlS1Ckqyc,1306 +torch/include/ATen/ops/upsample_trilinear3d_ops.h,sha256=ZDHO4UhFJnXMR2v2BWuiXwyAiO2-zC54S7WyNjGCFkE,3629 +torch/include/ATen/ops/value_selecting_reduction_backward.h,sha256=-FBrH3QTOF2DHjmK7jJzT7qpGCz2Dn1XJFbD3vmmU38,2079 +torch/include/ATen/ops/value_selecting_reduction_backward_compositeimplicitautograd_dispatch.h,sha256=h_iR2Hdmg98W58Uj3b3HlEhI95kZ4s8kNMS4pQoYh8I,1041 +torch/include/ATen/ops/value_selecting_reduction_backward_native.h,sha256=TDp4y6rczs8w5kBsL1sVU22cO1X4sTtiw9O4ilyd35w,604 +torch/include/ATen/ops/value_selecting_reduction_backward_ops.h,sha256=SNGrsqVgNvUQoz2_mwDThgWWArCv5l0sZ-0y6byXoXE,1326 +torch/include/ATen/ops/values.h,sha256=0NJaIUE4zWXU61X08jtanpI6UW8SwC2O1hEQVdL3rD8,491 +torch/include/ATen/ops/values_compositeexplicitautograd_dispatch.h,sha256=wZ0ZxzoPlFmOiTZ36yHmIFaloD1qC_tyx9UrccsHMVs,764 +torch/include/ATen/ops/values_copy.h,sha256=caoVlDdVUVfZbfxoqnO6btkCJhsTuR3zYKOVs44iQz0,1065 +torch/include/ATen/ops/values_copy_compositeexplicitautograd_dispatch.h,sha256=cvPG7K4CH6Ug0zbQbmP947Iybrob5Qvqzqhk1z7cYB0,877 +torch/include/ATen/ops/values_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=OzdOH5gU0sK_qg3oBFTI5y-eNVvxY0oXjmcTDopxckQ,795 +torch/include/ATen/ops/values_copy_native.h,sha256=28eME4D8fKxlUEbSJNaUZQ-UbPjLAa609DJqA89a7pE,575 +torch/include/ATen/ops/values_copy_ops.h,sha256=8OSb5wef5f0U1tYxdbElqI1Wh5zEHIh11qUhZs-TLLA,1620 +torch/include/ATen/ops/values_native.h,sha256=PGfwTyMKi6NfT64k0mfqGM6yerDELdsnOSg3yBH5-gw,682 +torch/include/ATen/ops/values_ops.h,sha256=U5zFwtKHTf3o3nWlGjTD4oEWTEINPz8iN4OSdeBEdjU,973 +torch/include/ATen/ops/vander.h,sha256=CVmZq7W_yFaJNwPpM9U1ka3F7Y5g3OnFafKlPqmHNDk,729 +torch/include/ATen/ops/vander_compositeimplicitautograd_dispatch.h,sha256=QjJ9wwWIRj9Spy0EcKBcLNLOZUWCF-CAD8LaKbQoqws,823 +torch/include/ATen/ops/vander_native.h,sha256=xd1kjc-OizLBkHxUXIyes-XAT0oRsXAv_TdAP_uaSHY,546 +torch/include/ATen/ops/vander_ops.h,sha256=auRt4QN_r_sJP54tX_E_GC9H3FFFHt1U2C3Z5VahU40,1110 +torch/include/ATen/ops/var.h,sha256=N495nxaiHpdQ0e510t_PUHUXAKh-NqDcNo-3ipAEjdM,4835 +torch/include/ATen/ops/var_compositeimplicitautograd_dispatch.h,sha256=WWY7z6M6aLd60KlAJEvHmir8bGXsr128JRRB4OYacgI,2011 +torch/include/ATen/ops/var_cpu_dispatch.h,sha256=V8uov8Z24nb2C1ApoqPN1eS6UokCPJeLFApiloMuBoY,1199 +torch/include/ATen/ops/var_cuda_dispatch.h,sha256=JXPa4Dw6zQYbuDtNQiDBxr2onwyhgpsPRBhgYW3m5FM,1201 +torch/include/ATen/ops/var_mean.h,sha256=PA8mGdbhdW15GIZgMcy52dYVFrSqm3iRfBOTD6QmrdU,3187 +torch/include/ATen/ops/var_mean_compositeexplicitautograd_dispatch.h,sha256=ussN6mR_D7c_7URE48NXRzY5YvuE2QbRWDZfssOiQrQ,1175 +torch/include/ATen/ops/var_mean_compositeimplicitautograd_dispatch.h,sha256=GMYHzjP3ll8JvVfA3LMGa68LUZyozL6kRLNp29lxQG0,1269 +torch/include/ATen/ops/var_mean_cpu_dispatch.h,sha256=zSbOUbmErIvyZEa4a_fq1RRMlhaa7lYSUai71htg8P4,868 +torch/include/ATen/ops/var_mean_cuda_dispatch.h,sha256=5qjl0R9yeXZaoBeY4cuElSU-emWcIFdRYH-B8k8KqtI,870 +torch/include/ATen/ops/var_mean_native.h,sha256=w-oddhfkvsww76kJ8rLIZB-Nt1s-qVtb5X0pi3glshc,1436 +torch/include/ATen/ops/var_mean_ops.h,sha256=0LlNCLmea8RlgnHzyI_jwi0pMFFq1msAGH4FjTiC6Oo,5853 +torch/include/ATen/ops/var_native.h,sha256=-_42muHqbrnHcN7_Uye2ZNOFB7ZgD-PlmwK4DjDKHpg,1637 +torch/include/ATen/ops/var_ops.h,sha256=mlLoqm7d-x6NCKE7b3t89i4azcpMOBeyrerExa4aTOU,7754 +torch/include/ATen/ops/vdot.h,sha256=iqjJsB75EgZRGJH6Gbdzt-cP5VRB5zcM2yISz6PpxcY,1136 +torch/include/ATen/ops/vdot_compositeexplicitautograd_dispatch.h,sha256=ZKCcA9apEkSe06mF5ORCbyv0P6j5S4ENgVwzy7Mmwq8,915 +torch/include/ATen/ops/vdot_cpu_dispatch.h,sha256=tpTH2sLO0-KyP3Ngte3Yy9I0hEdi_7Se6lGJ6rBI3f0,744 +torch/include/ATen/ops/vdot_cuda_dispatch.h,sha256=fuGVsu5H9Fk6zo37k2ikCA95uNMcvMIS2Rtvo25xdoQ,746 +torch/include/ATen/ops/vdot_native.h,sha256=PQ5bCOK764QTlpsbaRM4n0pwjywm2QgczGQddg8DgLg,696 +torch/include/ATen/ops/vdot_ops.h,sha256=FWARoxR-gt9f8y3SJ6ZbBQvhT_0Aygx8zREe01v9yIk,1750 +torch/include/ATen/ops/view.h,sha256=480xgSZ5aJLKFylhcVgAPIP2SRO4_wj-yJNrroMp_-Q,970 +torch/include/ATen/ops/view_as.h,sha256=tKg_taj4QA-2ZUbwR6Pxnt-St2m5YGBKGFItrnmvr34,492 +torch/include/ATen/ops/view_as_complex.h,sha256=ZOv7JGG3zhr82EAp2nqMB41sBPSWchkRLcDZ1VA4sXY,667 +torch/include/ATen/ops/view_as_complex_copy.h,sha256=FOPrOEIX_orkqkbJvPmAXD3DrPph3Z5JFAB4-jRExIU,1155 +torch/include/ATen/ops/view_as_complex_copy_compositeexplicitautograd_dispatch.h,sha256=wFiEAFvEymVv5H_kfmHPg_6N0z_3xANyBVMVNs2e0CQ,895 +torch/include/ATen/ops/view_as_complex_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=_m9Kh4YzfcJAioObWETYd7o-s91GBL-CDkm8sOLmKfE,804 +torch/include/ATen/ops/view_as_complex_copy_native.h,sha256=IftZtmNF3pm9iDqbwQSoje1ytsEDpAHpN0SbhZ_ZuZg,593 +torch/include/ATen/ops/view_as_complex_copy_ops.h,sha256=XH0GcpTr9laktL60-LnRBSBxI5ib3c6zFnlTlM2afck,1674 +torch/include/ATen/ops/view_as_complex_cpu_dispatch.h,sha256=NtJGQ60SXJxFx61GVRv4faG_4N-WyTrPfgR_TOP5fzE,729 +torch/include/ATen/ops/view_as_complex_cuda_dispatch.h,sha256=ev_1isqi35w5x5Ukf6x4YpMWJ0-YFslSiUenneor1Lw,731 +torch/include/ATen/ops/view_as_complex_meta_dispatch.h,sha256=6Y1J87LXDtZeqPkLWcGl_zcFhQ1sr9Tl0k1j_UUjwpE,731 +torch/include/ATen/ops/view_as_complex_native.h,sha256=xMWJA4zDlym-nBxOY8OdKhvEKid0qFseDsVG04TQBiQ,496 +torch/include/ATen/ops/view_as_complex_ops.h,sha256=r6KqNYnGlFsuTaa5AJEGy_XwctitKbrEjTAtSesVSmE,1000 +torch/include/ATen/ops/view_as_compositeimplicitautograd_dispatch.h,sha256=LrQARFU__8RnqvMfrRF-JJSc_WK039Ki2U261eDyFR0,791 +torch/include/ATen/ops/view_as_native.h,sha256=oBE6Ywjr1kPq5gMtTNMx9yDHxk2ZwO9OkaGZ8Mar7R0,514 +torch/include/ATen/ops/view_as_ops.h,sha256=IGFYQdbQJwlplybTosbWpgz5wxPhfhic-XmA_Ra-R3I,1062 +torch/include/ATen/ops/view_as_real.h,sha256=nwLEnHoQAOI9FLiJghn4R_M1QtBMQDxB54p-ZEeD5ek,655 +torch/include/ATen/ops/view_as_real_copy.h,sha256=okVXPMm-0YC2gGTqtPaM9pd8asE0aIUoDXQUi3cUkOo,1125 +torch/include/ATen/ops/view_as_real_copy_compositeexplicitautograd_dispatch.h,sha256=LUR2CsUwZd32YCTbRwoM-6X2M0hLlqSvF7Vbcquib9Q,889 +torch/include/ATen/ops/view_as_real_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=RmDY93B4glkGQ61neiw9Q9Nki7gmthSlTxzVTDdb0HQ,801 +torch/include/ATen/ops/view_as_real_copy_native.h,sha256=cmPQJyw0XxEEC2mnOH0fQGCqX0EmR7Ogyl0cabCMLcU,587 +torch/include/ATen/ops/view_as_real_copy_ops.h,sha256=JrracnourxRUCwgy36bENAwb27NJTKCQ7zJbPcxisNA,1656 +torch/include/ATen/ops/view_as_real_cpu_dispatch.h,sha256=Dql2XNSBOkJ4zVPAVB5WduYxEWIZU4edsVuXRNFRqx8,726 +torch/include/ATen/ops/view_as_real_cuda_dispatch.h,sha256=VPtRv93nAOjecTei4HbGhXQ2UY9jG_018FH0Cwj92-I,728 +torch/include/ATen/ops/view_as_real_meta_dispatch.h,sha256=JoEI_BGzdoNeHnKzGTjl2AsrjAlmDI_kP3YFNGINKgc,728 +torch/include/ATen/ops/view_as_real_native.h,sha256=BN0H9vVumod2DdycyNCIt5JGbUMhZ8Vlmxo_z5KxTD0,493 +torch/include/ATen/ops/view_as_real_ops.h,sha256=BHFyNqooHckpQJivtAdvqpn5JbjpakxoGBaYjGDQo6k,991 +torch/include/ATen/ops/view_compositeexplicitautograd_dispatch.h,sha256=Cpp23JscpJ7BQ2Vc8z46TsDx21aK0HVtrwbzM_FQ-xc,784 +torch/include/ATen/ops/view_copy.h,sha256=nmqqLEhq-SP-eiN9D59xafSo_CZ-ZPK5rbYQQm57iVo,4331 +torch/include/ATen/ops/view_copy_compositeexplicitautograd_dispatch.h,sha256=6CRxBiPOyx_-nd4Ou6BZy3XKqtigTqAb9yBYBOTzg6k,1353 +torch/include/ATen/ops/view_copy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=Ym30vRhIo5vs_6E8hkcAEgstMdKTE1N_Zsyzl44hY-w,984 +torch/include/ATen/ops/view_copy_native.h,sha256=qRNXtqAbYPp67ZVg2A9utPWPsStGF-_Ato49Ugtxu0o,831 +torch/include/ATen/ops/view_copy_ops.h,sha256=Yn-W028rOd8gjl_91xRo5ShqFzlWW4albgbf6sRAbS4,3149 +torch/include/ATen/ops/view_cpu_dispatch.h,sha256=zBKOO38ZDoGx8Oy7Lolpl5pQUJwI56GbjUv1Cef0ppE,825 +torch/include/ATen/ops/view_cuda_dispatch.h,sha256=9ryNyKP12NGA6cRxJ5yIq0n337Xhhr6R-PsvgZh-_Qw,827 +torch/include/ATen/ops/view_meta_dispatch.h,sha256=57oTuaCVEuzW_Nl4WQsIqFsm2TCKCmZVDgkhyh9JcYc,827 +torch/include/ATen/ops/view_native.h,sha256=O2EDSAhANoW19xqwWn9-oe0qQhs-8ss4OosjiPbcAi4,749 +torch/include/ATen/ops/view_ops.h,sha256=TxHgxUp81s03TGJqH_0dLQ522ZnX3gCj0j5CK8FXoBE,1683 +torch/include/ATen/ops/vsplit.h,sha256=4EVm8F9CfuV_lPEdt6wW0sm52kF4BEuOQT3_wJXwfAg,927 +torch/include/ATen/ops/vsplit_compositeimplicitautograd_dispatch.h,sha256=pvbVUDBJs2GmMP05mUqLH55iA3PmkkO5Sf14iDAOiw4,891 +torch/include/ATen/ops/vsplit_native.h,sha256=UjaxjJG3xfDz-qo9G8AKhmz0aqbQsltIlAEcD1IfL7w,614 +torch/include/ATen/ops/vsplit_ops.h,sha256=2ovJ3WrnRm4tPROybiNxboFKk2rV_bNixjbCqQDkxvI,1785 +torch/include/ATen/ops/vstack.h,sha256=1fLosaw4XXd7otGrofatzXSe5UdDdMzOSF3_87_BsyU,1036 +torch/include/ATen/ops/vstack_compositeimplicitautograd_dispatch.h,sha256=v0mm6a8MrJYi8e0ULYKziiEdQUdv2P7kvmgo6cFoNaI,918 +torch/include/ATen/ops/vstack_native.h,sha256=eDxdB0xyzhPtHo1umQRJiXQFE6TZVHMI7oggLBa2SxA,563 +torch/include/ATen/ops/vstack_ops.h,sha256=xnK4IFZ61C4cOkWSknncTuWd9z0XQE95_Y8_8QCVPBE,1588 +torch/include/ATen/ops/where.h,sha256=YFTbDdC_QFCBF9ggdDLI3RTFs9otq8fKIq3eyjCDrMQ,2291 +torch/include/ATen/ops/where_compositeimplicitautograd_dispatch.h,sha256=9c2jv_00MuqzYigsZrwDot2RsBmy_YKMVBIBCF_8OJU,1110 +torch/include/ATen/ops/where_cpu_dispatch.h,sha256=UyT7I7dXC067B8Qihp-mnUviKnIOIGmkN8HxLhkqtOQ,1042 +torch/include/ATen/ops/where_cuda_dispatch.h,sha256=3VoIl5JyvqVZAbuhq2D5dUGQ6287K2I5DHblvSByHqc,1044 +torch/include/ATen/ops/where_native.h,sha256=iJ-wUcWz7DDaHquhUZSLKJGV82CKlTqCJp0mSHfENqw,1080 +torch/include/ATen/ops/where_ops.h,sha256=rz0uU3wCfROL-Qs24dm4JtI4ue__5usEFr0NO2bj5_M,4802 +torch/include/ATen/ops/xlogy.h,sha256=PHT66Ug1HB_glWJcFSqNmdPlCpHeZ4iu2auiuLTS5fc,3052 +torch/include/ATen/ops/xlogy_compositeexplicitautograd_dispatch.h,sha256=aCndbKpFqyvidjXsftZOaQtqbVasfDgvH4TfNRNbqEA,1358 +torch/include/ATen/ops/xlogy_compositeexplicitautogradnonfunctional_dispatch.h,sha256=9469MOB2sbfC6ZX6-98d0VKBKAHUBeIijBe2x3X2YrA,891 +torch/include/ATen/ops/xlogy_cpu_dispatch.h,sha256=a_4jjJPvRKe8W58ffFF6X9jcc4Izlg3RiYDs6w9Kf_E,1028 +torch/include/ATen/ops/xlogy_cuda_dispatch.h,sha256=it3-VIwe08mGOYunpBmQqrR7u_WQDSdYsTKCXAz6NGY,1030 +torch/include/ATen/ops/xlogy_meta.h,sha256=CV63DfqS46SWVOJBpUX_x8kA3J5yevjQ3r36GBdVz88,618 +torch/include/ATen/ops/xlogy_meta_dispatch.h,sha256=1k5c4CPLwmdU2dMFGWZYNQf7JqHMG8L-Sp0OLZ6aTRE,1030 +torch/include/ATen/ops/xlogy_native.h,sha256=iorhhDyX76piDm-qPUmAh1c3Px4Ky_SEuyV7iWmjlZQ,1077 +torch/include/ATen/ops/xlogy_ops.h,sha256=fEtPUvfxnhSh9hWF6O58qtcX_eOjvMAuBDxOyHUrtvw,5868 +torch/include/ATen/ops/xor.h,sha256=shulnJnmGsK-G1RCdp1XeX193tstlTpKWUd_LKP0I8E,885 +torch/include/ATen/ops/xor_compositeimplicitautograd_dispatch.h,sha256=llZtzjLJvEQQuCrgVU0mvjT_ZGe8lEWekI2dEwYorgY,1028 +torch/include/ATen/ops/xor_native.h,sha256=m7ZuqQBFicUSxCCC0LPfEyaVhDgbcdSLH9ZT0IflfgU,751 +torch/include/ATen/ops/xor_ops.h,sha256=S3yBeGnvLlVRvcHTeM5xLAEQduRjaPaK4-lH65JYg1s,3000 +torch/include/ATen/ops/zero.h,sha256=eVHi-Q1b_83J0YQTXRABN-J3hD-8vp1MuXrYKvAVK-w,1131 +torch/include/ATen/ops/zero_compositeexplicitautograd_dispatch.h,sha256=akQ1gLLIEeRjNWM6221-5HpQsE-FtekFlEkXLuNsMus,915 +torch/include/ATen/ops/zero_cpu_dispatch.h,sha256=ZrrM_UT_lg_XCh850CD4-HzzJ4joXroYO0MabtRXyuc,715 +torch/include/ATen/ops/zero_cuda_dispatch.h,sha256=s35FQV1MR_XSkax4X3GYTc6b7gKF4zRX_RXJCmloDcw,717 +torch/include/ATen/ops/zero_meta_dispatch.h,sha256=-QLfASKw9qhs_Yo9z5PlsI_3UwxT8qf6VS1JEWJelA0,717 +torch/include/ATen/ops/zero_native.h,sha256=dUFcqlv8d9MWOZ15jyE7lK1pys5kOJy3A--79uD-w6Q,892 +torch/include/ATen/ops/zero_ops.h,sha256=-N_u-_aA5E2xKMDB8AqNJsk5jxzhVzjTef6jYClYy-g,2104 +torch/include/ATen/ops/zeros.h,sha256=PmjPwltCv6FmvzoWW7ZGLGSaCE0jZenbA7lXTn2wPTc,6862 +torch/include/ATen/ops/zeros_compositeexplicitautograd_dispatch.h,sha256=ce-_T5dwq_TJIA7LfnRr5AyoEPApsuwvh9kEhmWoJhc,2154 +torch/include/ATen/ops/zeros_like.h,sha256=DnzwksYeyY7Lv6RSA_nOhKFkXht9H0uQMvtxtdUxyK4,2189 +torch/include/ATen/ops/zeros_like_compositeexplicitautograd_dispatch.h,sha256=rzhDz5eJdXTvO0JeVc8dnBHiyDxG0fU-kEBR03vr-xk,1372 +torch/include/ATen/ops/zeros_like_compositeimplicitautogradnestedtensor_dispatch.h,sha256=RYelRXQ44vk9OCRVf1vDw-eJcmcVcG5VoEeRw06cB4w,1124 +torch/include/ATen/ops/zeros_like_native.h,sha256=AacHhs4JMCyT_xk8lSQqJ-2qT8kwTYogsqBshUY2fYk,829 +torch/include/ATen/ops/zeros_like_ops.h,sha256=uvX6TJPjQpj3no8RaJOb4-0xAnjscBzN4FKml83XYn0,2408 +torch/include/ATen/ops/zeros_native.h,sha256=MD06oICFHDeallX9Kh39ZyHiG_dLctl_-CiQ7Wx8RBo,1153 +torch/include/ATen/ops/zeros_ops.h,sha256=3rImnDKafclHOGXr2kUqCU4aOWuK9Yy1cz5E7mjwsBw,3955 +torch/include/ATen/quantized/QTensorImpl.h,sha256=O-XcKul65B9Ql8eeA4gXlJvz4IStdMkqTNzfefTReRU,4009 +torch/include/ATen/quantized/Quantizer.h,sha256=X6j4TQoXgD0l-o5rrLNOz7ilIjXleXf7sY_HazqgToA,9232 +torch/include/ATen/record_function.h,sha256=kaQ9tJjxDhKmMybXaUSW6hOIc9DLJO8ghpbqkmVNhjk,22407 +torch/include/ATen/xpu/XPUContext.h,sha256=Eor_d5xBekYy1nwWkNa4MSo2aX6KY3QbODtvBONnAi4,458 +torch/include/ATen/xpu/XPUDevice.h,sha256=nosB3k5z5s6_y6MsUf7MkYmonuixvYGjWCACp-_sBp0,267 +torch/include/ATen/xpu/XPUEvent.h,sha256=nZkAUbFpTFJMQ-XqIWkCoehnLVE9xfCw4N3utK94sUU,3621 +torch/include/ATen/xpu/XPUGeneratorImpl.h,sha256=HIScLAeT6Ii4Qe96Dpyork3rBf5K3g4-wqY-7yzoBts,1228 +torch/include/ATen/xpu/detail/XPUHooks.h,sha256=w0EySfCwUbZ0DAK3WzlcO4FI1eLkGTWxn4mOsMblGzo,821 +torch/include/THC/THCAtomics.cuh,sha256=sbRzB6GvRcYIN-1cCMaM0h-ig8M5tmqMmy-NfmojNfs,118 +torch/include/THC/THCDeviceUtils.cuh,sha256=hkOQh_VmHYP8Ir9HM5Q7oenfTLrTFygGFkGcnmcP06E,78 +torch/include/c10/core/Allocator.h,sha256=gzh4xw8V4ejIGNVpEgQC94nQtz4Y1FnRXdA4fF1u5IQ,10639 +torch/include/c10/core/AutogradState.h,sha256=COFnIXarRjxRmCxtEt3TVfdUQ1ETXydGBE233RhEme4,1591 +torch/include/c10/core/Backend.h,sha256=YXSImZsdAb3FXcl9YyC-gxROHWT742AlQdH-DnvWx3A,11354 +torch/include/c10/core/CPUAllocator.h,sha256=cUwX4Tp5hC1S62FypLhVGkisfbjQ-Wm27OjzNd2j2cc,1688 +torch/include/c10/core/CompileTimeFunctionPointer.h,sha256=LE2HvZBcsZ_tRb-u43n7b5hnB9a4MUboRv5pJKCKmp8,1700 +torch/include/c10/core/ConstantSymNodeImpl.h,sha256=XFFWGCnA88wZKyi-3BVKSD3fXE41NXap6ckOLyV82XA,2860 +torch/include/c10/core/Contiguity.h,sha256=u-fZj8LBSecUWgDKcfVFQDT82Ww5uO7wd2kUpxiEwaI,3392 +torch/include/c10/core/CopyBytes.h,sha256=7W421Idnt23V7RkFT3AhQBS_F2JW2L9zQoERVg1IdCg,1343 +torch/include/c10/core/DefaultDtype.h,sha256=jA8dnRLdn4aC4enYeb1YiOXuQCzgQtQHFfHegFsmWtM,394 +torch/include/c10/core/DefaultTensorOptions.h,sha256=0u2cbxT6TMZBHA5_LOt6TJS1vEutjAFn8axX_MxzJfE,1064 +torch/include/c10/core/Device.h,sha256=z77_V-qUDbjCTjQC9qC6n6Hce8DXMkaBkitWNhToF6c,6892 +torch/include/c10/core/DeviceArray.h,sha256=H5OYVEtpnhGx6tN6BPJIG2RYV_HZAWWaDBdYDjWY-pE,688 +torch/include/c10/core/DeviceGuard.h,sha256=helLjHo8AjNeiL6zx319N719DIy6TkrRovNobmhsjrY,7710 +torch/include/c10/core/DeviceType.h,sha256=pzQqmMU93eIUJy9GMCCy3t6dMo9mjfSKSSXomsAWtKY,4473 +torch/include/c10/core/DispatchKey.h,sha256=oxrKKXg8LfT3UU1KjHqMHed3UWFaoBZnedryLkT_gMw,32645 +torch/include/c10/core/DispatchKeySet.h,sha256=fgiBJhBLconZTOm1FeQUqWcdf8_LwpIRyx3lMj5Fllg,40577 +torch/include/c10/core/DynamicCast.h,sha256=P6wetNebedxi0d99udXrB-Cc2l8drZocIqfzVoj4lbU,4444 +torch/include/c10/core/Event.h,sha256=6OOa01JrTHv45G9Qmn4lhCxHQab_yYslJoUjLtp9jL8,4241 +torch/include/c10/core/GeneratorImpl.h,sha256=er6N8YNGt8ODMAOzDh1lhCSpEkqUzaDkK-1NVBIUeS8,3699 +torch/include/c10/core/GradMode.h,sha256=ojF7GFosLf9vySFUZqxMDP6r_iTIsSqx9Uu4Q5F_eqE,1253 +torch/include/c10/core/InferenceMode.h,sha256=x-F5kPhDJKZJw655mQSq2NYNNkjd0hgM7xyoaScMGks,3558 +torch/include/c10/core/Layout.h,sha256=ie5VbhR1SRHHegWXT-MxF4NGPwUeR7DZzunITlzLHfA,1943 +torch/include/c10/core/MemoryFormat.h,sha256=wsPYbHemnh_26P1-Yb-F_S4yIYT6kZL5q4mU06ocdJQ,9401 +torch/include/c10/core/OptionalRef.h,sha256=hWjNEDGGMt_kVVqsGhriRs1930q0J1b1fxbM3A8QK1g,521 +torch/include/c10/core/PyHandleCache.h,sha256=7Gb6mh98hla7kZlRVEE8jeVu_IRQsdfxx53cDzri64I,3101 +torch/include/c10/core/QEngine.h,sha256=-UoIngTGcXUXv2oe3LE5M0_n6WvrMj2dyeV1L0Okx6Y,1010 +torch/include/c10/core/QScheme.h,sha256=vcqI4auVfkZh-LwdTjdJmjUz_3T3jmdsiL2qyp_T68I,1566 +torch/include/c10/core/RefcountedDeleter.h,sha256=m9j4JCJeLF4GznXQRrf5Bpv8QDRsQmwmUgGiQYkF4m4,2223 +torch/include/c10/core/SafePyObject.h,sha256=Id3CTojvBlfckrCxx4ylk_aMcBQAFM-QiVxnuRSUQBk,2521 +torch/include/c10/core/Scalar.h,sha256=i5iuBxVNQZIXiIba18KTnYNBLM2AJFexG_p9ukNWNk4,13909 +torch/include/c10/core/ScalarType.h,sha256=5N2qSH8OV_T9pL6apt9vDizri0CFJkWQz6sKNJV_6Gk,26587 +torch/include/c10/core/ScalarTypeToTypeMeta.h,sha256=0k472L8chpKjZCZGC0iVzPVGyfDYoCKwsrsqU0F_DsU,1396 +torch/include/c10/core/Storage.h,sha256=g9w0BHtZDCNkE_97nDUy3nK50EXlnJhV2yoecqqvE8s,7059 +torch/include/c10/core/StorageImpl.h,sha256=6jDHrRiJDMNRHsYmqkSrOjWmZY1VFQ8iqMepti_ZSOc,8197 +torch/include/c10/core/Stream.h,sha256=ZsQOPW7woZ7o0Ea03DNnsjdID5-gTxaTOd6JAaDmSMY,6365 +torch/include/c10/core/StreamGuard.h,sha256=RVzYlSrMeHQW7lA5a5XO9BVME_yUO4X5474onYtyDbg,6478 +torch/include/c10/core/SymBool.h,sha256=uG8Yvj8UBdWeeaLCg7B18cbbGlfKfL1wUPqWCWs0GNU,2697 +torch/include/c10/core/SymFloat.h,sha256=a-_NL3pXDBgE3j1ZhDRc-vzDpABrUeaSxIdhcABi0vQ,3263 +torch/include/c10/core/SymInt.h,sha256=cV0BRyqNsIfULzf9XUDN8n5vepVlaxxrvcP6C5VsGIY,13901 +torch/include/c10/core/SymIntArrayRef.h,sha256=N2uYv76FGo21MELDGWq6nIwm2hAaW5-9_7LvVRuaBLI,2156 +torch/include/c10/core/SymNodeImpl.h,sha256=ex3RbOnIGceoc2dODZVQLoW_2U1ZhYmIPz_Vl6dZcks,5929 +torch/include/c10/core/SymbolicShapeMeta.h,sha256=k7t90mRjU8BS1NmVgYgePOLJaDTVKkL2ftMZIOUfrYc,7115 +torch/include/c10/core/TensorImpl.h,sha256=C1plz2oyHQ8BDJO5jexcN-rMCHxEFzmpxt5bhhqJe0A,114273 +torch/include/c10/core/TensorOptions.h,sha256=MKXVfA59MnJ6H_f9ZiS7OD9DaQv-NP8t7t53VPF-sbQ,27106 +torch/include/c10/core/UndefinedTensorImpl.h,sha256=grnF4Gr5ujAUR3Nv8jXO_GnSAut0k6TzM9dPxs1Jfr4,1117 +torch/include/c10/core/WrapDimMinimal.h,sha256=BZRtJfULHp6Dw2HlblnxQQ0xVfdwwxzaMKWqtbE7GnU,1360 +torch/include/c10/core/alignment.h,sha256=388Kxrz59CbzQ8Noj8oum3glnTyrbsyEvG8JGuXeDPU,564 +torch/include/c10/core/impl/COW.h,sha256=lFSX9LfHijJA-UYKSjUuqfO7Ve5-VDEKOZ59ysCeqK4,1057 +torch/include/c10/core/impl/COWDeleter.h,sha256=xZ1odJVNmSNpMoPs5yAFPus1ajeZ1MBcvITs6Aw9w-0,2098 +torch/include/c10/core/impl/DeviceGuardImplInterface.h,sha256=up4oy-nZpyOl1CT2oNUwwhD7bv_eoDPH7hDDY9tKuWk,12584 +torch/include/c10/core/impl/FakeGuardImpl.h,sha256=GjV0OUGkF7o9CEszwkWGul2de6TQslAi8HEwHxWCwUY,3135 +torch/include/c10/core/impl/GPUTrace.h,sha256=NaGndfpzJjUYMSUkP30h08bUuRZioQBuymQL3SjpZjk,864 +torch/include/c10/core/impl/HermeticPyObjectTLS.h,sha256=BpG-7Cj-VNe1T7_VnnLycw5bdm8rzgluqZzozZcpCgo,2446 +torch/include/c10/core/impl/InlineDeviceGuard.h,sha256=4DYmtU9xObwuDu-l46r0-HP6U6bWbvyPi6n5JT3hlUs,15649 +torch/include/c10/core/impl/InlineEvent.h,sha256=FuN8y-uSy07rkaQ3EizWdLcBUljRcy4-BDGsjUny7Jw,3105 +torch/include/c10/core/impl/InlineStreamGuard.h,sha256=cuwgaV5zvKG4-voxAC5lmyh02qEqaNMgXmZb9qU7t6g,9645 +torch/include/c10/core/impl/LocalDispatchKeySet.h,sha256=9DV1BNQ5GKPOcTGkjXD86LWzR3WIip01JTsEZXaMwQU,6225 +torch/include/c10/core/impl/PyInterpreter.h,sha256=jwqOVOhKHfI--i1XJF20sCzSdPz8zoe5Wtgli-O15Is,10726 +torch/include/c10/core/impl/PyObjectSlot.h,sha256=i-b9MQMwruhXoF-2JZ8T3BoADygAN4l192zedEUBWxs,8198 +torch/include/c10/core/impl/PythonDispatcherTLS.h,sha256=cEJvBpS47_ItVaRwOFG5Nz7jD4V2eB6wwZEM6d9sfbI,549 +torch/include/c10/core/impl/SizesAndStrides.h,sha256=R57cyvNQQqFbuWK-vWrXseBIa5M1sck5saOgGf60sLk,8378 +torch/include/c10/core/impl/TorchDispatchModeTLS.h,sha256=gvwug3UgCMmg-N3OLh3eOJbYQ3dYcJJsm_2Wc_2u35Q,2084 +torch/include/c10/core/impl/VirtualGuardImpl.h,sha256=Gp4aHeMlHHrupK7BcnL2MGTtit6wgxvloWVa80YTRXg,2760 +torch/include/c10/core/impl/alloc_cpu.h,sha256=r726N5hIEezpRC-cdGuSJJ7FD1wtLvhKvVS8JoQns1A,178 +torch/include/c10/core/thread_pool.h,sha256=HU9cBi8jQVypSFnbrFaT4fhGeuCx-rE57mqsxDjjDao,2997 +torch/include/c10/cuda/CUDAAlgorithm.h,sha256=_osQlsXB3DJO07B4TJLXnMyjkHip-DJNSxvZCmF8EjE,1041 +torch/include/c10/cuda/CUDAAllocatorConfig.h,sha256=VYz1MkA1wAd5_UyF_jHa-VTP8fcWqAW2WkUmMJmoAXc,3833 +torch/include/c10/cuda/CUDACachingAllocator.h,sha256=dXMqR0uZtNof-vOBjlC7TBJSeuSY-Rw4geR7TMLYuoA,15539 +torch/include/c10/cuda/CUDADeviceAssertion.h,sha256=QmHUlOlnY6gfQchorxedjp8XFzO27tgksxwtow9Y4-8,4071 +torch/include/c10/cuda/CUDADeviceAssertionHost.h,sha256=5OF5BNqxcu5wk49Trs3fSsE_BoUwInXfF0xisAq5qL0,6617 +torch/include/c10/cuda/CUDAException.h,sha256=8XF-UL75Mw_JrCNvDlRdgaiARcWyktn5nRFL_ueFH9E,4552 +torch/include/c10/cuda/CUDAFunctions.h,sha256=FY7g6zCoWHWHHkeRPtg08ii_RecgfyiKHqyTC4oG8kc,3887 +torch/include/c10/cuda/CUDAGraphsC10Utils.h,sha256=I2-ZHeT5Gs1AL9eLuPgmBhHgOldQX_qF554MmPnekcs,3005 +torch/include/c10/cuda/CUDAGuard.h,sha256=BMe1eJT3BMqgO5-xGBVvu_KhbWRj-sfddoSDYpk2dao,11187 +torch/include/c10/cuda/CUDAMacros.h,sha256=XGYaw_5z8tkveMtcSCXBKNMEtJ34j16LKiMVDv9Qr0k,1479 +torch/include/c10/cuda/CUDAMathCompat.h,sha256=s-yo1Ccyiz_rFvSnLK-R2pkmCVF4-EZuKaowvAac-X4,3553 +torch/include/c10/cuda/CUDAMiscFunctions.h,sha256=VYjGElQ6pE-FHwGjhLaf0KOQKpapciFPXmW5mt_xTWo,306 +torch/include/c10/cuda/CUDAStream.h,sha256=bC7wKIz7eYuMExKMzoJ4wNW_CXFUq-D3d_qtyXCUgGc,9667 +torch/include/c10/cuda/driver_api.h,sha256=qkKUNsIJq23urCd2m-iJcszF0iGW_qWK5X4S8UXGJwA,1956 +torch/include/c10/cuda/impl/CUDAGuardImpl.h,sha256=ViXd6G5dNCj5bdWIphFV8ok2UF08U3pKRI2WfnFq8VA,6966 +torch/include/c10/cuda/impl/CUDATest.h,sha256=pmj2IDoGqxUBvCohXPrEkoKZn4ZEwgUDXAcN27a5bNg,114 +torch/include/c10/cuda/impl/cuda_cmake_macros.h,sha256=5SZTOQCUZPH9z5lM3IUfEXcEt6BdeTLUt-TeEEX0PPU,194 +torch/include/c10/macros/Export.h,sha256=hitlLtM1vpAv9sxrl9XoXFDrWEBoWP-ymiHT0rzGmKw,5802 +torch/include/c10/macros/Macros.h,sha256=Py1c5SvXFYrcoNJ-peeEi8FyYmuBnQrQK1DNZBZ-VQk,19534 +torch/include/c10/macros/cmake_macros.h,sha256=VHySeoBhgBgNh01VyiCoWmoW8nTLITV7m5G7MyYW4dU,437 +torch/include/c10/util/AbortHandler.h,sha256=tbM4KWBdYwbCq1ArehgWpkZwweDKNvG0aoKJb-dDVbU,2090 +torch/include/c10/util/AlignOf.h,sha256=P8ZzdW8CGo583mnAw7NsgcnRAHREfBUEzVgzvofGB7Y,4906 +torch/include/c10/util/ApproximateClock.h,sha256=Tsl6PkjeqJ9K4Ice8WL5A1pYmEw1Dm9RawHGDC0278M,3483 +torch/include/c10/util/Array.h,sha256=iLMPjb7aVKpDsEQ-1E9Ry0MptXBQ80NQFW7sJva8ssE,436 +torch/include/c10/util/ArrayRef.h,sha256=_f2FTn95AkHFkwZKpEW4YfI8KSDexSK-hmwlqIgWWWI,10876 +torch/include/c10/util/BFloat16-inl.h,sha256=_26TxFZP11VYfd4o7TxDFFZRqNPQHfGFZaAiMQVh5Y8,10329 +torch/include/c10/util/BFloat16-math.h,sha256=gD36d7HDbm-8JIcR_ctT3boIuPvPRL5_-oq2WQTlDho,7985 +torch/include/c10/util/BFloat16.h,sha256=7uZHSoeFNrFQJbkm036JdFcHkzndHD0-Rv6nTxzxxFU,2882 +torch/include/c10/util/Backtrace.h,sha256=sbWyABFklbXFHnKCXJd9qTDJwZlw0RaJWCimSGxh4Uo,364 +torch/include/c10/util/Bitset.h,sha256=4tgpGr0oTix8UiTPhem2njwOrzhJRECCb0bO_DLcDTg,3339 +torch/include/c10/util/C++17.h,sha256=xeGTKydSHlgF1kKK0LQeEgkTVky-p-_WsZ43ky7H_08,4806 +torch/include/c10/util/CallOnce.h,sha256=bi_enFQ_NBH6PFeBbQAHVTLcwHZZfQGIA5biLlwxBBA,1941 +torch/include/c10/util/ConstexprCrc.h,sha256=3X4JO7ClQRAEmuwuWFjk2WyEJq2XbG4uMOgsEIwU5Xk,6638 +torch/include/c10/util/DeadlockDetection.h,sha256=lqJDsGUL7U-lDSXJNTX45EskIG-dwOl0ZQEZXVzbhNc,1925 +torch/include/c10/util/Deprecated.h,sha256=tyNcwEnjhdHs3LbgKssdAQqInoDJXNhgcSg1z2sj3nc,3579 +torch/include/c10/util/DimVector.h,sha256=kQxjIMzErk6BLDVVpLVCrzimZaZr-WG8pBjDePV6Njs,444 +torch/include/c10/util/Exception.h,sha256=GZ7eN1uMYXFoXnTDp-5vJN873gDP_UF4tyK6Kgu1xjI,27239 +torch/include/c10/util/ExclusivelyOwned.h,sha256=qwRVoJSLwNgKSoGTTRUfaF7PA7l8TGwJSCM9qg3I2a0,4453 +torch/include/c10/util/ExclusivelyOwnedTensorTraits.h,sha256=ik-PJqouBR29T6XDuf0QGhthRXQ69xpg81fuU3-8h4Y,2194 +torch/include/c10/util/FbcodeMaps.h,sha256=8vAkfHp4na6an2L9cXNB45k1POA9sLEkv5QZDcC3eHY,728 +torch/include/c10/util/Flags.h,sha256=3IIt2P8VEqadqcYmHpGNHdGz3mTe9UeciwBkdvZQFXA,10054 +torch/include/c10/util/Float8_e4m3fn-inl.h,sha256=VN1W6kCeSNxYXdvXLC6LovI7hQ1Ct6MmPOoYXt0KAaY,8566 +torch/include/c10/util/Float8_e4m3fn.h,sha256=-3NMGHE9GPSaxvRLCwjr-Wk-HpzcnXTxIoD0DlCIgSA,8328 +torch/include/c10/util/Float8_e4m3fnuz-inl.h,sha256=cttH-JCo5d0lwcZw36F2JORYNf1mjnKUzma5t1Vgp84,8996 +torch/include/c10/util/Float8_e4m3fnuz.h,sha256=1rWIIGU2g9sXy-XyjtNgmQM1Ty5vsLJb-oIGuvFys5M,3803 +torch/include/c10/util/Float8_e5m2-inl.h,sha256=-1wvPwDoSMCo8bYdiWpclOL8zGHNzf6MDgst0Orprks,8533 +torch/include/c10/util/Float8_e5m2.h,sha256=BUYmQrHBbURAzpBfhkFzPAk8zsESNMvWMBp7tYgxU04,4268 +torch/include/c10/util/Float8_e5m2fnuz-inl.h,sha256=VJABzsinCCfj9_ktliP6WLgwTqzFm4tv9oP86q9NV-U,8959 +torch/include/c10/util/Float8_e5m2fnuz.h,sha256=Y4rodI3Ui0CbHup2s3DXz7gEvwtsZoaV6ov_605Z3hw,3824 +torch/include/c10/util/Float8_fnuz_cvt.h,sha256=Y895tw0kRbqFDImmsycv3pFSiAMBoI2ddlUTWuxbOsw,1579 +torch/include/c10/util/FunctionRef.h,sha256=L2sIQ56zatHFPgwVDlVM0cA-KzBI4M6-Tv3M8G5WHSM,2296 +torch/include/c10/util/Half-inl.h,sha256=H2q79bNyvRF5Rcm483SOL2VRgzqLEHhyeiPEade6G-E,10223 +torch/include/c10/util/Half.h,sha256=lw3aJQR0lv-93I3IQMfTEGhdfC0wo3dxqYkK582nA88,20356 +torch/include/c10/util/IdWrapper.h,sha256=uYBOWQaBbtb9DDcerY46K4BfnM1bT3LLnIM6rae4iI8,2336 +torch/include/c10/util/LeftRight.h,sha256=qz8I2fjmp88vBb6qxq8zzOds57jutVAAle1MtY3G5qw,7072 +torch/include/c10/util/Load.h,sha256=onxMgIHtTe1Q8bbmT8tx7miGGdpBjTG9o8B-WF7s38w,904 +torch/include/c10/util/Logging.h,sha256=rLoGpRsiK8FG8VjDC_sIWDOsT3DYjYpEEm0Sl2pQ1S4,12846 +torch/include/c10/util/MathConstants.h,sha256=gyZaVPY6yUN2V2c1pdAkjtXy6UpD51eDmDixsacR_uU,3690 +torch/include/c10/util/MaybeOwned.h,sha256=JG-HdRwRjypc-liDVqV3r0FHmCq11gy9pKx2droIzYM,7155 +torch/include/c10/util/Metaprogramming.h,sha256=RWrjybE-bjBO5gUsAUDbR1vGHYco9r8Sf2i-TG7BtUk,7031 +torch/include/c10/util/Optional.h,sha256=t-dDwvMe7ULlbZEuG3K5GpUTA9orMFOvHc87J2s8VSY,1675 +torch/include/c10/util/OptionalArrayRef.h,sha256=0af3v_whZTvIMin4LssNMfFKX-vfheyAuMT-b9-7QNw,7080 +torch/include/c10/util/ParallelGuard.h,sha256=AClhBs6-_lFnvdUTtuDKKmNp1Rdf_CbLOo-BZCPJoUI,373 +torch/include/c10/util/Registry.h,sha256=0Ub5zzGxOT1OQwXoWvmgoz553g-o-L5VsV-W0mcvjvg,13158 +torch/include/c10/util/ScopeExit.h,sha256=7IV_xwvAerKLsjzHhU_TAFsjVlknfN22tOarz1mFjLc,1259 +torch/include/c10/util/SmallBuffer.h,sha256=8FhfpVXad5SXYTyeIvLrQMyf7xwkBK5lsOammWGbHRQ,1762 +torch/include/c10/util/SmallVector.h,sha256=3FO8q6Ap7RyplX2Hf4-jhCIvoObT4lkv3139aw8qAnk,49154 +torch/include/c10/util/StringUtil.h,sha256=0CiaiKULlEnSrYR7D7GkzHXDFg3jabo2tbCIhM43T-k,5185 +torch/include/c10/util/Synchronized.h,sha256=RYgOiIrZVwnXmMHeoZrHpv6-t383r39dotD-VZnlK1A,1896 +torch/include/c10/util/ThreadLocal.h,sha256=wW74FnH_mjIDvOKvzr6HTvxsPLRBI8HwWMuPcDFGsHk,3883 +torch/include/c10/util/ThreadLocalDebugInfo.h,sha256=ILDUXGApD0wOXy7FuQMSVnX9N-bnIeBVHR-53tvjFKI,2548 +torch/include/c10/util/Type.h,sha256=-GVwlf-O6CsPhLC_t9_t84apjpiCvwY7LlXpfp51OkY,646 +torch/include/c10/util/TypeCast.h,sha256=z2tbgnnuXhBVQjL9NaJtjZBeo80agyavWdJKS_PG2r8,5364 +torch/include/c10/util/TypeIndex.h,sha256=WUOrtqNbqB5PPYHBP8hLiUDSw4Kg1Al_p1j77sV7oYE,6038 +torch/include/c10/util/TypeList.h,sha256=YA3psuJdiyHYbjPAsGYrJVRqVvtWMH7kgC25_jqufu8,16829 +torch/include/c10/util/TypeSafeSignMath.h,sha256=ERjWczEb2maHR8bZM5BpfShJJFem3ExsqyUcrtt7qYk,4437 +torch/include/c10/util/TypeTraits.h,sha256=-3g4qpe76E0OKxVK731TUYKxElzCCj99SoAMU-UebHg,5338 +torch/include/c10/util/Unicode.h,sha256=hCDwsMEcAI5h6nD8F3ZxJbO4M4lq1pCRpwj6h3H0DvE,295 +torch/include/c10/util/UniqueVoidPtr.h,sha256=HbNzhyCaqaksAka7MfDVbu4E6jipEMt_DgVNu2hoaN8,4184 +torch/include/c10/util/Unroll.h,sha256=1R1zTrF4Blvqu0FRtpofBLroPSSVujaMdh0E8GIBDbw,843 +torch/include/c10/util/accumulate.h,sha256=hobsJjXaKqmwAZOCXogE7eZ-NFiScJS52hvnVjwElFs,4032 +torch/include/c10/util/bit_cast.h,sha256=X6VwjMumLNAkNzRsOJd55pxLofcLpj8meuotGhMjecI,821 +torch/include/c10/util/bits.h,sha256=5vkKgffFbfdboQtD9E4fDsMkxeGlMymsJuRwS_ChH-k,1449 +torch/include/c10/util/complex.h,sha256=El2yjMlx3_vOordFfikChNv_o-we7SULDl96Yq5kCKo,17971 +torch/include/c10/util/complex_math.h,sha256=K-lYAOgfqRUPZQQBExYkHuDpQtVplmaY85WlaO18wjk,12533 +torch/include/c10/util/complex_utils.h,sha256=647X9XNovef-gDB7_p-Q7TskQ-boGgW5MedmVJtp58s,1077 +torch/include/c10/util/copysign.h,sha256=EGcQC191aoUTlLXo8tKfAF9NFnMpQCE0hyWxw47FQZs,832 +torch/include/c10/util/env.h,sha256=tMqZ7y1lfkEX8GWMCZ9sL7lF81eioeSXDLt9QJHTQhk,944 +torch/include/c10/util/flat_hash_map.h,sha256=oSaLrGZejJg2sE4vOS73g9wxznCzBzaTEOeUKPH2ctA,61931 +torch/include/c10/util/floating_point_utils.h,sha256=qEX-EkcPf74per7v8KHX4c1-NAWsAqjckImw5pNC33M,809 +torch/include/c10/util/generic_math.h,sha256=OrVoQ3KVBmyRAXztOZwncxz6hcomJDYKwndsJAYGRfs,2156 +torch/include/c10/util/hash.h,sha256=6yk_3pfqiXLyBfNhh9Hw14z2CN8RjmAPtaD4rHqh0KM,11107 +torch/include/c10/util/int128.h,sha256=KZKU8oIs65NX36n5KsgT-aqoY4B2BHm3mfbkR8f6r3U,12466 +torch/include/c10/util/intrusive_ptr.h,sha256=p_v9X91Xj36K_rZY3x7hCXsVYK1C6OC-FdrUrRU714s,38467 +torch/include/c10/util/irange.h,sha256=PBKiXBnJTFP7Mpx1xZTa_jOX9027t6xF1tCc8MeRzLA,3352 +torch/include/c10/util/llvmMathExtras.h,sha256=x-xJE6ttLhUS3INBjLjXXjVwUgZWEx5qtUBIoSyXWxg,29493 +torch/include/c10/util/logging_is_google_glog.h,sha256=LU7_XPpQPV1CNYYOfKAnm9vRSTpUNFmRT81AqXJHtVQ,3794 +torch/include/c10/util/logging_is_not_google_glog.h,sha256=902fzZ3kKRO295OFUvKKFX9tM0Fcm959SE-uG7YsIn4,8664 +torch/include/c10/util/numa.h,sha256=Zv_RgPaUVPp3KN4FmvwaqIr-hZ_Es1bd_djbAIYGzsU,713 +torch/include/c10/util/order_preserving_flat_hash_map.h,sha256=H0kqajXqg-9Ez_FhP2U-C7ZKgP8mzAvSECi9AirffIg,65390 +torch/include/c10/util/overloaded.h,sha256=HroKnPbEpPcmOJ2ud_43qLAENSCdvN9q3F_2REQLhvM,727 +torch/include/c10/util/python_stub.h,sha256=Nigc7ZGrniF0qdLn-Ra4KIicNWTBrgARkJYpxs6Ssek,56 +torch/include/c10/util/qint32.h,sha256=iyBUhux_GEJ8J92GhOPnukFSHXEp_vCM_ImIZTR1_Gg,319 +torch/include/c10/util/qint8.h,sha256=bc5SknZDfO9_2Ez-QlgP6CVXkFhkFIc8pV6vqx4y4vo,472 +torch/include/c10/util/quint2x4.h,sha256=yGJ_ehKTUy8Iq54q6LGOQtBf2-Tdwm-6k9EzgLZnwr4,366 +torch/include/c10/util/quint4x2.h,sha256=XARtXHqCVQKflXpoKx4ybFS1E3Pdq9FafFAb9J8SUH4,366 +torch/include/c10/util/quint8.h,sha256=nEiBXDtefPX4IlYbmn_mxC7Ec9QaPZ-d0nIO1BbsGh0,320 +torch/include/c10/util/safe_numerics.h,sha256=QDH6C2kwmkewC8zw7pEBndXR2QvgsVMSBzCpvE9Pzow,2258 +torch/include/c10/util/signal_handler.h,sha256=cVZtjB4I9_Oy2ZinG-3BVa-8cMlDuflFqpPKWW0Y2AU,3309 +torch/include/c10/util/sparse_bitset.h,sha256=TdMRyhYIJtzDNRJQvMgTjY69YyytHZTRz9qJpNHxX4E,26645 +torch/include/c10/util/ssize.h,sha256=fRC0RaSU4YWJOWGpglcKzJbJoogdxtvQoSUKqW3Sc4I,1369 +torch/include/c10/util/static_tracepoint.h,sha256=u_jYYCJlvn-3eHJvxlGmnfwt99aG1mmVv4G65dS97bE,1076 +torch/include/c10/util/static_tracepoint_elfx86.h,sha256=_Nm-tHskm5pjhufoKXpjIEOnr2BAyhlndaI6DoZYt0o,7208 +torch/include/c10/util/strides.h,sha256=zGTN1Nfi4QBlE7vMHKltb8FSvDpeS_y2TSAPD39-8Qc,637 +torch/include/c10/util/string_utils.h,sha256=9tNMsGkmJEL4Uh8tO4_01EImdBzACHsNIWPVGn4yN2o,378 +torch/include/c10/util/string_view.h,sha256=zCJx2FT-VZFQjuTTrNvoDs5BsuTV_9fhmLiyv6ArLDk,17062 +torch/include/c10/util/strong_type.h,sha256=dMZYONhE_aGsNa1wfntKG-VTd9J2aloxEz3HQgv39qg,36740 +torch/include/c10/util/tempfile.h,sha256=eCtZ_I5XJ2I-WUUWs0UoTFdgAhr9HKsVcmFEJsI340A,2760 +torch/include/c10/util/thread_name.h,sha256=mnZYxkwFcjqj9d0Kk2HIjtSEYuuFi9rtmW10DUwHyEo,148 +torch/include/c10/util/typeid.h,sha256=a9WQ7tqJv2xvGRBXPWMH6N5M1U8xPOJCiH15rcCgYW0,23327 +torch/include/c10/util/win32-headers.h,sha256=Hwx6Heb2BvTTMDfWYL3yRoXsqMd9xdu1_LRXz2nMzws,858 +torch/include/c10/xpu/XPUCachingAllocator.h,sha256=kHZ98_sH_kkTE7GGm9d5IE0-5AOeSK7Mz1mcCm2APT0,437 +torch/include/c10/xpu/XPUDeviceProp.h,sha256=0iAyKXhyRWb24JSKVkbZWcih4UeVK3WvmJJbfMBxdKo,10166 +torch/include/c10/xpu/XPUException.h,sha256=ZSAWqWf8on0ZSjP-MHInJhN8BAt595-T8Qch7QO5DVs,415 +torch/include/c10/xpu/XPUFunctions.h,sha256=WNspPSqWta_BYs6aVToWaPE8z5Zv37iV3DEsDuiT3ro,934 +torch/include/c10/xpu/XPUMacros.h,sha256=byXiQLpH441jTqIrrVfF_EZEvV_8i_kbDYVqKcQ3rLk,542 +torch/include/c10/xpu/XPUStream.h,sha256=ite1MHaHz_FOg9jwHvkvpJF8pf8OQXvUati0RW0RjG4,4603 +torch/include/c10/xpu/impl/XPUGuardImpl.h,sha256=7K4ZAKCtBl6S9qJfqYVSSB-HSeligtPqiDZ5t34D9Xc,3599 +torch/include/caffe2/serialize/crc_alt.h,sha256=1S1Y-QOdR_AF6_ynNXP7skgrzBL4JA8knBpcUNniGFQ,75497 +torch/include/caffe2/serialize/file_adapter.h,sha256=cWooIxQt2IZhgtNh8Z1EMH-q6-ZRYt_Wm46bTZU2wl4,866 +torch/include/caffe2/serialize/in_memory_adapter.h,sha256=YvqxOKgl9o2TU79PqV29jh8jGxb91F1C_pdpuZd2S8k,644 +torch/include/caffe2/serialize/inline_container.h,sha256=Y001ThvgR77npui_9I7iRMdrdK1AJePbZiDDzHuR5_M,9835 +torch/include/caffe2/serialize/istream_adapter.h,sha256=jhPL2xpULlEAj8d6YhmRaSRRjRK6ZFkodgYX3vlPZSs,669 +torch/include/caffe2/serialize/read_adapter_interface.h,sha256=TrtqY4bnGW_iI8ZpIunrB0fbQhRq11g2Xic-AlE2ZPo,556 +torch/include/caffe2/serialize/versions.h,sha256=v2fi7vl7l_cGOVlPEjyW4GRFReQ5Kn4VTyJACt7_Euw,6648 +torch/include/clog.h,sha256=dDsRfc5QSJwCjfxivzVWLBK3ZVMRB-gn7CTl4c83nmA,3042 +torch/include/cpuinfo.h,sha256=FXfTZ9m3jA9qr6Csftc-vDR10KFKljy7C-7V9561Ihk,48854 +torch/include/dnnl.h,sha256=I-QBhgaQhsKI9ws5dIWiC1mo_tzjMZTqcOEH2R_dquQ,826 +torch/include/dnnl_config.h,sha256=4gxE_VLSQRh1ZjNU0b813RVsIqLRf1g97y8E7yYt6SE,854 +torch/include/dnnl_debug.h,sha256=54dhupUgTYXVDXGNKkIHZa_CIs5rNdGaB4jzaKOmsV8,850 +torch/include/dnnl_ocl.h,sha256=zEhZqSx-AMUh-leUn1DUIKre4POhBRoclUX204x0Ynw,842 +torch/include/dnnl_sycl.h,sha256=hP8wUN2leTYsOSH0zxGhYCowrWL6y1qzEMJx82cMOLE,846 +torch/include/dnnl_sycl_types.h,sha256=wx0L7FacMUW1yLGkQdl633awv1WIiMyjPit8VR0MxRw,870 +torch/include/dnnl_threadpool.h,sha256=pXtNzHokkJu8cOj1YHKPswQ2lHyfnlWmahZ6xSFUONk,870 +torch/include/dnnl_types.h,sha256=mj-E92o3tq2jYmf4m5ApwxF5ZUpOHSW2Tcx1Ye2-CXE,850 +torch/include/dnnl_version.h,sha256=TMnzInMTsAACwnwp4ICpkZmiGXNhA4PHNkrHME_E8_8,858 +torch/include/experiments-config.h,sha256=wokuhtIs0aUOFxBc3Hw0PRvqIs7o6KuNIAd07_HeuI0,471 +torch/include/fp16.h,sha256=E8HMsWXIGhISM6v9jeIa5K3ncDxV_ccTbShVn-bEmb8,141 +torch/include/fxdiv.h,sha256=fSkLf2DxcdPiQIF9s90UAZYYt_70xe8TWmU1DA3MAc4,13149 +torch/include/libshm.h,sha256=6V9-_p0xRhavijNsGdB4oxPHUgjOUZjd2U00-3dd0fA,1196 +torch/include/nnpack.h,sha256=1msg-Qi_QPKPHQHBEDHVWvHj0ilZNjwVIUSEhhs7_es,33083 +torch/include/psimd.h,sha256=4z8bkysyKCCrjI4MhcqPUIsdV46VUcRfjK8vO3p5q14,45504 +torch/include/pthreadpool.h,sha256=r65lzOu4EN3iozcIdd9C-J7y5DUCo0MCCNe26YD0t0w,99328 +torch/include/pybind11/attr.h,sha256=QPjH7BfhL8QFwHHkrDak8gNOLMlb1itAO5fobjdoLp8,24334 +torch/include/pybind11/buffer_info.h,sha256=m_VE_hfWPKl-KgUZy9aVQdPg1xtoaDaBgkurIX7aGig,7750 +torch/include/pybind11/cast.h,sha256=j5UvHFBOE3o-8kB2UcBNumV-dv9pLWn2Gf1uh-fz7pY,71139 +torch/include/pybind11/chrono.h,sha256=A23naeloqn-1NKVAABOsJtHU9Vz8lfvrAICuLk-7qBM,8458 +torch/include/pybind11/common.h,sha256=ATg9Bt1pwF8qnNuI086fprM4CUTdrZdk_g2HXE1Sf6A,120 +torch/include/pybind11/complex.h,sha256=AaDZ-rEmK4tFaue-K9P5y3TxxnaQF6JwZ_6LAzkdLQI,2096 +torch/include/pybind11/detail/class.h,sha256=J3yQxEpB9cg68riM3WnR5W9mzxraCJxmgQyHvONPPSM,28563 +torch/include/pybind11/detail/common.h,sha256=ww8qY6xFAjDhwTN8R3z-f4KI9itmVRRwG4H5vxYEfk0,53771 +torch/include/pybind11/detail/descr.h,sha256=k1nvytx1zhMh8ERL2xS8Unbxcio5fa7eZIqnTsZ0orE,5962 +torch/include/pybind11/detail/init.h,sha256=xJ_nyNwZh1j_a0d8K9fCloZ0-MIfh4X_vHja4CFwVF0,17858 +torch/include/pybind11/detail/internals.h,sha256=j0CmJRrMvSLOHFxn5yeq5lqTqBcjSoA0kT0v_VvgmgM,29033 +torch/include/pybind11/detail/type_caster_base.h,sha256=9AmJNWNFnbAmlty11TZEj4dcIDBItN_5EbHz3beDenE,49892 +torch/include/pybind11/detail/typeid.h,sha256=jw5pr9m72vkDsloT8vxl9wj17VJGcEdXDyziBlt89Js,1625 +torch/include/pybind11/eigen.h,sha256=-HmSA1kgwCQ-GHUt7PHtTEc-vxqw9xARpF8PHWJip28,316 +torch/include/pybind11/eigen/common.h,sha256=dIeqmK7IzW5K4k2larPnA1A863rDp38U9YbNIwiIyYk,378 +torch/include/pybind11/eigen/matrix.h,sha256=CS8NpkZI8Y8ty0NFQC7GZcUlM5o8_1Abv1GbGltsbkA,32135 +torch/include/pybind11/eigen/tensor.h,sha256=U7wM4vClaDAwWCKAqwmsCPiA2B3rAszIT3tV_yQusUw,18490 +torch/include/pybind11/embed.h,sha256=xD-oEg56PadTig9a8FOcMgbsL64jaie7hwG3y6DWPEI,13459 +torch/include/pybind11/eval.h,sha256=7re-O2Eor1yD0Q_KgFkHIjKD17ejzII687Yszl9_KfE,4731 +torch/include/pybind11/functional.h,sha256=XY1Rj5_x2nb9AT0OzB9skt6OMOn6klNSkT0uBrRIkLo,5051 +torch/include/pybind11/gil.h,sha256=IAR_w0RupvFS5bLfw66ZV91OE9WC1p1ztOFSaxHGvZo,8517 +torch/include/pybind11/gil_safe_call_once.h,sha256=tPoJICumDjCcfFsFkltDGLj7c42NbgdhSt0ERkrSGKQ,3876 +torch/include/pybind11/iostream.h,sha256=K5rPXoCYN325r1PptcJCIhPhgtRtTJQjMr7bvUIOwxk,8862 +torch/include/pybind11/numpy.h,sha256=iaVp3boyb4GkVgY2vgBXbFaLwoHPb6rmSlOM44-eFU4,84243 +torch/include/pybind11/operators.h,sha256=224RoAXcv1la4NNY9rQ3aD_AeC8S9ZKx3HVK1O8B4MU,9103 +torch/include/pybind11/options.h,sha256=qXvmnj--9fZSp56NYefnB3W5V17ppHlY1Srgo3DNBpw,2734 +torch/include/pybind11/pybind11.h,sha256=zwcJLUvVmiZPpzvkt0Lu9IysI5Xs1ptCw9Y7C689jJU,129569 +torch/include/pybind11/pytypes.h,sha256=ehwy0s9uSGkByshl2l90nd25D0Mop3RNY09JTRkHUME,98953 +torch/include/pybind11/stl.h,sha256=aMi1OCCw2Zb-IRLSlAtQEJJHtWsRJiLT9dKDMHST1Ic,15532 +torch/include/pybind11/stl_bind.h,sha256=TA3A3guojho4GWsaP8SQfqbphF_HJ62-Sj2M8-CnxVA,28472 +torch/include/pybind11/type_caster_pyobject_ptr.h,sha256=H7pKBYTvUlibiJQEcKmeAkygSQwoCkuIyukNSDmVq-U,1929 +torch/include/pybind11/typing.h,sha256=rnjXxUTOp6EKJ4bwGCNV5Jortun-gBezC5s4SH-o8Yw,3600 +torch/include/qnnpack.h,sha256=mWe4sLwLzgVvsAhXWL9Qjm8FD0nWaRhY6tNrWyLN2bI,8638 +torch/include/qnnpack_func.h,sha256=kxuQHibZQi5M43Cvi-CVaYx3sB5V0w8IHvy8sTo8GtE,4146 +torch/include/sleef.h,sha256=uPhj04GjDiBOyK3EYN2UgREc6_jBwi8fSvLoFSq2c8Y,232472 +torch/include/tensorpipe/channel/basic/factory.h,sha256=3o2OYoXOWYEwtjoQ5X-EswIApRuljOdRWv-ojMhhx5Q,463 +torch/include/tensorpipe/channel/cma/factory.h,sha256=JxKJlqaLXICRxUAUQ4WhZvnlDJ16q50RaRNrd_LI1kk,459 +torch/include/tensorpipe/channel/context.h,sha256=7ALwdlTvgQ03mQaf62xXQ8DUyPOqwg45Qd0F4K6d6II,3701 +torch/include/tensorpipe/channel/error.h,sha256=gELOO5tHQHB4A-WmJuEs6ti1R4EsclrJwIKd9M7tcI4,778 +torch/include/tensorpipe/channel/mpt/factory.h,sha256=G0uZbp_uflgv-AFC7ne6m0txzApGqMZWvt_ICfq3WKo,646 +torch/include/tensorpipe/channel/xth/factory.h,sha256=EmAmNeIHbPe5bMKHnlHR6xdxzTEoCjczXWS8AhiKJWc,459 +torch/include/tensorpipe/common/buffer.h,sha256=p4M8zVk4PM2536SlgY44_RhxEKREEZT6I8oVDJxhyXA,3472 +torch/include/tensorpipe/common/cpu_buffer.h,sha256=pxnNAhil60W4izP77i80GpYRAM1C80jeBO34Jai1RfA,441 +torch/include/tensorpipe/common/cuda_buffer.h,sha256=CTwIuLbgn0Jfp7rKEPZGG_Fo01q9oU67Mpw48SICUls,468 +torch/include/tensorpipe/common/device.h,sha256=KZSlF-D7o3gWVCc8bzQpt_nDBLvW0maDdOFrx60Whis,1649 +torch/include/tensorpipe/common/error.h,sha256=JkbuNVfCczMIFayGA0woiLCOEHTaSLmqC3dHBCvl4_Y,3136 +torch/include/tensorpipe/common/optional.h,sha256=R8Io-h6lETspEfT9z8gWWkKuS2y1X1bTCVFDJCp-lTQ,26638 +torch/include/tensorpipe/config.h,sha256=W7Q7azBmk7xdHVyvraFKBKwxkk6dsQew26lwxuDJu84,351 +torch/include/tensorpipe/config_cuda.h,sha256=_SLA9yKKTnnSbVDgUCfc5BmO3kFgcjGxUxVWu-WH3VM,319 +torch/include/tensorpipe/core/context.h,sha256=jM_MOIRoc1ZUU_NJi6du5PtFaxAzOEQiqzAb_ludD_g,2468 +torch/include/tensorpipe/core/error.h,sha256=7NdEl7Irf82Yk0WL2XXTFnpIapv04vuiEMn7mCCq060,961 +torch/include/tensorpipe/core/listener.h,sha256=19RG5UUa6-8AZAf5Nr-yA6_4j7bfBsdOv0CUwJF83cM,2928 +torch/include/tensorpipe/core/message.h,sha256=ycfshEi1a8QOrNJlOKZwKWKVzNo7F42-pZeiZtglxuY,2885 +torch/include/tensorpipe/core/pipe.h,sha256=Zb0z4tKyoAPd99se_YZs1RQe3Cd7iydEsbanE8LbiD4,2972 +torch/include/tensorpipe/tensorpipe.h,sha256=UlOcNcNxPcn35eq0OBZ0YzjRGPaZevqfOas094Mya-Q,1449 +torch/include/tensorpipe/tensorpipe_cuda.h,sha256=jfoYOu7NbE5bgHtQoW_LktEqtjP-D8QNHl9PgXfuKsQ,704 +torch/include/tensorpipe/transport/context.h,sha256=L6kYLwqLG3V-o90buhzJFPh7eI_dzQEqPj-m0A96alw,2645 +torch/include/tensorpipe/transport/error.h,sha256=cmUQYONBrI-zmT28gCKojsqp6OxSUh-OJq2bNWqjbOA,919 +torch/include/tensorpipe/transport/ibv/error.h,sha256=K_0RM-V2HRRp_f-CQR8VWxXao-jyT_BhAycnAlAX7uw,920 +torch/include/tensorpipe/transport/ibv/factory.h,sha256=x1RLLvO58D4JQY_BTj-Jo7eKQwKA1FVueAeVzzGg9Gg,465 +torch/include/tensorpipe/transport/ibv/utility.h,sha256=OwgbqTXmVFVfbq4HYZTPShLz0lhYWLsJ7OyG1c1uEK0,569 +torch/include/tensorpipe/transport/shm/factory.h,sha256=7SEWso-QS8ZpHPaffz4QCP-o8rusTJAC1Vdw3bMpJt0,465 +torch/include/tensorpipe/transport/uv/error.h,sha256=YHLjjMatSyU_V1ulMyFi3WWJQT_xJZCzH4YHt20tYLg,716 +torch/include/tensorpipe/transport/uv/factory.h,sha256=1hSYHcEhiLvuRgvEanrpDPzO1wtzG_2ZgeLH72mtwAE,463 +torch/include/tensorpipe/transport/uv/utility.h,sha256=FRljgmy75kb4DNXkINUOSN3prXPrNWttP4FvsyR1t3c,1049 +torch/include/torch/csrc/CudaIPCTypes.h,sha256=1NWXzIO6hR-YbsXDEAaux5cXPhA6Dc4POOrVBstZJe0,3397 +torch/include/torch/csrc/DataLoader.h,sha256=lznqMptWAhecYOjR4xNw7M9uz_D_3i-erB2afkahEns,222 +torch/include/torch/csrc/Device.h,sha256=-2jKs9r1Kd_NzeRiVXarBVyRAEHOd8JEZry6XhU0GWA,483 +torch/include/torch/csrc/Dtype.h,sha256=lx62svLbBYG49OcsMAyemsumU3cjiBWD19xa1og_g7w,789 +torch/include/torch/csrc/DynamicTypes.h,sha256=XiAB2Fn7sQha6YO_hy8CBDnq_OWMS8v_S4CY_yFld5g,948 +torch/include/torch/csrc/Exceptions.h,sha256=2aATgzf6Y5nB0ZzdIUAtdW98wDV5G-nyNztgd7ApPPs,15234 +torch/include/torch/csrc/Export.h,sha256=ZiMG2QBIF6DcKqwWj3KSiXLWEn55prmg9a5IjvOzjuM,157 +torch/include/torch/csrc/Generator.h,sha256=_grQ0D9LIPDHB_xkMu7peBjgJsbTsUjRwOOctwmvK8Q,970 +torch/include/torch/csrc/Layout.h,sha256=f4b22tdUkDPMBPf10r18CSrLrEX1zV0LgNBt9DUG1CU,537 +torch/include/torch/csrc/MemoryFormat.h,sha256=PS_TTIZiELRrg08au2TF5Pn5OjJ_78kESahVT754j2g,632 +torch/include/torch/csrc/Module.h,sha256=wN2tjWdCnIQxJrMDwGu9qvP8r3Q-33eB2HkCvydBUUo,101 +torch/include/torch/csrc/PyInterpreter.h,sha256=qKBF5qdTCx7hQxPUutO2sevyWnaW4kdtpM1G_yvZENo,195 +torch/include/torch/csrc/QScheme.h,sha256=7Tp540AWYE0HrNgNQmHdhyGwAouc2ZS3oewmKHsyXbM,558 +torch/include/torch/csrc/Size.h,sha256=i312eBDDhfQsJqIEY7HLO4mm6-F3gw0xptYBn-jcGYY,428 +torch/include/torch/csrc/Storage.h,sha256=iUd7oyBWlhMLnGKvZSZ3IttAjjwQOqlRG3QXHBovJ2k,1534 +torch/include/torch/csrc/StorageMethods.h,sha256=rwOmQTprbmsE6JSQwctAI4et7C4sCu4T9aIfqLlcFY4,132 +torch/include/torch/csrc/StorageSharing.h,sha256=1CArzbCWa2fFqAh9GWj4fQovYycv5iY4D3UaamuAKJk,139 +torch/include/torch/csrc/Stream.h,sha256=7kZ7O6VsI0JxaZ0a27v3mGPSVEDXllQ4zPy4DSw0ZXs,546 +torch/include/torch/csrc/THConcat.h,sha256=JD1F5DtB2Ep00ZJVpilglulqKt6sTBwu7hS_Cmw2Cek,691 +torch/include/torch/csrc/THP.h,sha256=SPSS5bsFlvR4N7dgR2kV4fhELIwwggJnA3a82Wtgh84,894 +torch/include/torch/csrc/TypeInfo.h,sha256=ELy98ihypY76ViLiKmnrn0I3Lm6v0Xkko6hHzVdLl-M,498 +torch/include/torch/csrc/Types.h,sha256=AmVTjwFoCqH3ekahbAr32ulikXerrtB7ycNIDeX32lU,163 +torch/include/torch/csrc/api/include/torch/all.h,sha256=9nh4mWm6VZTD76X8xtCVjsx67eP5d3he8dAGKS_DmBc,590 +torch/include/torch/csrc/api/include/torch/arg.h,sha256=iGZepqd2MO7wSLfVuxeFo4UIfEHsI344159ekT528Mg,1427 +torch/include/torch/csrc/api/include/torch/autograd.h,sha256=MsdrQ_Un675B93MTyFZ1cLc09aLGLpXhwvJTZhR_j0Y,172 +torch/include/torch/csrc/api/include/torch/cuda.h,sha256=J238-uWS1thxsCxBj_f6wxC_fQPFc8A6MAYftdEEa5I,738 +torch/include/torch/csrc/api/include/torch/data.h,sha256=Kmhs111GxZwH-79BzETOAFrXVdXa-biOfDVy9H0PSvc,301 +torch/include/torch/csrc/api/include/torch/data/dataloader.h,sha256=YgJsTQB3R3MKfllvYAL56iGhxXm3ZS6jK-aR4xb2qFk,1969 +torch/include/torch/csrc/api/include/torch/data/dataloader/base.h,sha256=bAS0eiyi1X6EyNTl7R7CdmsVvT5qZrbe0Ec0-d1azZ0,9091 +torch/include/torch/csrc/api/include/torch/data/dataloader/stateful.h,sha256=Ll4teD7pan4E2nRoX03oaftJERT_JS7oXFvEWgdolA4,2374 +torch/include/torch/csrc/api/include/torch/data/dataloader/stateless.h,sha256=shX4hiIWK6gNwdWdUt1qRcJBH53SzOrFCebUn45Riho,2773 +torch/include/torch/csrc/api/include/torch/data/dataloader_options.h,sha256=11favVQYGSXABmtx2OtLHIXDbV1tE_zEbcWnxJN3B8o,2207 +torch/include/torch/csrc/api/include/torch/data/datasets.h,sha256=Q3_zlkvTD7BOp09o0vpPhI9r_1ABb_6n5CunXPS8ZCU,289 +torch/include/torch/csrc/api/include/torch/data/datasets/base.h,sha256=IeK2LEjERreF490CTHgQyVBHAsDwUoEj5tiCy7DEGc0,3255 +torch/include/torch/csrc/api/include/torch/data/datasets/chunk.h,sha256=pcxe7fnfFIpMMBF7Ap9MYO1pW-SnYUl8bUlCopwh5CM,19166 +torch/include/torch/csrc/api/include/torch/data/datasets/map.h,sha256=izVTBZSlJg3XA5cSzZmOxqFtSNPmFnqBF2-0p7syVKw,4149 +torch/include/torch/csrc/api/include/torch/data/datasets/mnist.h,sha256=EsIiV0K1xWUkWyvxJECZ-h5i9WTcgey7UwWg7y7rXbI,1274 +torch/include/torch/csrc/api/include/torch/data/datasets/shared.h,sha256=3sWsIjprurANfiujsA-nXYSaUjDb4J-6SC1fqfeAWtY,2640 +torch/include/torch/csrc/api/include/torch/data/datasets/stateful.h,sha256=BSXgm3tIeUJ7UeXFtcx9cl1ETE37j8xtnTZ-1Ph2AI4,2304 +torch/include/torch/csrc/api/include/torch/data/datasets/tensor.h,sha256=iwc95QjuG-qua9WDXr-UVvlJcL5yxaon8VjSS3_Gj9E,954 +torch/include/torch/csrc/api/include/torch/data/detail/data_shuttle.h,sha256=Ezx7V5a0DzbKFYaB-qONu5KE4CrMC6MddrluCXNkEzA,2626 +torch/include/torch/csrc/api/include/torch/data/detail/queue.h,sha256=sC_Z5JwLzcudmuDj2s5U9f39dkcdjkwfElWje6sSYyw,2486 +torch/include/torch/csrc/api/include/torch/data/detail/sequencers.h,sha256=4hOK1efnNfm_E1XY7kP1eC0EzJNlRpI317kciJi3S7g,4470 +torch/include/torch/csrc/api/include/torch/data/example.h,sha256=FoF2ZsbWqnyGe62RGxQpEe9zkPEFwPbnV_O9eGErl_o,1314 +torch/include/torch/csrc/api/include/torch/data/iterator.h,sha256=a5SCTCB0wHPJAuZtgj04OMKoyc3SKDwjnjfDONIbYZo,5284 +torch/include/torch/csrc/api/include/torch/data/samplers.h,sha256=ILkgiKXJN6RyR0Fjmmv8E8LuRBIoBH_P6lUmenbf8Ho,318 +torch/include/torch/csrc/api/include/torch/data/samplers/base.h,sha256=r_HP0iHQFeQ-5kaihcHHspLTZk4fSs6cztGPTKo2wJ0,1230 +torch/include/torch/csrc/api/include/torch/data/samplers/custom_batch_request.h,sha256=wwuFriVD9gspMiNaUerjj0JbzYiSq9gGHcvGxR5HJMA,556 +torch/include/torch/csrc/api/include/torch/data/samplers/distributed.h,sha256=xpV3JDi_ypd2zII3dzwVPVoNTVj1cuBkBV3rLIEr9yE,4120 +torch/include/torch/csrc/api/include/torch/data/samplers/random.h,sha256=CyDH8IthLCqxQMd7hp_Hjclmz8yXjIVdreKjx2MVQ-Q,1522 +torch/include/torch/csrc/api/include/torch/data/samplers/sequential.h,sha256=8CkVK2ND4rrMFeA1UQ2V8ZeI66NOJoaqX7mZd9Zz6mk,1254 +torch/include/torch/csrc/api/include/torch/data/samplers/serialize.h,sha256=Xziths-YjwF_GZ48kRC2woI-Mq3T5FnPaqb_rN1Dd7A,707 +torch/include/torch/csrc/api/include/torch/data/samplers/stream.h,sha256=QFEyl-x1J14aCngLJJ5Cq_M9z1UsW1yfDSsU1P1o_7I,2033 +torch/include/torch/csrc/api/include/torch/data/transforms.h,sha256=TvF9SJpmwR6rCQJvCvO4T5egw3AsiQsCCoOXs_0UTrA,222 +torch/include/torch/csrc/api/include/torch/data/transforms/base.h,sha256=ASbt1QfCjbbr1Y0UlhbxJMe2fB-aRUiQknSgnhSc52E,1629 +torch/include/torch/csrc/api/include/torch/data/transforms/collate.h,sha256=WmDBU1eC-t1-s0j8FQioTkdq1mwXoO_bqpB1lQo3rQI,1113 +torch/include/torch/csrc/api/include/torch/data/transforms/lambda.h,sha256=Kv3GGowexuP96q9NMdRD8VOPvAWq1V3vkc_c_SiUdjM,1709 +torch/include/torch/csrc/api/include/torch/data/transforms/stack.h,sha256=-PJSj11bWeg0mja_pATfo56qqrMcrHxvKO_qEZXaRQY,1424 +torch/include/torch/csrc/api/include/torch/data/transforms/tensor.h,sha256=kuYi1QbUpZcFZBA6_ty3rndAxH8ijPHUDaK64LqDr9k,2473 +torch/include/torch/csrc/api/include/torch/data/worker_exception.h,sha256=5wwUj8XNAgIBfepKIFOVzjtZ1_jf4TNXXXe-MUOIVxA,1088 +torch/include/torch/csrc/api/include/torch/detail/TensorDataContainer.h,sha256=2WOw7NwGbpRsnq8wx8G2OnRzoFFd-D3Yv014fPG84Wo,13893 +torch/include/torch/csrc/api/include/torch/detail/static.h,sha256=pUIWtGGNH8v1WLnEULDUp3nUXrEn5mlgr2VEUCvP2nQ,2200 +torch/include/torch/csrc/api/include/torch/enum.h,sha256=-tBHQNaovnuDmmfZaxe1HaT09tDXEQiqtA9osvIDdGs,7407 +torch/include/torch/csrc/api/include/torch/expanding_array.h,sha256=iekGG_-VoPk6phxfx8pi_uAS-LIGE_217r46Czb6-8M,6673 +torch/include/torch/csrc/api/include/torch/fft.h,sha256=5WaKGS1q9UbbMoYMNJuH8KoYLBy728WvBVRT8IcpjAo,12062 +torch/include/torch/csrc/api/include/torch/imethod.h,sha256=jKsQgJqScAnlZLk5Gpx_b0mE1crUn95AULY3w77hjmw,1740 +torch/include/torch/csrc/api/include/torch/jit.h,sha256=DHCcXjlpyeSFTF58OmdCXUJL3hrXRujX-hIgA8YXukM,913 +torch/include/torch/csrc/api/include/torch/linalg.h,sha256=_7-5qV6s2d1I5NlXU7890OX7cU7V85QrMcif9LeseSE,28484 +torch/include/torch/csrc/api/include/torch/mps.h,sha256=FRDi-oKf2Xayga00DSgWPomyyWuC_nSKSbMSgkUAAWM,1219 +torch/include/torch/csrc/api/include/torch/nested.h,sha256=v4cHHkJXPGWowWUiiURoKg1MV4jLdxofwRR9k1me5ak,2804 +torch/include/torch/csrc/api/include/torch/nn.h,sha256=Iah9Blyam2lcEKX85589p1KxupDmsbwkigjMErXYSUI,251 +torch/include/torch/csrc/api/include/torch/nn/cloneable.h,sha256=zDEzxwVI0lJUgMhfHFjJOI7RyusqymDKl5MUSXortdE,3881 +torch/include/torch/csrc/api/include/torch/nn/functional.h,sha256=NysmuOu8Bb9fjjXr_qJk2eflRZtyB-B_txwODYKiCyU,642 +torch/include/torch/csrc/api/include/torch/nn/functional/activation.h,sha256=DILH097KXAQxTUUdPE0TDnfD9L66pDd2P_6nX7M5JmA,29884 +torch/include/torch/csrc/api/include/torch/nn/functional/batchnorm.h,sha256=jWw-aKMc8AQCj1Yi5bM9xJeGg3fc_h1TIClFD5ADRW0,2090 +torch/include/torch/csrc/api/include/torch/nn/functional/conv.h,sha256=IGUXjx7Mo0vLnyKeAZFX7P1mROGcLCNH_eRMc2T55k4,8159 +torch/include/torch/csrc/api/include/torch/nn/functional/distance.h,sha256=0LZ0Z0xj3SBf7ahI-m4gZ8b3zg9-O3r-dNuRA3GH-ZA,2553 +torch/include/torch/csrc/api/include/torch/nn/functional/dropout.h,sha256=TDx5HONnEEw3z7aA_1we2ydlbbbfz0GM5XNULh9smx4,6596 +torch/include/torch/csrc/api/include/torch/nn/functional/embedding.h,sha256=afSsCg2V18oQoRX74entS8UX1gKVmsTr13RtGtVp7pA,6463 +torch/include/torch/csrc/api/include/torch/nn/functional/fold.h,sha256=cgF22lXcAJ_f2zItREa2zXuasC7tbtzr5M1qM1db0wU,2790 +torch/include/torch/csrc/api/include/torch/nn/functional/instancenorm.h,sha256=2uZaKLXWnZ0eukm7Bb8ihTGuowKaOMheE0A70QE14ZM,1607 +torch/include/torch/csrc/api/include/torch/nn/functional/linear.h,sha256=WXUeDK7FwvXxtZroPOP9KdP6Rvn2T3K8ds2OCEkPJfc,811 +torch/include/torch/csrc/api/include/torch/nn/functional/loss.h,sha256=4yhi-r1k3WDzI1PzpxLQk3gR8JPygpPFxU_-YnJ-UHw,31995 +torch/include/torch/csrc/api/include/torch/nn/functional/normalization.h,sha256=1LWFjXvI_Ad8WUaZeE0viV7u0KPCimq-HMCS4h-QKR0,6029 +torch/include/torch/csrc/api/include/torch/nn/functional/padding.h,sha256=zeK_8QKEOE72Ha9A50CQ5bEvZxAQIK8rSt58B8-bOWA,1726 +torch/include/torch/csrc/api/include/torch/nn/functional/pixelshuffle.h,sha256=miKN15rhr9w4LsvzB8s4vjWP7CoD9NakkzhR3QBfd9A,1345 +torch/include/torch/csrc/api/include/torch/nn/functional/pooling.h,sha256=6jpkKcQXDDP7fOVRuQdOi-qMuzQ5fr2cYkoG87GiKIo,35491 +torch/include/torch/csrc/api/include/torch/nn/functional/upsampling.h,sha256=ganV_vRn19CKdGIrzBD48lGEUuc4m6P52Ps-1Mp8LjI,10763 +torch/include/torch/csrc/api/include/torch/nn/functional/vision.h,sha256=SDymvG0oGt7mzHw1nnCaOTO0NPPVDPvANE5PukN8TAU,3677 +torch/include/torch/csrc/api/include/torch/nn/init.h,sha256=peZX66JUTiRh4XRtOdscOKM9gmzt0N8RdqnvQFVleAo,4967 +torch/include/torch/csrc/api/include/torch/nn/module.h,sha256=-TiJnrYpMg1MOAcRcxMKVpqMTPVGYVc7_nLmKSWDros,26858 +torch/include/torch/csrc/api/include/torch/nn/modules.h,sha256=N-ch-fayJ5OIZEUP2hKxJK26CjIEGUnC2d8BnQWfK2M,1289 +torch/include/torch/csrc/api/include/torch/nn/modules/_functions.h,sha256=BP9nGTfrMWkvkNeWHXCl9beAWRvq-EQtnNo-DrCaCKY,706 +torch/include/torch/csrc/api/include/torch/nn/modules/activation.h,sha256=4Sgq1FLPCeTY8ZpBgU1p67jTA8SBMGOtvzA-ovVlI1c,30392 +torch/include/torch/csrc/api/include/torch/nn/modules/adaptive.h,sha256=DFbRzJAqoxxTbLUjojV-HuwGHfOnAAPKpOdBXFRwXS4,3513 +torch/include/torch/csrc/api/include/torch/nn/modules/batchnorm.h,sha256=XM1zVWA81Ggara8dzWFedYYgemZ0i54_Vx1qvGeLapU,8435 +torch/include/torch/csrc/api/include/torch/nn/modules/common.h,sha256=VIpLpI_JSyD8B372lKDzksHNFqgy5Ktn0F9iv5v-YTQ,4318 +torch/include/torch/csrc/api/include/torch/nn/modules/container/any.h,sha256=Bs4T4Djx4XZObd0lGveBI6tVsVvPGev5R23Gsaiodos,13717 +torch/include/torch/csrc/api/include/torch/nn/modules/container/any_module_holder.h,sha256=z8GDcCvhmOx8tImBvBm1tiXITYRZBuvQ3linvfeoDPI,4796 +torch/include/torch/csrc/api/include/torch/nn/modules/container/any_value.h,sha256=2PcpOjAazKJSzj6L5G2fSDt5mR1epvQdABYbptVxdpI,4078 +torch/include/torch/csrc/api/include/torch/nn/modules/container/functional.h,sha256=CujavnJKGre8HgI4_pLLkbn_UCCUX1Yi52Wu0hN1fVg,3437 +torch/include/torch/csrc/api/include/torch/nn/modules/container/moduledict.h,sha256=OS8d-nox3sghr-80W5q1Z0JaIjKmszf1lJn-pGSNROU,8437 +torch/include/torch/csrc/api/include/torch/nn/modules/container/modulelist.h,sha256=qnmLQwQpZnSQT6hY-PuMQGW5HDy_0tCg5EUPSlGRXEA,8983 +torch/include/torch/csrc/api/include/torch/nn/modules/container/named_any.h,sha256=P2sWNAVFOwMDgAxGuLNeWTfv27J3pwgQfd6fDZ1xTUU,2748 +torch/include/torch/csrc/api/include/torch/nn/modules/container/parameterdict.h,sha256=hZfkx8aAFcLHdr-pTgDgRZB0AhFKEcw1fhxpoyqGRus,4500 +torch/include/torch/csrc/api/include/torch/nn/modules/container/parameterlist.h,sha256=Dt0JwsLZpr9C0WOuvNmxJHZSOntzLmnewaE2CfcUarI,5612 +torch/include/torch/csrc/api/include/torch/nn/modules/container/sequential.h,sha256=nt_XLg90S2qQGCT9-Mdx_0F2P7U7Unx3FzVrRExOiiM,13801 +torch/include/torch/csrc/api/include/torch/nn/modules/conv.h,sha256=u1Z45kc-Yrfh1jbMFIMIclg1fEY7w9ruxBDbKiwu3wg,16350 +torch/include/torch/csrc/api/include/torch/nn/modules/distance.h,sha256=0Cbqt-BskTtJJOTvgwlsGhAx5Hu_tT7nRouwBmA4icM,3085 +torch/include/torch/csrc/api/include/torch/nn/modules/dropout.h,sha256=TnCUg8mHAq7MIePrhNllBKJ5E5ktZqdQOAQZ_hfrxAQ,6525 +torch/include/torch/csrc/api/include/torch/nn/modules/embedding.h,sha256=BIuoRucwMOp3k49_px5A6967fcrvtrH5wFxqGUqOva0,6224 +torch/include/torch/csrc/api/include/torch/nn/modules/fold.h,sha256=JWW6AqN-AmBbpsjRjT_bmKQolcrDeg3rzddW3zs10Fw,2851 +torch/include/torch/csrc/api/include/torch/nn/modules/instancenorm.h,sha256=QrrySsiNuN-q3ThXWsDrJ0yfbfOvNi2d81hG0FPQzlo,5440 +torch/include/torch/csrc/api/include/torch/nn/modules/linear.h,sha256=4kx0xcQj8oyPQ8cGRPnoI9bY8fqf_i8Fb2zw8FMvZak,7455 +torch/include/torch/csrc/api/include/torch/nn/modules/loss.h,sha256=Oix5-EEvtLEMUbZgy8TL6-975lZ4jKM1gfmiuBbD3kQ,31047 +torch/include/torch/csrc/api/include/torch/nn/modules/normalization.h,sha256=mKzV4fa82pQkxyN7pXs48hRCKFMPJ5y5SMhEYeCSf9c,6932 +torch/include/torch/csrc/api/include/torch/nn/modules/padding.h,sha256=7g0s-1Nf-pZ6FqjT85Bn1MEn-kkRsuOh2Pjn1BaNOvo,14389 +torch/include/torch/csrc/api/include/torch/nn/modules/pixelshuffle.h,sha256=3xvKd1fP_uLIPRHLB0O6uhnVqUSBUVpFdYqKEum78Yo,3138 +torch/include/torch/csrc/api/include/torch/nn/modules/pooling.h,sha256=TXsWMUmiv2EqxdNOQbX4kdCnfh_EbwGKvNtjhrYYPkc,29705 +torch/include/torch/csrc/api/include/torch/nn/modules/rnn.h,sha256=V7XDot1YcC4Ck-_asydRJvug8Kg8wnt-gcFYHC2PBQY,13482 +torch/include/torch/csrc/api/include/torch/nn/modules/transformer.h,sha256=csOLk0HEH9ecHhyRvagjkFSx4ImefSI-beO_mn1Tnh8,5347 +torch/include/torch/csrc/api/include/torch/nn/modules/transformercoder.h,sha256=9ED87J98BxDKwlXCU3pgDEIMJuB1ppxhkz4--OrmW8Q,5210 +torch/include/torch/csrc/api/include/torch/nn/modules/transformerlayer.h,sha256=W8DjzwFJXv9XOf1DZv8eZ1t1oWFc3IJJPszHz0Dzb1o,6436 +torch/include/torch/csrc/api/include/torch/nn/modules/upsampling.h,sha256=JdQtx-f9utLFCM7iQvRjce0Wh_xOCUtFGkahRs5MmOc,1653 +torch/include/torch/csrc/api/include/torch/nn/modules/utils.h,sha256=xckfFxoRlgOVH1njGyogceCx5q-KJQ83nJaOkHSUG3g,1517 +torch/include/torch/csrc/api/include/torch/nn/options.h,sha256=gilbiVyS93p7hxxyII0HQeKrDG8lVfOafzVF--xe6Jo,645 +torch/include/torch/csrc/api/include/torch/nn/options/activation.h,sha256=HaiFrpZ_hIOTedWZKSz9IF5IHvHfhptp7_yoBXpQqy4,19044 +torch/include/torch/csrc/api/include/torch/nn/options/adaptive.h,sha256=5EPq-J3DmNkQbwGBVLp7PeBCdVtSvBkfbPgGwdn4hCk,1082 +torch/include/torch/csrc/api/include/torch/nn/options/batchnorm.h,sha256=fvDhawqR57OjuKMbenihMdBhte9FLWZU9cL7xy2MhGM,2799 +torch/include/torch/csrc/api/include/torch/nn/options/conv.h,sha256=fDKeCfujd4KWTHVxhK3uEHJwcc1z0pa4Kphq6FQW_PQ,13471 +torch/include/torch/csrc/api/include/torch/nn/options/distance.h,sha256=1xO3QSvj2bRjC_tDSxsRHeZrWUo-aoyjoWGfjpE4FB8,2014 +torch/include/torch/csrc/api/include/torch/nn/options/dropout.h,sha256=310P1wMBa54NUwsX9-ZnaZz5cQ6MXt--zLwMopR-kZw,3070 +torch/include/torch/csrc/api/include/torch/nn/options/embedding.h,sha256=rVSAJCdYD5lmI7lOeDn8z8rO3hQg5z5Q67LhnVRv1e8,11667 +torch/include/torch/csrc/api/include/torch/nn/options/fold.h,sha256=O0L5OK4knN17vWHoOlJO0oYcTPtg45KwHf5_Ozm7QOo,2985 +torch/include/torch/csrc/api/include/torch/nn/options/instancenorm.h,sha256=OYi8hkjptDwVSmUe4rVRKbWAinL3-yGWKfnrgVQhchE,2321 +torch/include/torch/csrc/api/include/torch/nn/options/linear.h,sha256=4vbCx_PsUqaEBZHT23QkkMlwX8dYJlgPDUewYEgAOP0,2804 +torch/include/torch/csrc/api/include/torch/nn/options/loss.h,sha256=Q9jm6F2z4MBRP_x6kLNXTLOEfWS12vFxhFuvqa1IO9U,26727 +torch/include/torch/csrc/api/include/torch/nn/options/normalization.h,sha256=4tkA8pmb95MtP_EeLYmXqqfJVBVhzxnqMZIIdRX5nZA,5522 +torch/include/torch/csrc/api/include/torch/nn/options/padding.h,sha256=niy8hQD-O7chIgVuxed2Vn5Y4msg6qsCsUnoU2XHNwM,6860 +torch/include/torch/csrc/api/include/torch/nn/options/pixelshuffle.h,sha256=8IxbtIymppT6zZ5HML8U-u4popSCbPoGWwL97kWovj0,1657 +torch/include/torch/csrc/api/include/torch/nn/options/pooling.h,sha256=SDCCf21tBSa9RQ524vo_URBJ0QH80KEjPeVu4Ghajzk,17743 +torch/include/torch/csrc/api/include/torch/nn/options/rnn.h,sha256=RBLJcPr1RXoK-lFWVyAgxcmQa0StVX3wifjYOr3XksI,8220 +torch/include/torch/csrc/api/include/torch/nn/options/transformer.h,sha256=ZovANxKNXQMg3-GjB1FYcYnGiWq5zAunZVRNxubCnvE,1839 +torch/include/torch/csrc/api/include/torch/nn/options/transformercoder.h,sha256=GyPoGtcjMp1zC0cdecPqdHUyqI9qMRImM570EXUoVjk,2344 +torch/include/torch/csrc/api/include/torch/nn/options/transformerlayer.h,sha256=j-KijW00OJcG8mDqkY7RzA8UTE337YryBmvU0SkhGU4,2084 +torch/include/torch/csrc/api/include/torch/nn/options/upsampling.h,sha256=iRaeM-saLpAUCKMBJcY4S046Bif-jY_bzGFX1XX6aCo,4150 +torch/include/torch/csrc/api/include/torch/nn/options/vision.h,sha256=UYxQaulHINEpbP4zNfM0ndz3NCKMSvSOeEiV5aBGJg0,1099 +torch/include/torch/csrc/api/include/torch/nn/parallel/data_parallel.h,sha256=boWLFLpR4oWK_SlnnJYZGaIC7xCWHXJcyRvHwD0oHU0,11126 +torch/include/torch/csrc/api/include/torch/nn/pimpl-inl.h,sha256=xxnX5ieC6RiLP_BrWToPZQS5-8Kd-FMkxu8K5EjJtb8,3196 +torch/include/torch/csrc/api/include/torch/nn/pimpl.h,sha256=Uue6ZUytkwcQfy7ro4D27rbw3Ft_X_MrwJbOhRhE-14,7102 +torch/include/torch/csrc/api/include/torch/nn/utils.h,sha256=WCbMNSev0r4C0hIKiE0SK89PEv_fXBGZA3jregGzNNE,131 +torch/include/torch/csrc/api/include/torch/nn/utils/clip_grad.h,sha256=AKcUt4L7e4AieGkst9kTcilHRqW4AQmERNs3EOS8veM,4874 +torch/include/torch/csrc/api/include/torch/nn/utils/convert_parameters.h,sha256=82Rx2e8-k4iX9Kr39oU-XTzQLVnvtgSIVy_Gymw5lXM,2442 +torch/include/torch/csrc/api/include/torch/nn/utils/rnn.h,sha256=NR5nXvB2yreXGVFhx2IcyQJDTKIqgWFScmIDQg3Ndg8,12680 +torch/include/torch/csrc/api/include/torch/optim.h,sha256=J4OhJvYyEZAp8PvJ76j92iQ72tMckncR02F9fssgkRM,330 +torch/include/torch/csrc/api/include/torch/optim/adagrad.h,sha256=MTFVhxp4UVapF-9_WycQrkLOJnm28z-2NkW1bRIaJNQ,3553 +torch/include/torch/csrc/api/include/torch/optim/adam.h,sha256=g25k323eiHpoomr8I4U1FB4ftmSAfwqAhSMEhvK0Fg4,2948 +torch/include/torch/csrc/api/include/torch/optim/adamw.h,sha256=2ggm--yAP7_u6q1LQuvOgVYvaFsHX_luZVlYRQMwJVg,2968 +torch/include/torch/csrc/api/include/torch/optim/lbfgs.h,sha256=aBel73C2L0dfnp3k0BQ5Jyoe7Xv62aDMse8qVaStfOU,3475 +torch/include/torch/csrc/api/include/torch/optim/optimizer.h,sha256=-t7rn6F4vEMVKWMdbmMs6ijXwv5IvksPma8q9A8KGp4,7739 +torch/include/torch/csrc/api/include/torch/optim/rmsprop.h,sha256=_-0cYe5WqZEx5CFQbQ7kDqI8s7ErzvVf7FFJ8OSYyJ0,2944 +torch/include/torch/csrc/api/include/torch/optim/schedulers/lr_scheduler.h,sha256=IEBVve89OX_4eeCsiUE7VeImY798ivG5y1S6qH5T89U,1073 +torch/include/torch/csrc/api/include/torch/optim/schedulers/reduce_on_plateau_scheduler.h,sha256=8t2t2vNyfrOqyoilW3QMW_NgX98lyLQOU2fhhKG6Khc,1301 +torch/include/torch/csrc/api/include/torch/optim/schedulers/step_lr.h,sha256=dL77rvbqybcqFZr6FodFnW6taud9JFPFnX5kW_2b_ZY,424 +torch/include/torch/csrc/api/include/torch/optim/serialize.h,sha256=Lep7_9fyStat1UTMe9jorW2axDtUKadyE2OqDRGb-mw,12250 +torch/include/torch/csrc/api/include/torch/optim/sgd.h,sha256=5W-3wIeP3Zic4ZJRA0bwYiwMPJGzX88CHi_X4qr5uVU,2690 +torch/include/torch/csrc/api/include/torch/ordered_dict.h,sha256=LyKdAi0oHRb09ePr1N98eid4PwITHxxOwUcogYBX-6c,16236 +torch/include/torch/csrc/api/include/torch/python.h,sha256=kuyCBD7bhkzNLGIFfNFYbrUxfAJrIg9thYvLslOzFcM,9916 +torch/include/torch/csrc/api/include/torch/serialize.h,sha256=IDE9Nj1gc7itAvC3fPOtydjauYKC7nLkWUi6vecOlLQ,5244 +torch/include/torch/csrc/api/include/torch/serialize/archive.h,sha256=IM8xj82javqyrkZJGayTWjrst7_FKKllzucRwSMrlos,101 +torch/include/torch/csrc/api/include/torch/serialize/input-archive.h,sha256=4n36lYcMEObL_PkPRpOwDGKIAwV6MxJ6M_LRzAJ8ErM,3992 +torch/include/torch/csrc/api/include/torch/serialize/output-archive.h,sha256=SwvplynJPXRoJFGKYnocrS4K_jelwVG0cCmiB8wd9Ow,2315 +torch/include/torch/csrc/api/include/torch/serialize/tensor.h,sha256=gEYAbqPp6R4AH1G7o4OuS-zVPY8osmtguUFfSSUt7jI,432 +torch/include/torch/csrc/api/include/torch/sparse.h,sha256=XqH3dLpwkPJzg0p_5XcJ01tnrQC98M9Fhe48Jg6KHc4,97 +torch/include/torch/csrc/api/include/torch/special.h,sha256=flCzivIWYyGJK8pygai-IAFfGMuDnFVbHT1KT40yWXM,38422 +torch/include/torch/csrc/api/include/torch/torch.h,sha256=VRdG_p1q4Y2gB0LtTmL_C4EpbrPQuvFVa-21l1wc-VU,154 +torch/include/torch/csrc/api/include/torch/types.h,sha256=87vYupO22F9us0JGpA8otsJ6T-ggDVYSLaRXaBHB410,2300 +torch/include/torch/csrc/api/include/torch/utils.h,sha256=T1WuMmWHTIEsjAwu6u04stbCbDGCpQyqDVmdvRrmIoo,3512 +torch/include/torch/csrc/api/include/torch/version.h,sha256=zM3Z1pkvi9uPka0NpcmQMpB_W1I4Fp5WieZaJXqatkk,315 +torch/include/torch/csrc/api/include/torch/xpu.h,sha256=Dlrk3eATuICT4j9HpzznnO6T7nPzIoEXlbuUtwstXOU,602 +torch/include/torch/csrc/autograd/FunctionsManual.h,sha256=7atNl_cssycTdh18YVupkrP8AErirTTib0lW97A8vjY,32107 +torch/include/torch/csrc/autograd/InferenceMode.h,sha256=hyp9uc-uXPuSoiyVupyje0n6r0_RlcZKQS4xX8eVAWE,156 +torch/include/torch/csrc/autograd/VariableTypeUtils.h,sha256=GPR4SkLBJkeitirrAb44Ptcar8x03o5HDpAh59cFAts,14811 +torch/include/torch/csrc/autograd/anomaly_mode.h,sha256=VhivPLzU1VudJLTVJvKOCfyR3e9Y0dLBwaefJaGDWpU,1724 +torch/include/torch/csrc/autograd/autograd.h,sha256=DiHVkxJqLFKK6EpHDUDOJRDQ_LEkG6YmgNEdU73gD9s,5309 +torch/include/torch/csrc/autograd/autograd_not_implemented_fallback.h,sha256=4uoj4sHweJt--NEkq8qWqEWj2tb6md_kC31TOU1N8os,1142 +torch/include/torch/csrc/autograd/cpp_hook.h,sha256=PRy5GQju8pdUEfXKQYo2qFRnyXa5G9l39RAc04cNXYI,865 +torch/include/torch/csrc/autograd/custom_function.h,sha256=AW8X-Q1AIPqs_6nc9amI6QqLcV01ECEghn1-Tc2XkgU,15463 +torch/include/torch/csrc/autograd/edge.h,sha256=pqMnb2ppiPeiKn61IR_SY2jMpRQpU-OB9Vr7cqZrR6I,1615 +torch/include/torch/csrc/autograd/engine.h,sha256=V103Mk42PcXf98QOCmWlsaVb1TPQhX-3G8TQbL4PL3k,10702 +torch/include/torch/csrc/autograd/forward_grad.h,sha256=4b01CUfL2WNzrxME5fiBmkGdCBDFoYwa7Bg--rwIWDY,8938 +torch/include/torch/csrc/autograd/function.h,sha256=O7U88tMN2PMr4f7KCHQYRo9qFlSS4ArF9mUjmDzxN8w,29650 +torch/include/torch/csrc/autograd/function_hook.h,sha256=lRuKm3CZ19Gl8ueR_MMSn8m4VK_Kx6ZfrMXR8ZVitnk,2072 +torch/include/torch/csrc/autograd/functions/accumulate_grad.h,sha256=J1Os4LQ92farCfHm7d_-11ZKBR-9f_lZepHwUOIAOzw,13659 +torch/include/torch/csrc/autograd/functions/basic_ops.h,sha256=BBaqHcPe30GCLac4nVxSuzYwX2J0fmnyMEVrVBSC3Ek,3257 +torch/include/torch/csrc/autograd/functions/comm.h,sha256=bByTQRRuBRcDLQs-ppYZVu9DaQSZaQhcyQ0zM0aJ_0k,1233 +torch/include/torch/csrc/autograd/functions/pybind.h,sha256=e6eM-r7Xrvjp2lGt1nC0SOj56u_m2u6ysd0nBlXMP0s,342 +torch/include/torch/csrc/autograd/functions/tensor.h,sha256=gvjFoWaYGhjex-Aq0n7GEUGvukI8QNyRpQOCe6A-Yeo,7266 +torch/include/torch/csrc/autograd/functions/utils.h,sha256=9IR2EGNMyqGa9OqcLp4Z8dfop8N-B1rP4DiP5ALjXGk,3211 +torch/include/torch/csrc/autograd/generated/Functions.h,sha256=0Bn6adhybG-RoxyQoBOavA5tV3hits8-100d0fqUxFk,491497 +torch/include/torch/csrc/autograd/generated/VariableType.h,sha256=FudGYS4N47MaNG_c1xD1gDZG8QnrAGy7lJpvSDr-cS8,1730 +torch/include/torch/csrc/autograd/generated/ViewFuncs.h,sha256=DCHSkyZVJqKzU19t4CZ3HzbUkBnF7bhtS966Rz9xiPk,36698 +torch/include/torch/csrc/autograd/generated/python_functions.h,sha256=m2zbP4C796FvQVsVVmsXUCiz8Prj2O-pT55rbHA2NwA,891 +torch/include/torch/csrc/autograd/generated/python_return_types.h,sha256=duqsERucZcEvzjWUHjzvRJejN9GvrIcxhI29Sc7vrgQ,4062 +torch/include/torch/csrc/autograd/generated/variable_factories.h,sha256=bSwvVXUj_oVpVsjfxxLnyC6Kz7bvGp0Ova_zLPJIWO0,55243 +torch/include/torch/csrc/autograd/grad_mode.h,sha256=uzjms9KcKXMdR0-20069M5-4lNYJoO6Dp5IrTlp0040,210 +torch/include/torch/csrc/autograd/graph_task.h,sha256=Mj_fjS0cVRc7Hf-ZljfHx77tmf2U0vCCDvnPJi3z0zU,9250 +torch/include/torch/csrc/autograd/input_buffer.h,sha256=SRHtOa0aPq6fBnUqyuXf9VQgDDkiSdqPpqCI5Tcf_f0,1418 +torch/include/torch/csrc/autograd/input_metadata.h,sha256=c0fYFoqxMeKpEVrT1-eprIezNZw5T01JBKW7g-11tv8,2982 +torch/include/torch/csrc/autograd/jit_decomp_interface.h,sha256=FyQGL5BsOWcWFZruQYh_ysQDEy5LkO-GcRT63H3_DMM,1798 +torch/include/torch/csrc/autograd/profiler.h,sha256=6ArK8ksshLYFDODo91Q75_cqzFjn0mNzQ3-Tdefu4y4,112 +torch/include/torch/csrc/autograd/profiler_kineto.h,sha256=rwL1ybK-PxwLco7X3z0I_bkYcOg5Kk6PtXg9Kqqnm6M,6834 +torch/include/torch/csrc/autograd/profiler_legacy.h,sha256=_Sf5WSlZkkLjlO9sGxqQk2g333l8I59rKN39xq3uY10,10718 +torch/include/torch/csrc/autograd/profiler_python.h,sha256=8Z3Z8f9uC_BLJzWSJAGsNyhmig7RCpSZm0aYsYzkOZg,84 +torch/include/torch/csrc/autograd/python_anomaly_mode.h,sha256=ab0RG3xRaCXKiT02x_DxOYgZGNVreApNNfSjI6Hygxk,1164 +torch/include/torch/csrc/autograd/python_autograd.h,sha256=L9C-y46IX9u0Q48q4-cEFSDRK1weUIEzAQLcwtUlq-g,375 +torch/include/torch/csrc/autograd/python_cpp_function.h,sha256=_-ej0SU49LZsgZVh8vUCVVaqyA1DFDIvyzEwV3zD4Ao,4528 +torch/include/torch/csrc/autograd/python_engine.h,sha256=o2VfohkLdBGIZPOmej3U8-SDeDGYBjd4weSmGqgWxGc,1249 +torch/include/torch/csrc/autograd/python_enum_tag.h,sha256=xZjV2TWlkXw5USUrIq0aYpoVoG2mbDy4GXREOnPPkZI,120 +torch/include/torch/csrc/autograd/python_fft_functions.h,sha256=OZv3f3f7oonK7zYbShCv4EH6p3VhSPaAH7Sl-ahz62I,87 +torch/include/torch/csrc/autograd/python_function.h,sha256=xv4zczSjgh6cuUkNtXfCuA-WjXlnDcR7TBHPYFjwI14,5519 +torch/include/torch/csrc/autograd/python_hook.h,sha256=gyxs2ZFVFgML8tDkwlUbxU0ZBD-MV5t2xxWLjw8kPHw,2015 +torch/include/torch/csrc/autograd/python_legacy_variable.h,sha256=_8tWed3mDIVmtYpI_WPVUpfjK_eH7Qv4wNrSIIlahVQ,257 +torch/include/torch/csrc/autograd/python_linalg_functions.h,sha256=592vpVDlik2EwxZnuKwqJ617_xq2p0Rf3Tr4XspSh2A,90 +torch/include/torch/csrc/autograd/python_nested_functions.h,sha256=4R_lyK5cWoEtRSKS1HqX6xHPfO0IUmnA99yiU-lyxRk,164 +torch/include/torch/csrc/autograd/python_nn_functions.h,sha256=_MMnMSOYTvNIHHzX6OEExk2ABVmgSVYvD_gt9C7gBqQ,86 +torch/include/torch/csrc/autograd/python_saved_variable_hooks.h,sha256=QeL_3hpnQ4AcIK63QipFRCndchE8ZKGqjQr8Q9nRwBk,933 +torch/include/torch/csrc/autograd/python_sparse_functions.h,sha256=Yw7doo_gafLcBM809TnnzZoitf_NBtCYex0nSTNweAc,90 +torch/include/torch/csrc/autograd/python_special_functions.h,sha256=4OdWU29kp8Alvtug_gJ4sLBvBYPq7n-v5Uwi4NRL_gk,91 +torch/include/torch/csrc/autograd/python_torch_functions.h,sha256=WMyOlDkJIchECl67t4uDckaSgKg0d1oK_F36pQ0Xd_A,650 +torch/include/torch/csrc/autograd/python_variable.h,sha256=L9NBZIEZBGicQWEWt-A83-IG5HUjLNeu7oCLV9x1_T8,3521 +torch/include/torch/csrc/autograd/python_variable_indexing.h,sha256=5kZvu_o0_h1zfbv2WFdI6-Vif6r_ICQkLKia8v5iFpo,2922 +torch/include/torch/csrc/autograd/record_function_ops.h,sha256=gXlXGMq8Awz0sHYozk9ardSdm3u8FvueT4MZxuizdO4,946 +torch/include/torch/csrc/autograd/saved_variable.h,sha256=qmWseW1TXA_x8XMqbgYI_P84KcmhmQTCg7NERj6Ny5U,4684 +torch/include/torch/csrc/autograd/saved_variable_hooks.h,sha256=d4Y8k7TzIhfaXWi_89WXbe3ZtT283ac_OiLtzFcpHuY,296 +torch/include/torch/csrc/autograd/symbolic.h,sha256=XMrwDnlSibXxnqZiy5pNDVwTBDsU8aIDamEg66kOEYk,300 +torch/include/torch/csrc/autograd/utils/error_messages.h,sha256=NBHVXO8V1_6xk2gwMofFfVt9nX1UCnXHi782S6zBYCw,545 +torch/include/torch/csrc/autograd/utils/grad_layout_contract.h,sha256=k0qojHNOvUIvBGJ1vkh6RuERPG6NgDzv0b0itZNPfVI,2872 +torch/include/torch/csrc/autograd/utils/lambda_post_hook.h,sha256=FkmqRcdB8ZrWs7F_59ZrQ0fL9qlUDp_dI1shzs3aegs,1272 +torch/include/torch/csrc/autograd/utils/python_arg_parsing.h,sha256=wBHtTreXkDNTNutDT29YF831A6ca_RVrEDc-7sJMMEA,1473 +torch/include/torch/csrc/autograd/utils/warnings.h,sha256=asBCrExi_O6PzdroSIjC0Qi_QMqOvE6FFQVE2fxG-dg,633 +torch/include/torch/csrc/autograd/utils/wrap_outputs.h,sha256=QtY2BdWrVsIXGlBSSyD4ikUtQoJbbxd-W14P_xoTjBY,3816 +torch/include/torch/csrc/autograd/variable.h,sha256=W7hMXhpnPlfjvqnVJp10KgZL986WahBaiBMpQ5h-ij4,40162 +torch/include/torch/csrc/autograd/variable_info.h,sha256=R-Zw-sUmTMOIpWb5Vnf_n2jlteDs5o0NZpfxLx7yKYg,481 +torch/include/torch/csrc/copy_utils.h,sha256=HPNwtV01Xllja6b16GsOFNYlpV0DrHkqsGCiwSYWnVg,1420 +torch/include/torch/csrc/cuda/CUDAPluggableAllocator.h,sha256=CghHUx7_9Jd9CqJ0oZc34oaWjJRWg04_-Q0G-vm7p4Y,5690 +torch/include/torch/csrc/cuda/Event.h,sha256=FK6jWILeAE5Y3b53Eqw-pDfF0tqu-LmIiiJ3Qck7ahc,406 +torch/include/torch/csrc/cuda/Module.h,sha256=GgDQDHrKiVqJgRS_Oxe49-vTIQorgcL1x4VgNbiEGvs,436 +torch/include/torch/csrc/cuda/Stream.h,sha256=Qp6DFebuoMgWE05n4AIfc7pasukINXSwKLrkqRK7TJo,504 +torch/include/torch/csrc/cuda/THCP.h,sha256=M9D-wbEcdRLxPxx-ZwChqKXx9TI1hL5GFLipfYbRHXY,213 +torch/include/torch/csrc/cuda/comm.h,sha256=lXRo8mfhOHjLywodtGB6iQIxaIkf3O8rnc8vfxx4H3Q,1525 +torch/include/torch/csrc/cuda/device_set.h,sha256=8s6LLs4PG1uykInR1FW08Ey32EQP84vgg4rDfPcLmF4,185 +torch/include/torch/csrc/cuda/memory_snapshot.h,sha256=Aj5dx0fVHT_B7NqliVhCTA9pC_RAkSrZProY7_WE0f0,780 +torch/include/torch/csrc/cuda/nccl.h,sha256=Z2lKlewAc3WLrWu9wyKtBR4x4TLPRFAPpa5OB0BAAFk,5887 +torch/include/torch/csrc/cuda/python_comm.h,sha256=ysrI2Zyf3DEjAUPkc6Occ3SuSd__eZnPJptRA-hiU4A,123 +torch/include/torch/csrc/cuda/python_nccl.h,sha256=yNwoyNpT1EmyYAmk9k7UWpO3aNfErizqV0QVMiFtDts,682 +torch/include/torch/csrc/distributed/autograd/context/container.h,sha256=zgh1q2ouJQbhgfE03o6OFMf45Nf7JMF6oxK9xVqpd40,6435 +torch/include/torch/csrc/distributed/autograd/context/context.h,sha256=IBra9z6MfWpxdiCMJ5ydGwu8-9i0C5RpoqYc2MZ0Ooc,6623 +torch/include/torch/csrc/distributed/autograd/functions/recvrpc_backward.h,sha256=RXUW8DHNtGmsJncR5kalFR1OlSCMXAD42xlOfHwIdFU,1705 +torch/include/torch/csrc/distributed/autograd/functions/sendrpc_backward.h,sha256=aM04SmFMzmvHhoPbr3NsSLuNMxfnXUiRxKeoFxvPaKs,1373 +torch/include/torch/csrc/distributed/autograd/rpc_messages/autograd_metadata.h,sha256=TncgZoQ3veChIuqqWIrWk3C6fQLkE4vXUX1Xbmu04Po,750 +torch/include/torch/csrc/distributed/autograd/rpc_messages/cleanup_autograd_context_req.h,sha256=MbhyDQOZTiZgJdh-0NCSQGWxJd3HP5XI78PP37DD5T4,886 +torch/include/torch/csrc/distributed/autograd/rpc_messages/cleanup_autograd_context_resp.h,sha256=IhH67Y_YeYJG89z83_eabDLtLQFc6Qyw2i_Wf3UBrD0,711 +torch/include/torch/csrc/distributed/autograd/rpc_messages/propagate_gradients_req.h,sha256=fmUaNRSlp8UCpPOrfFVOYUWHnW-tIV1jPEq4gcOrCzA,1298 +torch/include/torch/csrc/distributed/autograd/rpc_messages/propagate_gradients_resp.h,sha256=gFrx1pp9o3mjfJMi4i0aN4nIofKvDrssUgI6ulwGFkM,804 +torch/include/torch/csrc/distributed/autograd/rpc_messages/rpc_with_autograd.h,sha256=gZptHkMQkV_GKb245ZvTXGj83XygGNlc_7RPxIUi6Xs,3556 +torch/include/torch/csrc/distributed/autograd/rpc_messages/rpc_with_profiling_req.h,sha256=ud7bL1DAGkXJjrYbT3at3PrUFSndKQML0MAYZu1SQ0g,2347 +torch/include/torch/csrc/distributed/autograd/rpc_messages/rpc_with_profiling_resp.h,sha256=ZAuSpskXTGPad2W7maXa6yOAqWwM8y01iC5V7M08w0Q,2307 +torch/include/torch/csrc/distributed/autograd/rpc_messages/rref_backward_req.h,sha256=97UW3DLiLJK1AiM3gMGDCNhXTZ7RHPUOeM6MJ0B9Gr4,1027 +torch/include/torch/csrc/distributed/autograd/rpc_messages/rref_backward_resp.h,sha256=ji-yEL0BUVRR6yGLhURGmje0GdRP5m047-urW_0_HnE,558 +torch/include/torch/csrc/distributed/c10d/Backend.hpp,sha256=U-7tVVTWJkuouoUK18YNjoNfAM_JUEgiSBs6pB-7oTo,12987 +torch/include/torch/csrc/distributed/c10d/FakeProcessGroup.hpp,sha256=pyYQS2AQugAQ8M6NRDWWHE-Zx8qeUEDbGyisRBRMFq0,6309 +torch/include/torch/csrc/distributed/c10d/FileStore.hpp,sha256=T57ueYyvSnyRalBp2sZ51oVvMbE5QoTIiOllsNfzuUo,1492 +torch/include/torch/csrc/distributed/c10d/GlooDeviceFactory.hpp,sha256=sh1F0-6ykB0f58LitkS5CC35UgX4ts1cp2G_my6_V8o,773 +torch/include/torch/csrc/distributed/c10d/GroupRegistry.hpp,sha256=AY2m8qmBtcSvfHQLWn79oGfSPmDczounrM9eR6nX53A,562 +torch/include/torch/csrc/distributed/c10d/HashStore.hpp,sha256=udXrv_pNQWROxlSoWaTkUONq2B0MLPcvoKCZoZpsnpw,1591 +torch/include/torch/csrc/distributed/c10d/NCCLUtils.hpp,sha256=CqoUaw6O9GqfiuSgC89ADD_xehciZeHzY9aGzMuLsns,19644 +torch/include/torch/csrc/distributed/c10d/ParamCommsUtils.hpp,sha256=wvD-_2AzkIIcTOj16Vpx78cwVi8M5C8hs53c0z55DzU,8497 +torch/include/torch/csrc/distributed/c10d/PrefixStore.hpp,sha256=1XibeUmEbbRKIWdCgxvXcwW-ID8jdQZVQugycEZB0nc,1967 +torch/include/torch/csrc/distributed/c10d/ProcessGroup.hpp,sha256=WZQgvCfmo37iUi-nbx0cFQFHgz4hnKlllAkN10VPZdY,28119 +torch/include/torch/csrc/distributed/c10d/ProcessGroupGloo.hpp,sha256=D3rWZVzooA_Nu_oi8Q6TDY-oySwx0xk9QR3Tvyd3WqI,15690 +torch/include/torch/csrc/distributed/c10d/ProcessGroupMPI.hpp,sha256=7sLhT6_LW9a-dj6pQ0DMCNlj__j8WsXg4pJ9lhwWq88,8640 +torch/include/torch/csrc/distributed/c10d/ProcessGroupNCCL.hpp,sha256=fAG0AYWoKJ_-qzbkJTIYmZ_Lrr0S5ts6pBf2XrwlFgM,41643 +torch/include/torch/csrc/distributed/c10d/ProcessGroupRoundRobin.hpp,sha256=rkZzy9oxnV2tvUmvrd2HKSQ8bY9tES0Rr9b1BZribwQ,3803 +torch/include/torch/csrc/distributed/c10d/ProcessGroupUCC.hpp,sha256=eTtzwL0oCkjTGiD_WSbEA_UlG6hE_NltOBz4x_6UY1Q,11076 +torch/include/torch/csrc/distributed/c10d/ProcessGroupWrapper.hpp,sha256=qFWav-lfsRnVJgyczuSz_zVSFp_vojfhPRObIPfvDfY,5070 +torch/include/torch/csrc/distributed/c10d/PyProcessGroup.hpp,sha256=PophsbBELx0E5-qUZyPEWDv_sW7uSweWPOhJlS0xtb8,6781 +torch/include/torch/csrc/distributed/c10d/RankLocal.hpp,sha256=tG9YhmIjvYo21H4aCITvrL3XsHS2b4uEU4MKUG20hDo,2279 +torch/include/torch/csrc/distributed/c10d/Store.hpp,sha256=p4xMmoNUQjipN3e5R6Zpe35Lec_tEbIhcBdfhxS5CEY,2832 +torch/include/torch/csrc/distributed/c10d/TCPStore.hpp,sha256=iL-kBSg4t35ixrJOlTv5nfbJPW2gCZsCByYuh5uiBFw,4353 +torch/include/torch/csrc/distributed/c10d/TCPStoreBackend.hpp,sha256=ruEIs4MbqpksSNet3BHxS1GcuFRyHuu0BX1zsJZnPtc,1573 +torch/include/torch/csrc/distributed/c10d/TraceUtils.h,sha256=RsCcpt8h3lOLvKCil2Hx79EiL6D0UBz96vg1moAAMHU,22639 +torch/include/torch/csrc/distributed/c10d/Types.hpp,sha256=PgbzAqlmGKMGGE_ngMe8QaAmwkQGJAnNrcaFT-fOvDU,4899 +torch/include/torch/csrc/distributed/c10d/UCCTracing.hpp,sha256=t3jW1WV_VfbBnKvL-vJscb1D5oZDHiqIqUoO0AjRbw0,2301 +torch/include/torch/csrc/distributed/c10d/UCCUtils.hpp,sha256=lj2dmFih-AdPgLut2cIYKQwhASWm8u8pU0hIWAF8ktU,6360 +torch/include/torch/csrc/distributed/c10d/UnixSockUtils.hpp,sha256=FH5wcycsZUd1gnRrJJPDjXrR2aMqFDQCeRlw4g3RuHs,575 +torch/include/torch/csrc/distributed/c10d/Utils.hpp,sha256=mbIiQc0q8ieK9rjxJD8vHVDfxvJjrVaUDMpXfyRLVZs,22530 +torch/include/torch/csrc/distributed/c10d/WinSockUtils.hpp,sha256=-PUywz6KhM_ngjiZxYlhuAHeR_4Tz_mMGuTdb8jE2oo,566 +torch/include/torch/csrc/distributed/c10d/Work.hpp,sha256=EOiE56BBXDcKbH3GDWGeI-2MTvSChTm1cf81LsQsRCI,5081 +torch/include/torch/csrc/distributed/c10d/c10d.h,sha256=erw6jxQNqwf2IKaRhi9c6_x8sscxKKEFFunON2rMUwc,216 +torch/include/torch/csrc/distributed/c10d/comm.hpp,sha256=mWPMu3j-9iAORZtTpmWVEYQ2EgxD4am8gZhohrw_7ek,4346 +torch/include/torch/csrc/distributed/c10d/debug.h,sha256=ihvgjPPnKL5CIZCt-b-sG9ZkGQOgR127o9j4JnzCZY0,604 +torch/include/torch/csrc/distributed/c10d/default_comm_hooks.hpp,sha256=06hUZLCjMBO4_AHFs0J4RL5EiiA9L6226CifXpDESnQ,1735 +torch/include/torch/csrc/distributed/c10d/error.h,sha256=JLzBftaNhMRWU7kZSmqSgniRPbj2NYgg0FshAyguz5E,1361 +torch/include/torch/csrc/distributed/c10d/exception.h,sha256=YpfrCv_c9vxk2tI14aa5iHujuxWkCwUYg56v4oYHBj4,968 +torch/include/torch/csrc/distributed/c10d/intra_node_comm.hpp,sha256=xG4ZqpQz2MmoOeMPBMlvDzI4c7y_TASwpjrKBgZw4qg,3827 +torch/include/torch/csrc/distributed/c10d/logger.hpp,sha256=6LO9-LevSCeb9fv8lnnZv_S5pLw7j7SMJ7XUbxZ1HcM,4039 +torch/include/torch/csrc/distributed/c10d/logging.h,sha256=WSP7f4iQC-gr0BLEUEEpCMq74ihWIr8ERvk3fo7_LX8,2059 +torch/include/torch/csrc/distributed/c10d/python_comm_hook.h,sha256=3C91AuADu-mZPOuxjNWxQywWOdp0X94yf4zbPjR3M0w,1072 +torch/include/torch/csrc/distributed/c10d/reducer.hpp,sha256=1u1OMEya3P_rHaWvVaf46w9ocDb-CspJ2aRNaQ-q1RU,25686 +torch/include/torch/csrc/distributed/c10d/reducer_timer.hpp,sha256=i3hNCDGat_8DIMHFo22ds9x34SylX2q9Vu-WELAi_tU,2374 +torch/include/torch/csrc/distributed/c10d/sequence_num.hpp,sha256=uWvHaIvAecQ7zn-y8Kmf4LZaAHJUSY63pfNZiE2s-dw,1681 +torch/include/torch/csrc/distributed/c10d/socket.h,sha256=zmhDv9eV41kBlUO_DIaMXg2GmgQMsZg421jUjxsTYw8,1949 +torch/include/torch/csrc/distributed/rpc/agent_utils.h,sha256=GnT_Z5VBQjr8MX54ju9oIuXlpk1O5jpK2y0aXQmbPUo,1679 +torch/include/torch/csrc/distributed/rpc/message.h,sha256=oaI15j4VSm5zxVTJOa_6FU3KyDO5FZ69PfGfBRjOoUY,7527 +torch/include/torch/csrc/distributed/rpc/py_rref.h,sha256=GODl5yeelFByzpGpqblc9_Jrp8_CAnc8ktocR1oH7u8,2974 +torch/include/torch/csrc/distributed/rpc/python_call.h,sha256=1bv2_SQ8WO3BLQ-zMvxolVxg3ArNg6toYV0ywRu3vGI,790 +torch/include/torch/csrc/distributed/rpc/python_functions.h,sha256=8PZagDa_TzingCPHkA5aGBKOXlofGBgZ4eZfJ13j-js,2307 +torch/include/torch/csrc/distributed/rpc/python_remote_call.h,sha256=t5bZ8LEPdFaExO1hjAB84XpPc2Y5PIMbx_pivlmPo9E,1184 +torch/include/torch/csrc/distributed/rpc/python_resp.h,sha256=O5D6odFJ7rq6eSS_Fi1-C0ZcvVo0LjRH6zeFpYUcsRo,671 +torch/include/torch/csrc/distributed/rpc/python_rpc_handler.h,sha256=K8Qj9yBgc3bZkm7deYH-GBtTJp-eLVrKvwb9lTmJ1Bc,5004 +torch/include/torch/csrc/distributed/rpc/request_callback.h,sha256=4-1Sw97hE7yz9R37u9zl-uLBy7ta79e__aJxhbWilrA,1276 +torch/include/torch/csrc/distributed/rpc/request_callback_impl.h,sha256=P-mVdApnXGcv_y8DLV_6Ph1TayWQ1enHNyvwb_I9-Ng,2083 +torch/include/torch/csrc/distributed/rpc/request_callback_no_python.h,sha256=9J1RGGdk15tVTrL5uagB8YmeQLTXwJBYUPdf0RGuAb8,3884 +torch/include/torch/csrc/distributed/rpc/rpc.h,sha256=N4T_NaiHmxQeggJ6YGReFOmn-wCGETZtAH73cA6EhLU,214 +torch/include/torch/csrc/distributed/rpc/rpc_agent.h,sha256=kqT5bqHLqgobqYaO5oux8SnHH8jA5BfOgw8KukjUN90,13455 +torch/include/torch/csrc/distributed/rpc/rpc_command_base.h,sha256=Ob5xrnMaMwDaUQJ3qhqL-6FZTlWoHI8r6CJnRTN-l0c,728 +torch/include/torch/csrc/distributed/rpc/rref_context.h,sha256=Tnnm_juvLcIk1jQAZRDq6bvMDKgtoP9GDIw2uMmRDSE,15829 +torch/include/torch/csrc/distributed/rpc/rref_impl.h,sha256=fQ4lJ7Ijv52m5VxftqCounwEa4xMUzhqRMkAblh5Sds,16159 +torch/include/torch/csrc/distributed/rpc/rref_proto.h,sha256=KinBpxjMtL0tJUCLI9LfKigZA8gZLBY1IYsprPHJbDo,5290 +torch/include/torch/csrc/distributed/rpc/script_call.h,sha256=2FZh-ZZTT7Kik4zdRUh9nYqSaU536VprEpEc9qavoMA,2527 +torch/include/torch/csrc/distributed/rpc/script_remote_call.h,sha256=WV-k6jQJ_tjJzxgs_ZI6fyg16BLxctgIrubBrnuX73E,1652 +torch/include/torch/csrc/distributed/rpc/script_resp.h,sha256=hMiCaxdFPYYGYFOaRRNOd-tTvNrD1T36iv-7AkwJIP0,678 +torch/include/torch/csrc/distributed/rpc/tensorpipe_agent.h,sha256=LSIuGtoRYl3rCy4BJHRgpMpMBMPexuiufgs2l6_iTfQ,17425 +torch/include/torch/csrc/distributed/rpc/tensorpipe_utils.h,sha256=Cr_3OOMpvyF0C5Uv23EEEoGvVCKXVkhSz8PE40K6pRw,4761 +torch/include/torch/csrc/distributed/rpc/torchscript_functions.h,sha256=K0HI8ZzP5aVn-TLRAU-vPP6b0wdZry5ZLtKHO8_DAV0,1707 +torch/include/torch/csrc/distributed/rpc/types.h,sha256=2KJn9XcBlAW-yiooYMO6RhmIgWup6Th5cRT-b8lhq7Q,1720 +torch/include/torch/csrc/distributed/rpc/unpickled_python_call.h,sha256=IZIuhgkohRn4Mt0REj3pwcTj4MC5p3OYkS9DXHo3I-U,1367 +torch/include/torch/csrc/distributed/rpc/unpickled_python_remote_call.h,sha256=yEFoq8rsnBFPy_9gvzQ25oukqoV7KX_S5RqutvfUrQw,1257 +torch/include/torch/csrc/distributed/rpc/utils.h,sha256=bpmEULAaBqiQXZ_om3jMieazn63WWndj-vLbzl_j9M4,3840 +torch/include/torch/csrc/dynamo/cache_entry.h,sha256=zjm21DCURtx8COP8_PEdhV6BdF7pjvC0hX__HMSdmRk,1605 +torch/include/torch/csrc/dynamo/compiled_autograd.h,sha256=hc4fb6LO8dL9cpwIJ0Es3sk7dzfPqMbaeavKVJbS7sQ,20683 +torch/include/torch/csrc/dynamo/cpp_shim.h,sha256=6a8TJKtkFG1PUMiE4-CmkRNSmrbHi7IWmiGn49yEb8o,357 +torch/include/torch/csrc/dynamo/cpython_defs.h,sha256=l9EsmSzRhW9dBygsZthao89ni_2bRuFWlSOm2NTF8-Q,539 +torch/include/torch/csrc/dynamo/debug_macros.h,sha256=GLgfjJgLtCrU3XiKHbn4Iui757ZkHotdJkFN0Uc9bwg,1474 +torch/include/torch/csrc/dynamo/eval_frame.h,sha256=E_GkS9vOzpIaTH15YpFAfw7Pf-q6JG19wf4R7um9-RY,97 +torch/include/torch/csrc/dynamo/extra_state.h,sha256=L59lZDBy58Xf6xHmr5ayenWJ4Hcb7ODw1_Gzp5fZwBg,4408 +torch/include/torch/csrc/dynamo/guards.h,sha256=ldc_4mwpgjLNawNtaK-XilkAq9jRkDzTbkwv9eJl20w,93 +torch/include/torch/csrc/dynamo/init.h,sha256=sOvnH_5t9F-mHJDA2jIqDPtIXQlZm6R35GAMxe9U-2Y,219 +torch/include/torch/csrc/dynamo/python_compiled_autograd.h,sha256=dFWRhXaGLZEKOxIRw_8aJK_qTrhZkEf8iUOAmg2a7PU,215 +torch/include/torch/csrc/dynamo/utils.h,sha256=56qNFK9kiNNUdGKqv5JmJ8uWUJhOKxV0giT_UYJ6kWY,283 +torch/include/torch/csrc/inductor/aoti_runner/model_container_runner.h,sha256=znqTCKcR8IVvcVpKvnCULtTh32z_u1EwqZD9fNrbGpc,3172 +torch/include/torch/csrc/inductor/aoti_runner/model_container_runner_cpu.h,sha256=XgmR_Qd3JWNLa8vYG0sELcPbnfHbDNWpONlslyVSQfg,489 +torch/include/torch/csrc/inductor/aoti_runner/model_container_runner_cuda.h,sha256=T-t2cPRW9s8aeJRCk3tnq6GzrWGPzIpt3DRDpli3Krg,927 +torch/include/torch/csrc/inductor/aoti_runner/pybind.h,sha256=9qh4-fASrKhHGajRPRFIPbyarL0evSWaK-LeL2HaZf8,148 +torch/include/torch/csrc/inductor/aoti_runtime/arrayref_tensor.h,sha256=M9eUkVRcTZJXpSdWqTU3mmjxIlkH7zQuCLxhFPVYjiY,9897 +torch/include/torch/csrc/inductor/aoti_runtime/device_utils.h,sha256=nf7kENi6HWJMPpcCphBTGGebAq7c_zhfTVNa2QJ7vPE,1553 +torch/include/torch/csrc/inductor/aoti_runtime/interface.h,sha256=5CfC69ajsaTCtlp-IJNmdrkk6C9HSIiLMujcgv-hWhw,7549 +torch/include/torch/csrc/inductor/aoti_runtime/model.h,sha256=kFP0n7sKDe7IjfEamciEQ_oE657oOX-4vUzRjdXs0QM,15920 +torch/include/torch/csrc/inductor/aoti_runtime/model_container.h,sha256=pdjGb4jeZ25p2vO80OPWMWsefGp1ZFDzMV_w-AuSfE8,17330 +torch/include/torch/csrc/inductor/aoti_runtime/scalar_to_tensor.h,sha256=Yell-wuEx6lwfxgS38jVLPFdCvO9z4_yTEDr8Dx_Px8,1459 +torch/include/torch/csrc/inductor/aoti_runtime/thread_local.h,sha256=5hwelwk_XNosWgGmr608m6kmWHRvN_w1qKA-6mRmDxQ,4240 +torch/include/torch/csrc/inductor/aoti_runtime/utils.h,sha256=TfGepJx2z7_hA3KVbWBxOMEo4nKI96ZQpy5R4tahw4A,4781 +torch/include/torch/csrc/inductor/aoti_runtime/utils_cuda.h,sha256=lWQLHVCdJixcu7JKZLjvQ8dKM50H7YgrJqmjn_yRfCE,1713 +torch/include/torch/csrc/inductor/aoti_torch/c/shim.h,sha256=RaKfgzFqfuRUEL9wBo9jH6WPzTIAHmBIfBF1SuUSIXE,20598 +torch/include/torch/csrc/inductor/aoti_torch/generated/c_shim_cpu.h,sha256=TWhXiBR9gkBdgmY4S84oyC2XNWON89Pu0r3VIdoDBXU,248788 +torch/include/torch/csrc/inductor/aoti_torch/generated/c_shim_cuda.h,sha256=gW4fa4Spy0hT9sJw0ecCe9-heP_J1MWOLgwZYgSLZN0,265564 +torch/include/torch/csrc/inductor/aoti_torch/proxy_executor.h,sha256=82JGBwnR7TZVr8EfjKP_uTjdKt-71EzCouFTB4MKgdM,492 +torch/include/torch/csrc/inductor/aoti_torch/tensor_converter.h,sha256=365yTy54o4b4BmBx6fipedfDTnmi6WPhmZ8-6tYzQ3c,1351 +torch/include/torch/csrc/inductor/aoti_torch/utils.h,sha256=FiUPamWb9wbxwrVVKtgXyGiLpbsCES9bY9oYK9dShyo,4564 +torch/include/torch/csrc/inductor/inductor_ops.h,sha256=twizse1MiD7FKxU5mt9crYW-MfHVj2yiRYD1Vium9wE,798 +torch/include/torch/csrc/itt_wrapper.h,sha256=eCw9u1gl7vzf92sSxqO7WrEc0rhmVBW5cydUc2r_c3k,320 +torch/include/torch/csrc/jit/api/compilation_unit.h,sha256=WIL8gBuLNyDUT_YQn3DHj-sg7rit5k_GEJuBiA9X1kw,11708 +torch/include/torch/csrc/jit/api/function_impl.h,sha256=YmS_2-wbCsJ8vyOZq-w9ZQPx3w6SuK4yAtxvZAEW7PM,5705 +torch/include/torch/csrc/jit/api/method.h,sha256=sS0T0BQZ4ZZiO0lGh5xdmsW_Q3vIFaGUNWH0O8770BA,2370 +torch/include/torch/csrc/jit/api/module.h,sha256=aAf_EOkBBd9ytJ9tImFr5-iq725yGDMt-Lw3ZYI6sow,23633 +torch/include/torch/csrc/jit/api/object.h,sha256=EowprhMikdDkZZYYYeb7Nm8FPxE3bbOQbuZR3eo-Fmk,6074 +torch/include/torch/csrc/jit/backends/backend.h,sha256=xDYuoy_lXkz4x7kY0SaBVjG5VFun4DcW3X7m2LLPVXA,4060 +torch/include/torch/csrc/jit/backends/backend_debug_handler.h,sha256=TZD8_Eh1PHjAAvOMbC5--eBNGHO5NkhEaeGUvJ18KeY,6332 +torch/include/torch/csrc/jit/backends/backend_debug_info.h,sha256=kyVKooxs8i3KpU61nkyqQvPgqBrBXVn8ngsuEuB1tDg,2338 +torch/include/torch/csrc/jit/backends/backend_detail.h,sha256=3Vwqochwvvj1Hx_gOf2fQX-tIB-LyLfQV3d9bVffXFI,1104 +torch/include/torch/csrc/jit/backends/backend_exception.h,sha256=TkQle7sRjMI5lqbkadTp9Sme_CyI8iMWJyQSOPK0mDw,2085 +torch/include/torch/csrc/jit/backends/backend_init.h,sha256=oO64G0Ay0hdQtUeGSgXccDAWxSZ49bw_0wKNahGjM-A,277 +torch/include/torch/csrc/jit/backends/backend_interface.h,sha256=hMNGdVeLdZuOSTPMlTlqoT1hnWrq7UuwsOLcGr4jp_8,1184 +torch/include/torch/csrc/jit/backends/backend_preprocess.h,sha256=VfwbX1X0kyR50iKhCqbsdrp8a43AYaEMpIC6VxD51DA,438 +torch/include/torch/csrc/jit/backends/backend_resolver.h,sha256=fcuqo_lthD5E7OM7nY57kLXUNzMTiMcAe0GPpr1L9qE,277 +torch/include/torch/csrc/jit/codegen/cuda/interface.h,sha256=wT2NC-AX4H16CeKIs8moB7revz07jSlZ8LtaoJ13xdU,1929 +torch/include/torch/csrc/jit/frontend/builtin_functions.h,sha256=AVlrJ-b0oVDOLO61-JPdz58odNIX4ZKzWgQPodF2qS4,240 +torch/include/torch/csrc/jit/frontend/canonicalize_modified_loop.h,sha256=KDS5czTQZUWkzlEp9XWnfi_iGkrf1tz1c5tR5VBA6XE,312 +torch/include/torch/csrc/jit/frontend/concrete_module_type.h,sha256=ucw3LZttusKvyS30p2m1RTyqS_efrR4qAZjOPZWFlOw,9062 +torch/include/torch/csrc/jit/frontend/convert_to_ssa.h,sha256=R0qk8fX4o8qqoZChkzL1O-0w_Pqi9yLos1N94l1zINo,327 +torch/include/torch/csrc/jit/frontend/edit_distance.h,sha256=hm4zRJY_rs1ictYlvmm9yzqNe0_pJHiDBam8ZET6I-k,254 +torch/include/torch/csrc/jit/frontend/error_report.h,sha256=K0HHBIcTvXMQKQaSvDJCxnp1oArhPLDqv-3Zscxc4rM,1485 +torch/include/torch/csrc/jit/frontend/exit_transforms.h,sha256=_e0F3TGVaSwWOEqyxAFLiq38HI7efc0DF6zHW21U7tA,218 +torch/include/torch/csrc/jit/frontend/function_schema_parser.h,sha256=eBBIiNTDxFE2LJUycMeAmRGfm8VM3vzqCTfugsZVVWg,452 +torch/include/torch/csrc/jit/frontend/inline_loop_condition.h,sha256=h8ReUR0lKOWoGr8lqFai3wXpr73KsRl_-_CYm_ymmzM,352 +torch/include/torch/csrc/jit/frontend/ir_emitter.h,sha256=VLPmvzzJjQ0JcVDcWzHF-1Ey1UhwxYuEdzh3YvW7Ws4,541 +torch/include/torch/csrc/jit/frontend/lexer.h,sha256=pv7gIjoEMOCruRa_dlui94qrvzP-n-X1-1myxWQEawI,19249 +torch/include/torch/csrc/jit/frontend/mini_environment.h,sha256=pJjTC59f5wTwfx34DrhgDdhC_EnvmgSR_t7xdn5A3G8,1400 +torch/include/torch/csrc/jit/frontend/name_mangler.h,sha256=WZ0hpgm_eCuCz4vjG8TBoIe6tcQsNdoavAu6zfHHoas,655 +torch/include/torch/csrc/jit/frontend/parse_string_literal.h,sha256=Cvmixjh0Y3L4tJetodepR5wCivpNqG3QabyzxIlYMPk,2295 +torch/include/torch/csrc/jit/frontend/parser.h,sha256=sVpCoMJTlmElqG-8u3p-zu0gI8sMq4eTZr2wG9aZPp8,674 +torch/include/torch/csrc/jit/frontend/parser_constants.h,sha256=ENeKl7-wM4ljDf2sR_qynnnCke8d4YrCyxKxM5OmSwc,162 +torch/include/torch/csrc/jit/frontend/resolver.h,sha256=trmkoyBkAYPjpFaoiFRzrRoy2T2EsFjQ0dfLq1HX6OM,1982 +torch/include/torch/csrc/jit/frontend/schema_matching.h,sha256=FHsOUlG32SmTxAtdzrzR_qiICc-nCgMGP0NOhOlzA0M,2133 +torch/include/torch/csrc/jit/frontend/schema_type_parser.h,sha256=sm4sYiuNkTRR5L1DhEPYhLJlzfjD3QjUgHVYaW_RVrk,1113 +torch/include/torch/csrc/jit/frontend/script_type_parser.h,sha256=b-h83jh5VK4LOl4eAPJck2Rx27lz8I5xOVhKZ2hd6ME,1605 +torch/include/torch/csrc/jit/frontend/source_range.h,sha256=AnncLITSqDtdmYT5DUaoWvghAdPQhIjzlk90SUxl64g,12886 +torch/include/torch/csrc/jit/frontend/source_ref.h,sha256=mQU6_nrLmy8_zun717SNW5zEk2HinnWka-IulgKRzx8,1319 +torch/include/torch/csrc/jit/frontend/strtod.h,sha256=pXNpI58EBYdQ3B43FJ2TRkmlVHfz8BNAK6jytZOq8Cc,241 +torch/include/torch/csrc/jit/frontend/sugared_value.h,sha256=SxoXU8IJAala8uBSxD1f5tSWKfzCSvxdRwtb4tERvhI,27854 +torch/include/torch/csrc/jit/frontend/tracer.h,sha256=VqC8Dqm3nGBLMJgS55rl7POoea1Zugrct07D9667q5g,12798 +torch/include/torch/csrc/jit/frontend/tree.h,sha256=Hwx3oiz_Kup-c2ifkPXAKIqATBO0pMMT1IZqG2CCkGw,6629 +torch/include/torch/csrc/jit/frontend/tree_views.h,sha256=RgPY077JgUQxPUGePV8va8IWS-D4OuqxEmfJW4CHzUI,37251 +torch/include/torch/csrc/jit/frontend/versioned_symbols.h,sha256=xXzAecqTP-NZNhpiTNaj6m3FB0RNFMBXFbPFckccTac,620 +torch/include/torch/csrc/jit/ir/alias_analysis.h,sha256=msqO1uNUHsicIEfw_zIVEpAPSRkRtijzVTZ7j-3vQtc,12850 +torch/include/torch/csrc/jit/ir/attributes.h,sha256=LPBugSzeY71fM8aRZVxa0iDQxDnJBC1R9TT5wxeCpb8,4929 +torch/include/torch/csrc/jit/ir/constants.h,sha256=qAC1OnN_rm-8xH_4juy7AOnZdsYFPwczzVdgA2kAMY4,2032 +torch/include/torch/csrc/jit/ir/graph_node_list.h,sha256=ROrVM01XWiDtqL8s4SuTTZ8QTt1-iH0B8e90VhU_VZE,6379 +torch/include/torch/csrc/jit/ir/graph_utils.h,sha256=fGLGBLy7HdGihSpojxmzUD_8G4apDLx2_RtIicwXnaI,529 +torch/include/torch/csrc/jit/ir/ir.h,sha256=iuMYymBN_AF7rkBd5R9SK0M0fgsYke6CNmaS9FahSqg,54292 +torch/include/torch/csrc/jit/ir/ir_views.h,sha256=jrgHLunPvnr0xgp5_wnHZ-C20pO5NKXcvTVAVDzKqHo,4648 +torch/include/torch/csrc/jit/ir/irparser.h,sha256=yGP_Lk9W6HQzdG46CO-FUsO3VRupORJUrhqGlbmTu54,1163 +torch/include/torch/csrc/jit/ir/named_value.h,sha256=J4DYk967jjDBO1trFk6aW_aoaKR4OIY0fl-4e70i9UI,2434 +torch/include/torch/csrc/jit/ir/node_hashing.h,sha256=YFHiWACcNrteucwRCbQuBqwo0bQ6vPaatKkCS0Sb1kk,290 +torch/include/torch/csrc/jit/ir/scope.h,sha256=5GHfy_ImrNC3HALRK6A9koS5eh9seIo3KsAXGTMvhBM,7184 +torch/include/torch/csrc/jit/ir/subgraph_matcher.h,sha256=OjnS2hW2wVTE9bEtceHHLYDnKDXdf9WjhhN6JIJsxaQ,3151 +torch/include/torch/csrc/jit/ir/type_hashing.h,sha256=SKEP-8m8LiQ2SKbCsW5jcc6SUBaNuJe84ffZgZeMf_c,449 +torch/include/torch/csrc/jit/jit_log.h,sha256=2p4Ppro1HDAmnxlM47hngRqg6FfCQU5T__uV8MAm99k,4798 +torch/include/torch/csrc/jit/jit_opt_limit.h,sha256=3OVvSgL6igVN0RBsYvr4zbh8I5TXfVE19Z_6jyRnd9A,1406 +torch/include/torch/csrc/jit/mobile/code.h,sha256=62BWHvvHgPV_pnoW-SBPhuUKZdIuubijOFSsL9C_QLw,1186 +torch/include/torch/csrc/jit/mobile/debug_info.h,sha256=NcSePALty2KoLYfTv0MxV4KTXeo4QUNO836vMOH-1Y4,2230 +torch/include/torch/csrc/jit/mobile/file_format.h,sha256=clDM2z4imtoQhsBtmJ-rhKSrx2PzZsqIKpePscxRYzk,6632 +torch/include/torch/csrc/jit/mobile/flatbuffer_loader.h,sha256=zYDQ1pUpGjKh5DoDmoS_GMy7RzL3hLs6QX4ieT2g33s,4999 +torch/include/torch/csrc/jit/mobile/frame.h,sha256=kwuJkqJgEXcf250eDsvsH158dDnHU8Gtq897jfIFI7M,872 +torch/include/torch/csrc/jit/mobile/function.h,sha256=JI0VdmPN2Cqc_hNDUkDl9cVP3l54pdNCYv7Njya7lSA,2900 +torch/include/torch/csrc/jit/mobile/import.h,sha256=9apUoiMBiKpO-Fvq6Xp0WezxhQAKEfT4o85JHyd7-Es,3937 +torch/include/torch/csrc/jit/mobile/import_data.h,sha256=69bhaeCTEbcK_L6ttdN96VAJlnyLOCE7ks7mDDiwLjo,1031 +torch/include/torch/csrc/jit/mobile/import_export_common.h,sha256=YxBhRTweGOwndHx51WdgG8p-zwiW1ciVq5xQKtIP4lA,554 +torch/include/torch/csrc/jit/mobile/interpreter.h,sha256=HEQ5f8LM3wbjCpCbbO2pcXaqsycRegY0VfHyZ0jeyak,688 +torch/include/torch/csrc/jit/mobile/method.h,sha256=2MU0r3XL3q2QQMSSLRsjiXG-4Z99L7xdWPnLsFYN5oA,874 +torch/include/torch/csrc/jit/mobile/module.h,sha256=ePtNzhIiVIDz5QQP8v2T8p6gqWi1aH3NgsTcaQxIM8o,5977 +torch/include/torch/csrc/jit/mobile/observer.h,sha256=GhQYLhyUPbiIkVzBO2PcZRyo44G8yIoVwtLEzZ5iaLY,3637 +torch/include/torch/csrc/jit/mobile/parse_bytecode.h,sha256=pCwodDUGgtuCT7B04ekzdQuL-del6GFM_J96lMQLr2g,790 +torch/include/torch/csrc/jit/mobile/parse_operators.h,sha256=Jc3g63GerzBC2WRNw0J_FOOwE-paeyFhVqB2R-lSN1Y,734 +torch/include/torch/csrc/jit/mobile/prim_ops_registery.h,sha256=ggZkB-iiTO0RMW1ztdKNbmTaVy6eKOZc1W3gMxegQzw,645 +torch/include/torch/csrc/jit/mobile/profiler_edge.h,sha256=w9NwGZ3w45Su6RUxyWYPszzrgSW81H8ZRClbJFgFzBc,4538 +torch/include/torch/csrc/jit/mobile/promoted_prim_ops.h,sha256=2U3bNnj7C8Ypwc5qbE5bFwz-3jUCRVLiXYRSsKXzT48,1068 +torch/include/torch/csrc/jit/mobile/quantization.h,sha256=JALhO7vuLyehdCe5ecPAbi_X-WePiAqzoYUl3u_mrKU,1288 +torch/include/torch/csrc/jit/mobile/register_ops_common_utils.h,sha256=6t9gPu09zWRXoMNIUCWdFvUqWuSmZsLajsNEwLoSI1E,1683 +torch/include/torch/csrc/jit/mobile/type_parser.h,sha256=SHCUMNas3tT6nlP66FwPGAoXo0rYsUKhaLCVaM7amqg,1443 +torch/include/torch/csrc/jit/mobile/upgrader_mobile.h,sha256=gEz8k62qjg2D9wxsfKD4FA4NmkNCXwNvodfpQKk4VLY,981 +torch/include/torch/csrc/jit/passes/add_if_then_else.h,sha256=DAC6-vToJ6fqyDhCvW78_3xSrMS3SAjsMqJTvb20O9M,188 +torch/include/torch/csrc/jit/passes/annotate_warns.h,sha256=KKMFM5nOCeVUKI6x9Kx223EEfUU5uM5kxJc9SZtBE_Y,192 +torch/include/torch/csrc/jit/passes/autocast.h,sha256=yFwOAQHPjDG8Zl_N0VkzmNGyX3Lnfx3eHfVose3D9cY,267 +torch/include/torch/csrc/jit/passes/bailout_graph.h,sha256=_N5B_8WJZ9OdHgGnKuPBiCqoxzlO54Y_k3SflT1WTQ0,1115 +torch/include/torch/csrc/jit/passes/batch_mm.h,sha256=x6DsjOKNXdXaQ_EVz9FKqf281Mmcn_SlA8LR2AVKikk,163 +torch/include/torch/csrc/jit/passes/canonicalize.h,sha256=ZEyVhzOh93JtrRAhb0sAkiH-KuZjVrYNAqL5Tn7oST4,492 +torch/include/torch/csrc/jit/passes/canonicalize_graph_fuser_ops.h,sha256=JRZ3Ldx0_3FUSVJ78o6yOVY6R7QL61vKMjyhZunwuv8,177 +torch/include/torch/csrc/jit/passes/check_strict_fusion.h,sha256=LE5ekWMi5KGUqh2ipZu7gHNd9fam3klyXmdpuNV2HHo,191 +torch/include/torch/csrc/jit/passes/clear_profiling.h,sha256=-7lka-w2NHHFaerEJfhkYor7wbgLMM8KYR_hlddKw_o,493 +torch/include/torch/csrc/jit/passes/clear_undefinedness.h,sha256=R3EOnJ2wgDGo3we5MJMA0loCWMGcHHlm8oBdwcj_HtQ,875 +torch/include/torch/csrc/jit/passes/common_subexpression_elimination.h,sha256=z7IfjAQ-MGLf5HIehx4nAl4XovJz0lp_Y4mmfIK0g3s,194 +torch/include/torch/csrc/jit/passes/concat_opt.h,sha256=wHxXr7R_NTiKqG_SH3wIdQXJLldX24uwbYXd0Ftgiw4,550 +torch/include/torch/csrc/jit/passes/constant_pooling.h,sha256=N1a2ZiNietyOW2zvh4tSQDsdUYMaUzqla0kLVcd5QP0,177 +torch/include/torch/csrc/jit/passes/constant_propagation.h,sha256=1j-kQDzw_opHRRk57bQl8dP5AF7g8jM_EudrssU5ecU,1314 +torch/include/torch/csrc/jit/passes/create_autodiff_subgraphs.h,sha256=ZPUno0m-_ig3FWPau-Gu9YYaJT4gpqPmhZNCBlZDjpk,538 +torch/include/torch/csrc/jit/passes/create_functional_graphs.h,sha256=23H8y-a2uENpTHKTKZgR6qyIGtsHQKRu2uq-zEBdih4,309 +torch/include/torch/csrc/jit/passes/dead_code_elimination.h,sha256=qCIO97-UVqUaVmO9TyFEt_Mh-oq2unIM-J96Y3_0YbI,1584 +torch/include/torch/csrc/jit/passes/decompose_ops.h,sha256=9DiAUdCsDCp2tvCNck4UQR5A3U8An4bQuS8LTyubXKI,168 +torch/include/torch/csrc/jit/passes/device_type_analysis.h,sha256=IgrD5iDdKcjyoV8XMLb7KewwT5KhVt-CHk-FqkmEOEw,267 +torch/include/torch/csrc/jit/passes/dtype_analysis.h,sha256=9B7Y_vRJuZwXl-ZJYi8AUQlc7N6Czt4u8iA4PyXYcL0,414 +torch/include/torch/csrc/jit/passes/eliminate_no_ops.h,sha256=N5DsEvyhU0qBslYnpXFRvPZglSKB55Q3erS1MjBHpSo,517 +torch/include/torch/csrc/jit/passes/erase_number_types.h,sha256=yvp_ZBONBL3Xozskx_wm4B7hS7ypKxeILnLtpfKTQ7I,813 +torch/include/torch/csrc/jit/passes/fixup_trace_scope_blocks.h,sha256=U-HcU_4QjcksygXEtBVU1L13oS0C4KdEQ5GJ8JthB7U,1673 +torch/include/torch/csrc/jit/passes/fold_conv_bn.h,sha256=xb32jMMakR_ffR57TLS9g4OCBwREFWdPy3y35roa_ps,995 +torch/include/torch/csrc/jit/passes/fold_linear_bn.h,sha256=hW-uQYBv1a1i14Tdk52iOEtWylD-euOXo8oPzrDkiPw,691 +torch/include/torch/csrc/jit/passes/freeze_module.h,sha256=vw0opmLQ8AibD97GDtBCwm0bjBjA_a59xXLVW4wom5Y,1244 +torch/include/torch/csrc/jit/passes/frozen_concat_linear.h,sha256=Fdv0Z583wh9P1Ihq36kJ_f3GLpMcYRLlP4u-TANvmrg,277 +torch/include/torch/csrc/jit/passes/frozen_conv_add_relu_fusion.h,sha256=YBS8fWI79Kur0B2Znhh6nJNJ3L2lO7exOX4ZvDaMpwg,329 +torch/include/torch/csrc/jit/passes/frozen_conv_folding.h,sha256=5xHxXQaNmMTPdXN_G3-EdI3pE7SY5Z_MageAzgGI6hg,872 +torch/include/torch/csrc/jit/passes/frozen_graph_optimizations.h,sha256=UVQJPftcQHum-aAWrqel1lbvTuG4hHdKIxn99d8XHT8,466 +torch/include/torch/csrc/jit/passes/frozen_linear_folding.h,sha256=BNXMiKccojRWescayYkJkSQ-Aw5417JYiWQYdNHrDbU,370 +torch/include/torch/csrc/jit/passes/frozen_linear_transpose.h,sha256=7LvwiTSd1qMiJmGzO32Ctu7SYvxxN7ID2obA52JjNn8,286 +torch/include/torch/csrc/jit/passes/frozen_ops_to_mkldnn.h,sha256=zl66-XDYCQz5VMjOD80CkBNThHRtUi6MpTOMyNqPJ0o,414 +torch/include/torch/csrc/jit/passes/fuse_linear.h,sha256=gWla8he_7p2nhpOTClUukGPUueF_g7uumqJSC2XkyK0,768 +torch/include/torch/csrc/jit/passes/fuse_relu.h,sha256=hVpx9P8NMSHI5IlJWKSpNEfyatDQu1nvyD1TjABKxrU,273 +torch/include/torch/csrc/jit/passes/graph_fuser.h,sha256=B9J7gGOT6S-9UXb-ltZg5FOSvofsJmD5VrEAOKz8mHc,1251 +torch/include/torch/csrc/jit/passes/graph_rewrite_helper.h,sha256=wPXekaV5ck3jXNQSZlnuB56t2-qzYCZo_LjJrZKE5_8,1785 +torch/include/torch/csrc/jit/passes/guard_elimination.h,sha256=IOvzzo6_RvAthO1dhIYG-iIAv_MOGmBDHwAtenxQAy4,376 +torch/include/torch/csrc/jit/passes/hoist_conv_packed_params.h,sha256=RPdZCCa3I91wwEBruCktQgdtFT_skrNuaHAbVXwRpTI,211 +torch/include/torch/csrc/jit/passes/inline_autodiff_subgraphs.h,sha256=H5j-cg-2ky6V-m57XOMhLX0zdBI7w8ANRI2B5Z33kJY,275 +torch/include/torch/csrc/jit/passes/inline_fork_wait.h,sha256=REGVjC2nZkSpOcU3VOjTrw6zF_eZwZJxusr29UYQTsk,547 +torch/include/torch/csrc/jit/passes/inline_forked_closures.h,sha256=mhDh_9YO33vqMeqa9QsmNMQHxv20uIUO1WuGW2cdvBo,227 +torch/include/torch/csrc/jit/passes/inliner.h,sha256=ZBquqjU2bC7v0byu_sV4Od74jTZyCh8W79_F0_Gu1x4,254 +torch/include/torch/csrc/jit/passes/inplace_check.h,sha256=xijQSXw2abZOHPa_uLlXIvbSpzeK0cVmStxC7ahL04g,168 +torch/include/torch/csrc/jit/passes/insert_guards.h,sha256=oXa4a7QXBbPJDriOCJqC64tViTScnHbN5udldzv9Je4,439 +torch/include/torch/csrc/jit/passes/integer_value_refinement.h,sha256=N5jGBQswN7vU8fMv09tUxDq1E7oR81L9697fz9DH-yw,234 +torch/include/torch/csrc/jit/passes/lift_closures.h,sha256=6RyzKF8TFcBVUMNoqKlmxGFQrSj8DhHldVGJCs3dI1M,222 +torch/include/torch/csrc/jit/passes/liveness.h,sha256=IYGAyOoJX00fvvPlpBjBNr7RYVk_vVB95QYHRye3fEc,649 +torch/include/torch/csrc/jit/passes/loop_unrolling.h,sha256=qI1uHjW9dgWoGa_iZY_4-VhT0gGli6KY8MqWk7b-4GA,1006 +torch/include/torch/csrc/jit/passes/lower_grad_of.h,sha256=lQlKvI1LTZ5jSQp8VB7SkklnxoSLeTcRRoQQB0Gvt6M,348 +torch/include/torch/csrc/jit/passes/lower_graph.h,sha256=HKZxM64wjqRanSbpfLfBJATMpgTDGhFGSZt0pgKu67k,750 +torch/include/torch/csrc/jit/passes/lower_tuples.h,sha256=-LvG4dIykeTo4kSbPF5_zFlyBNfoi9vcOCa0gdLTjWs,666 +torch/include/torch/csrc/jit/passes/metal_rewrite.h,sha256=25_wn_jqFV151KKR7c7NcU62VysR4u0c6xLQGYV268Y,606 +torch/include/torch/csrc/jit/passes/mkldnn_rewrite.h,sha256=8MsnoMbkQT49r3IF6pSrQzkQIOpOP2wTNlFedRYvcD4,630 +torch/include/torch/csrc/jit/passes/mobile_optimizer_type.h,sha256=FkImh2z2c2osMwsZ-dCA8wQysofiETWhhZMbcDg54Ek,237 +torch/include/torch/csrc/jit/passes/normalize_ops.h,sha256=Le1kIVBt2PrVmUG1i5Cf-U2ueWGbFKBD_RgIEgqhVXg,536 +torch/include/torch/csrc/jit/passes/onednn_graph_fuser.h,sha256=rCzyjTE1-mcYOVqYmptlgpEuT1TstYOxwvXtbkVtbHE,1448 +torch/include/torch/csrc/jit/passes/onnx.h,sha256=N3n2zcTYshoDjiSe8039jm5QZYKoS_jGwezIQGd3fnk,867 +torch/include/torch/csrc/jit/passes/pass_manager.h,sha256=3BQsxmJ8XOJMIMEZcGJmrI3uR8IPfoOvwB7-EPGt45Y,4574 +torch/include/torch/csrc/jit/passes/peephole.h,sha256=yqP0A71Mwk5xZKGkwOdLbz4RgIQJ8nFvwWOvDzaUNgw,507 +torch/include/torch/csrc/jit/passes/peephole_alias_sensitive.h,sha256=nfw9Xwcc-zhyIgnTsV2TWJrWxCHA0rRcHRwlpi8fc4g,435 +torch/include/torch/csrc/jit/passes/peephole_dict_idioms.h,sha256=NaZa85lCmoaqYSYwwypKKscSSeAIASgPy1V4XNOcTWI,1000 +torch/include/torch/csrc/jit/passes/peephole_list_idioms.h,sha256=__Zp475tWI1tSo8fzTqx3O5RX4ZuRJTfzGlK_yNPKWM,2003 +torch/include/torch/csrc/jit/passes/peephole_non_tensor.h,sha256=ZGpoLEljNMx6pKctfy-vWCgJfZ1HX87qIgOsmwPSZNQ,342 +torch/include/torch/csrc/jit/passes/prepack_folding.h,sha256=aQa61BMSpx4GgU6KpCVyC4wLSEVGmM_FDxxnEjkRmyo,358 +torch/include/torch/csrc/jit/passes/quantization/dedup_module_uses.h,sha256=BO4QlaPSdH1I37kIrdUi88CDoLDm3MYaKY-7YjMFNGI,826 +torch/include/torch/csrc/jit/passes/quantization/finalize.h,sha256=QEDufBsyjHdBm0rYP-yTAIQi7sRdRLUAEc0UEWMmUjw,2321 +torch/include/torch/csrc/jit/passes/quantization/fusion_passes.h,sha256=uDbKWQfLMcdtJt4H-1h-V4JCT8mKzKx6cAtxb5FtxkU,191 +torch/include/torch/csrc/jit/passes/quantization/helper.h,sha256=cBVttmlnIlkeUPDd2B3HYKbBM3mJSRrsZWgCIGep0to,7484 +torch/include/torch/csrc/jit/passes/quantization/insert_observers.h,sha256=3ebXPtSZOolJKgpNU__Y6lptAxl97EQVl3x5N4UoFOE,2351 +torch/include/torch/csrc/jit/passes/quantization/insert_quant_dequant.h,sha256=LHatNCh1b6fas9UPE0x9UxoAGJyoEWi1rxdSat6Olys,1450 +torch/include/torch/csrc/jit/passes/quantization/quantization_patterns.h,sha256=9jqgw4ptf0-ZoNlV-iucRJTO8TRE4An-6u8CLEM-380,53727 +torch/include/torch/csrc/jit/passes/quantization/quantization_type.h,sha256=UDgAy32Y3JJQUhZYoYo_qCA__SUbIdUThbBdQqGfOPw,358 +torch/include/torch/csrc/jit/passes/quantization/register_packed_params.h,sha256=XbD6rCZJx8Df4z6XnY-C1M4wNdaMOLuwxJCf63Jd2nA,514 +torch/include/torch/csrc/jit/passes/refine_tuple_types.h,sha256=AOglEl5zFs5GLygxXdZWIBvLY8E-euGUtOKr670dYRk,267 +torch/include/torch/csrc/jit/passes/remove_dropout.h,sha256=4gPkuN-LrDB-hGZOCnmeXiIvTjcPz6NT8bgUoVoC5ig,280 +torch/include/torch/csrc/jit/passes/remove_exceptions.h,sha256=uUw3Okrp0K27SoccPqlA8Wz2szkxS1bw3_X45pURZXc,954 +torch/include/torch/csrc/jit/passes/remove_expands.h,sha256=p1gyyUkdAl8paoIua_hIw7w9gZ6tbIOYYqkMND0ZVZM,175 +torch/include/torch/csrc/jit/passes/remove_inplace_ops.h,sha256=Jc9B6oTsIBXl_x7872GyBdbWiJjG_3a3TD24YsErM_g,296 +torch/include/torch/csrc/jit/passes/remove_mutation.h,sha256=NvKQoiaOIcamUsbl0xcS4VbYG2H3KC0hAeTkh-t7d5k,2631 +torch/include/torch/csrc/jit/passes/remove_redundant_profiles.h,sha256=nxTd7qnxpPSfwAQEGfwXyxGARygFcXEgGbFeOtazxw4,262 +torch/include/torch/csrc/jit/passes/replacement_of_old_operators.h,sha256=TcMUJonQnZL1TM8B8AACsWMQOE6r814c4AEmtHzgvoI,459 +torch/include/torch/csrc/jit/passes/requires_grad_analysis.h,sha256=NOk_n1Klny2BUbVGvbcUMXVD3ad3kpDx5IsR1w0g7rU,246 +torch/include/torch/csrc/jit/passes/restore_mutation.h,sha256=uU4DOi6WVSOX_KTFBWeR5SmMkhdzQdjQuJJnUjlupCs,1826 +torch/include/torch/csrc/jit/passes/shape_analysis.h,sha256=HpgZk6Gd-qy8YQEndmu3sgfchLVwJBI7Pmt_Ves0vYo,1102 +torch/include/torch/csrc/jit/passes/specialize_autogradzero.h,sha256=66bMvmBU5JN-2Xg6fpNquws9feQTGSWpnt_vJnldIaw,656 +torch/include/torch/csrc/jit/passes/subgraph_rewrite.h,sha256=l70yIPbM3Au9u8XwaVRLJXiIE4P2dRtbvrWcMD3axNc,4112 +torch/include/torch/csrc/jit/passes/symbolic_shape_analysis.h,sha256=dXM4whR8APwMqz0rjvFadetxOf4pAgnPqMTwrufKSO8,2103 +torch/include/torch/csrc/jit/passes/symbolic_shape_cache.h,sha256=s22J29bc3uK4DsS-DAKyqwbxIjNl60DKqC-TfTg-sS8,1599 +torch/include/torch/csrc/jit/passes/symbolic_shape_runtime_fusion.h,sha256=vLNAUTR8HLCPqoSoyuWZ5aq9piJ08aK6KmP-kIVHDPo,2390 +torch/include/torch/csrc/jit/passes/tensorexpr_fuser.h,sha256=OxcY1D8TT3wUcT-V9bOzj-wTnM8_nxF8dAfubGuwdf4,2625 +torch/include/torch/csrc/jit/passes/update_differentiable_graph_requires_grad.h,sha256=WNrA8iRJorDUG9Fsq3fVNMcLbJ0x0WuaQx4cSvFaefA,740 +torch/include/torch/csrc/jit/passes/utils/check_alias_annotation.h,sha256=pZafsHGeDV3cPTfJJubzUe20nGjb8Jsfe_pU7qaEFCY,612 +torch/include/torch/csrc/jit/passes/utils/memory_dag.h,sha256=Gi3vRkmoCyu4bjZ08Lf8L9vmCvurtM4NhlzRXCTbSMg,6427 +torch/include/torch/csrc/jit/passes/utils/op_registry.h,sha256=UoA-APAe_5BCuNBWKN-zGdUUbhF3jjEYIMwCezuasE8,1033 +torch/include/torch/csrc/jit/passes/utils/optimization_utils.h,sha256=rSeEsn9yWTqYUxLSiz-XOHfN3qmECg2fVnrhAl_Vef8,244 +torch/include/torch/csrc/jit/passes/utils/subgraph_utils.h,sha256=E_OlnMAVussYOgV2HzPZJ5Z0WBPOzS9Coqw5vDk0jlk,2411 +torch/include/torch/csrc/jit/passes/value_refinement_utils.h,sha256=IU0rQv9QGbyJ9WQP93Cj3euziCJjutrwObQizd9LWD8,2632 +torch/include/torch/csrc/jit/passes/variadic_ops.h,sha256=GUbzziWDOcJKqpxkqnPqhrNufRYtHm30IrG0lmvUuz4,910 +torch/include/torch/csrc/jit/passes/vulkan_rewrite.h,sha256=D_erZJaxM2nVOvVFWzoanVlKb57Ce40B__HVaToSX4k,698 +torch/include/torch/csrc/jit/passes/xnnpack_rewrite.h,sha256=9B0h-1dQL0OU4MxArPMiXEwNxlB_nB9deNOcW6BwEe0,820 +torch/include/torch/csrc/jit/python/init.h,sha256=pi94AbCTzGH47EW-u9kPDdRazf2RXwVKISlt6S3p8dY,143 +torch/include/torch/csrc/jit/python/module_python.h,sha256=UXIHhWTC99J3Oqh7NyoDfwukGuZ4vnZjSS-sLBgSGJY,960 +torch/include/torch/csrc/jit/python/pybind.h,sha256=McG2f_uxhUxBHOwkU_p40eKxwje8D7cFOHVayyS0dO8,7929 +torch/include/torch/csrc/jit/python/pybind_utils.h,sha256=iR2SVhgqSL-yDlzh8Rug0dbeQ3XhnbhUGqD4zEVRa40,39411 +torch/include/torch/csrc/jit/python/python_arg_flatten.h,sha256=-4yxueFeKLSCSDJO8zWm5nZfIWwNItwux0kXf_7jxZc,3527 +torch/include/torch/csrc/jit/python/python_custom_class.h,sha256=I-MFhM3ig0IiiVne9U84w0aqHrKRwl9MaCOGCtIfOPs,446 +torch/include/torch/csrc/jit/python/python_dict.h,sha256=rnifLBJFGqY5Xd8sQUw98yfJmvqegyq1kWcJ_yabHgY,3320 +torch/include/torch/csrc/jit/python/python_ir.h,sha256=42V5sIKri9OpVkXynDoBy6mCpynpHxKwfFyfKSXBDJI,1693 +torch/include/torch/csrc/jit/python/python_ivalue.h,sha256=Bp8NbUzfDwPkC_M7AcrC_DQTzOiaUoyu8_nHX0oi6nY,3261 +torch/include/torch/csrc/jit/python/python_list.h,sha256=gM2GdS5LCUW274tq1bqNPMr34hmHcLCmjOEhuhA14Fw,5423 +torch/include/torch/csrc/jit/python/python_sugared_value.h,sha256=h-M0INIQrTj7jdqwqwj0dEobZVYeBAQAmnt_inkGMb8,11253 +torch/include/torch/csrc/jit/python/python_tracer.h,sha256=lqc6qmwN1Z8NdBWZK3NxrF5U3GXEfEZZXyW3IcUQZ-M,1211 +torch/include/torch/csrc/jit/python/python_tree_views.h,sha256=yJkTxIBDBgYEkX-7zAjVE1ACKKBNXvBU9Kiq885knT0,150 +torch/include/torch/csrc/jit/python/script_init.h,sha256=-nyejY7PHUrX4O1LEs7W48ZifDvd_oMfucwL2vAndyg,152 +torch/include/torch/csrc/jit/python/update_graph_executor_opt.h,sha256=pdlOCRdZR5VsId6If4yEOtsN1zNtLDzzFT7fncH-B-U,185 +torch/include/torch/csrc/jit/python/utf8_decoding_ignore.h,sha256=rndEzjMH5efB3RbaWMpfujvNQUe3o2_mesOzreaJHPs,179 +torch/include/torch/csrc/jit/resource_guard.h,sha256=Jg6cRhnUGCe219SnaIkIkPNs-v99qUBsu0OKIXDzxCM,465 +torch/include/torch/csrc/jit/runtime/argument_spec.h,sha256=CHdWtjbHoqHyNrmI-1jtY1W_jQvWeFc1qtYaZap6Pbs,17001 +torch/include/torch/csrc/jit/runtime/autodiff.h,sha256=5apSR8BAAdifHGPPFeCsS4GpYstVS1EvAYbK_lsaQgc,3930 +torch/include/torch/csrc/jit/runtime/calculate_necessary_args.h,sha256=WQujo6Vy1MOEeHzKhO04AYoOAAztIHnIZJ2Om4eqg9Q,2281 +torch/include/torch/csrc/jit/runtime/custom_operator.h,sha256=x5Pj1v62Qg0-LNXzV3rMRxgerhRSfpwj8cu_bDRMgkE,1054 +torch/include/torch/csrc/jit/runtime/decomposition_registry.h,sha256=xoSz6G8uopLGqzno6BQBrdsTQ0lx8zu7HPMJFItDVrE,1045 +torch/include/torch/csrc/jit/runtime/decomposition_registry_util.h,sha256=vJ_K-8X9IaDOmrmwHNS79NxyyBlPdNcwH4NUbuvVS34,261 +torch/include/torch/csrc/jit/runtime/exception_message.h,sha256=HhV725zokG4hM07w-JpB6F2BLLoCoxwCjcYg2-Ccduw,614 +torch/include/torch/csrc/jit/runtime/graph_executor.h,sha256=0TdEws18179UcyY32Izlf8a4zVYb6t62LEGQ3xP_Pdk,4713 +torch/include/torch/csrc/jit/runtime/graph_executor_impl.h,sha256=CqADDMtS3pq2JEj1FdgsS4JZBoaid2g-w5Qr7i1IMeA,4027 +torch/include/torch/csrc/jit/runtime/graph_iterator.h,sha256=pSfARVvHC2XCw_p83DAuKxfLgvSJOgvkAB5dFXVE8LQ,4938 +torch/include/torch/csrc/jit/runtime/instruction.h,sha256=z1R5fLzff85MErdJopGVILbT-7Jii2ROWeRMoDSBoJ4,5621 +torch/include/torch/csrc/jit/runtime/interpreter.h,sha256=J953HrzcxH9BhwV_bO7K6emkL9_Rdw5x02CZxDYkkgg,5016 +torch/include/torch/csrc/jit/runtime/jit_exception.h,sha256=CFsv44op9BxpJ62xbTvodjFT-YIv5ZgLD-jbg8GyChw,1180 +torch/include/torch/csrc/jit/runtime/jit_trace.h,sha256=J7iFyOfzcqTPPaoGDSsgz79FcvpVEUJQz9Lp60IWdIk,200 +torch/include/torch/csrc/jit/runtime/logging.h,sha256=8iNY7OriqxO_PkLjzaPfcoCH0xM-cXo5fKSpGurc15Q,2554 +torch/include/torch/csrc/jit/runtime/operator.h,sha256=xiDLC96kK2BOeuCdaUBwyeG18EWSJq8Ak8ljUx4KVvc,11738 +torch/include/torch/csrc/jit/runtime/operator_options.h,sha256=T3eF5cJyP0Gfv-8-8UDZQ67GYAznVFv4_S5MOr6QEow,164 +torch/include/torch/csrc/jit/runtime/print_handler.h,sha256=7BhckncLpvB1v1OViPjayXW-gMIDSyJ3HWc8ghENgBg,308 +torch/include/torch/csrc/jit/runtime/profiling_graph_executor_impl.h,sha256=cVDO2a9iqojIzeUoVEUFuhSL4MR5wIgSSyHjMSrx9-I,2718 +torch/include/torch/csrc/jit/runtime/profiling_record.h,sha256=j5cXWqFSi4hxM1ncv4Z6u6kHOVf3c2f1MWlU1rqHq9Y,8543 +torch/include/torch/csrc/jit/runtime/register_ops_utils.h,sha256=m0WoCekUxDSl_tsbz-f5vZ7kRx_V2Ci8r6Wc1QtQJQc,42603 +torch/include/torch/csrc/jit/runtime/script_profile.h,sha256=uryrw9gOOF1dB-0p-T2BROgTrDesmznjHrrv4cWf3IA,2617 +torch/include/torch/csrc/jit/runtime/serialized_shape_function_registry.h,sha256=TOfPLKlvlilf71WrOfkPCaCH0aFbnBCxFHSvxSAmEbE,356 +torch/include/torch/csrc/jit/runtime/shape_function_registry.h,sha256=E15CTZzgUVWvdzS4WBzzBLp53qHpRGIqi43STGjiymE,243 +torch/include/torch/csrc/jit/runtime/simple_graph_executor_impl.h,sha256=TrLd1bQdQcgvHzbd9uz2lWKZk18njVRuvUrJC_EJ3-k,643 +torch/include/torch/csrc/jit/runtime/slice_indices_adjust.h,sha256=-7bG6aoqU0uEXd4kXn8UNX63r3EETlWK8tZqBYiHhxI,782 +torch/include/torch/csrc/jit/runtime/symbolic_script.h,sha256=pFMWhnaWRslFY71luGbw-q6viP0kPoxoH5DjAa86p84,573 +torch/include/torch/csrc/jit/runtime/symbolic_shape_registry.h,sha256=bbs-tOgxUJXCkRCGOSkd3ZviHIn0Pi7n5yfLUb1UGf0,2795 +torch/include/torch/csrc/jit/runtime/symbolic_shape_registry_util.h,sha256=7p1cL2YS8jZuGeWI48XXETdslPoD9tm0_0FU_p-kWVQ,351 +torch/include/torch/csrc/jit/runtime/vararg_functions.h,sha256=4YE78NgzdL8MxckVRrej9O0B_JXQkcKJhxbazpoHXBc,1147 +torch/include/torch/csrc/jit/runtime/variable_tensor_list.h,sha256=BLJu7wftFO19tgS1o_8g9Vo58vKoBqtdLiH0pYMCbdw,527 +torch/include/torch/csrc/jit/serialization/callstack_debug_info_serialization.h,sha256=dP401kjJlCYnHT3ImcGQJKef0Tmgw1P60bkggkuERj8,2624 +torch/include/torch/csrc/jit/serialization/export.h,sha256=oZKLD0FP6T5SudgdZZ-llSGIR_1f0QKZ9M8KBfBGiCs,11530 +torch/include/torch/csrc/jit/serialization/export_bytecode.h,sha256=nS3M5IKe-ife0LErkyh2hom3gPyhS8h8OM4hsscs4wM,1436 +torch/include/torch/csrc/jit/serialization/flatbuffer_serializer.h,sha256=xdg0sjrtrKEad8FIjpY4YGi4pCtdpiZoKQrwhNBHShY,3068 +torch/include/torch/csrc/jit/serialization/flatbuffer_serializer_jit.h,sha256=f71NMpmWRD8vLxf3oQoodL14eawM8SJNtmQA4nACsHY,197 +torch/include/torch/csrc/jit/serialization/import.h,sha256=eWwGipJEzo7suzy7TjuCMouJ1KwU9flHF_OvPGOJxuM,5038 +torch/include/torch/csrc/jit/serialization/import_export_constants.h,sha256=PwcBt7QaJgIeXEJharwa8-7TAbBoXW0jcBD0URuKv4E,670 +torch/include/torch/csrc/jit/serialization/import_export_functions.h,sha256=z1x5GErHSdXtFZHu-8RssFW6nXBztv43gh6o6a3Hs9M,413 +torch/include/torch/csrc/jit/serialization/import_export_helpers.h,sha256=AkAKNlNXoEd0uwK4NlgJ45OQ1yycbxppvdYL5Bkj_p4,709 +torch/include/torch/csrc/jit/serialization/import_legacy.h,sha256=oAVCnzvpIQGKBCUWw7XC_MPFPCYoFzPNtbRaLiu9leE,496 +torch/include/torch/csrc/jit/serialization/import_read.h,sha256=K7hpdwk9j2ytESQKIo7-K7yf0AkiMNCHv9txjB8lhVs,875 +torch/include/torch/csrc/jit/serialization/import_source.h,sha256=Kz0odK-jp7QFbWEsVi8QvnxaukTDpZwXdMo2toIQDsk,3477 +torch/include/torch/csrc/jit/serialization/mobile_bytecode_generated.h,sha256=lYcBLkLIoeIVAno96rXwi7X5KMe3oAmjJaiodkZbv90,98594 +torch/include/torch/csrc/jit/serialization/onnx.h,sha256=MACgWo0l7D149IqzgTV-Maw_--5a9Kx2uqEgFqxuuqc,229 +torch/include/torch/csrc/jit/serialization/pickle.h,sha256=jpMsgRpjFhEq6B1XuM0ZwDpm6zesexfwEjyMVHYfiNk,4179 +torch/include/torch/csrc/jit/serialization/pickler.h,sha256=vLo9YeOIW4lZlcZj5QD4XdOOOQnod3w3-0LHYT_WqhU,13853 +torch/include/torch/csrc/jit/serialization/python_print.h,sha256=ta8iGXz6MEe42z4hV1FlQwzcjEG-TDxWijRFjd973HA,1334 +torch/include/torch/csrc/jit/serialization/source_range_serialization.h,sha256=iMsaM6FiyeTklw5MDxKbJ66vGm3DIOqQ3Bw-5BWkDEU,1691 +torch/include/torch/csrc/jit/serialization/source_range_serialization_impl.h,sha256=GyKDHMJh8vES7CKm2Vb01bsotCTxXvUvwH2EVq4eJiE,705 +torch/include/torch/csrc/jit/serialization/storage_context.h,sha256=7Yuz7ObDXi8r8eBYXpQiB-7XNXkQff6Gr4URHAdAeM0,2512 +torch/include/torch/csrc/jit/serialization/type_name_uniquer.h,sha256=Iw47XHz7lPkgC9K5dUolB51xJ24SCWQ362jKGukbUKs,779 +torch/include/torch/csrc/jit/serialization/unpickler.h,sha256=k5eaycn84tt8go0UWv2D3b8nygxZm-giCn9QDP8GPhg,7596 +torch/include/torch/csrc/jit/tensorexpr/analysis.h,sha256=XYsGpeq0kz4P4FH0-ZBOe7Yr2y98DrNbNWRqeGkHUKE,9180 +torch/include/torch/csrc/jit/tensorexpr/block_codegen.h,sha256=BPwiFdd-iDO0WGQKfhJKIYo4AwdivkihivMcEWHQMFU,4241 +torch/include/torch/csrc/jit/tensorexpr/bounds_inference.h,sha256=tIHoZEpXklzMujA-0x1JpsfOi2NPEWJAAdyUHT2St2I,2216 +torch/include/torch/csrc/jit/tensorexpr/bounds_overlap.h,sha256=CcwLq7XN4RiGtlOmWAizp3E0KNg2uiwt7AHftMx1OPw,4526 +torch/include/torch/csrc/jit/tensorexpr/codegen.h,sha256=BBmyWwETK8ovXT3gHI3aWbOAyreGDbrEDOAJ-whPZ80,8136 +torch/include/torch/csrc/jit/tensorexpr/cpp_codegen.h,sha256=QqpMixOPvEsoK4fNF0Qmbankqh4WJ8_jDfIZM9993EI,2278 +torch/include/torch/csrc/jit/tensorexpr/cpp_intrinsics.h,sha256=XEzshVCUefNQLU-d7ZixlApMdgtvZ3_9_wsuO8zGq4Q,719 +torch/include/torch/csrc/jit/tensorexpr/cuda_codegen.h,sha256=S0sBFcNBGF0rM_z6a-DCNHmwrKq4Eb8NZTWzxZUIMW4,8368 +torch/include/torch/csrc/jit/tensorexpr/cuda_random.h,sha256=c1i6pdqn9m-l9PeMXeNlhW9qiE8FlLSVj2DV-ioYB7c,2642 +torch/include/torch/csrc/jit/tensorexpr/eval.h,sha256=hgHhrZb3H4jmlZP7eNuxPyErsRu0dThRCJOS9hVSh8M,11044 +torch/include/torch/csrc/jit/tensorexpr/exceptions.h,sha256=SEHeRHop_dLo3vma50iqcIrDTZi0gg0jQX-1qfhbElc,3239 +torch/include/torch/csrc/jit/tensorexpr/expr.h,sha256=soJl075qA-CbP_jSPsXSpKJBFTBxRgK1Z1b4TRazQYs,14343 +torch/include/torch/csrc/jit/tensorexpr/external_functions.h,sha256=iNEwepGqGWmEpPL55lL9obEEs4fYvG03qV0BSNcPuuI,3485 +torch/include/torch/csrc/jit/tensorexpr/external_functions_core.h,sha256=b35GbjY-X7qyLJ57hEu902nPpkk6uDs_tzaFCBYQlp0,504 +torch/include/torch/csrc/jit/tensorexpr/external_functions_registry.h,sha256=5PMv1IZZPXuBbj4t24FwbbhPNMgUjAlTaa5dkJjYB1Q,2356 +torch/include/torch/csrc/jit/tensorexpr/fwd_decls.h,sha256=NmtzudbjIA2Cm0HOFsDraY95bvBwy5wdNt-SJIDqBOM,3034 +torch/include/torch/csrc/jit/tensorexpr/graph_opt.h,sha256=qIoi-OKlAVZVP82OGr4mzrYgj52221nqN_96O1u5P7c,4484 +torch/include/torch/csrc/jit/tensorexpr/half_support.h,sha256=3HP6qoqJv-fqTImF54smFiMvExD-wJ1LdluQZQZPoeU,5836 +torch/include/torch/csrc/jit/tensorexpr/hash_provider.h,sha256=TO1nBm1Aqgf5LvhurYgbLjOid5fjc-lUJraErGWFiiM,7983 +torch/include/torch/csrc/jit/tensorexpr/intrinsic_symbols.h,sha256=xFMYwrG9FzKJKOWVZSlyRaRn3YPR8SuDDAo9Md0GPVQ,420 +torch/include/torch/csrc/jit/tensorexpr/ir.h,sha256=RuxJhiKsIeXmc65Fe3PRDT63DjkdOvGkPK-NxBmz6l0,23598 +torch/include/torch/csrc/jit/tensorexpr/ir_cloner.h,sha256=-lPpvoRa9WCu1atbZcQ9eVz7QKFOIYUYL7RJyk6taKY,2110 +torch/include/torch/csrc/jit/tensorexpr/ir_mutator.h,sha256=qFsEPY_-eB1JxmsF9gybc-w2WGbTGT6vr5JWESRquaA,2140 +torch/include/torch/csrc/jit/tensorexpr/ir_printer.h,sha256=W69knIpaNagjTPn0WInf2zmmeckaK5py3T4Li-LZVSI,3860 +torch/include/torch/csrc/jit/tensorexpr/ir_simplifier.h,sha256=iayHUcL1X0rRAn-Vyj_X_ZzwNoG-fWWsTnv4VO_vS6U,15520 +torch/include/torch/csrc/jit/tensorexpr/ir_verifier.h,sha256=3uBx_O4TNeIctSQ81sjKtKOXd6E6s8bGQLY54loyrZk,1219 +torch/include/torch/csrc/jit/tensorexpr/ir_visitor.h,sha256=buPmythe5_kaYS9C1VC3pqXi6hT5LjSYxTtreTtVICs,1943 +torch/include/torch/csrc/jit/tensorexpr/kernel.h,sha256=umMcWiLwZVqROJ41ga6Hztod_ZNdFL1fOXXRpTlvw5U,13376 +torch/include/torch/csrc/jit/tensorexpr/llvm_codegen.h,sha256=O3Mwbg1ywyQB33OsKGtckaJ0rCSCsLe5nQEUA2BAUBQ,3850 +torch/include/torch/csrc/jit/tensorexpr/llvm_jit.h,sha256=WEEu4rxptFRvaVxn47j-_zR_cvVGWsdSYR1mOSGtrEI,1951 +torch/include/torch/csrc/jit/tensorexpr/loopnest.h,sha256=8Wbbu-5KJzNvT19FKOX1S-Su0Ebt0k53JnXurQB6A-8,21347 +torch/include/torch/csrc/jit/tensorexpr/loopnest_randomization.h,sha256=EDpt9cBdS4oyjO_pH1i8v8rzyIOJBupk5yBioNzdlR4,359 +torch/include/torch/csrc/jit/tensorexpr/lowerings.h,sha256=mp5BecMZYCjRwk3xQWyoAL-K4EBwnExg-FkeEaro-Ok,1323 +torch/include/torch/csrc/jit/tensorexpr/mem_dependency_checker.h,sha256=GxuH9MphGhcEB6dXw1F6Udcjc1DmM16R0a4j5I7x4-I,13239 +torch/include/torch/csrc/jit/tensorexpr/operators/conv2d.h,sha256=bns5NkH7_MlZ-2p--vHs6vNSJgGvAkihzDILqvm33a0,2943 +torch/include/torch/csrc/jit/tensorexpr/operators/matmul.h,sha256=Lu2V2dZLDE3Nin6_hHbRC6V2L27v6vNcP0SryfRfj7Y,653 +torch/include/torch/csrc/jit/tensorexpr/operators/misc.h,sha256=N0FKZMy45iWvcxYYp3f1GAJzc4uGFKQ-Qftc3lyz45I,3324 +torch/include/torch/csrc/jit/tensorexpr/operators/norm.h,sha256=VuNMXNVcpD08jM-HMK-J1UTAEVVMMiZM19p8kyNz01g,423 +torch/include/torch/csrc/jit/tensorexpr/operators/operators.h,sha256=uUMEOYPpfSOrKklAjsN4YdQD7agTgSCUzMni2PeH78s,471 +torch/include/torch/csrc/jit/tensorexpr/operators/pointwise.h,sha256=HEtSbuouHEurpOuAO65X3Oqe12UNRHQH4ecrKULqtRs,3202 +torch/include/torch/csrc/jit/tensorexpr/operators/quantization.h,sha256=Tlxco4v3z0mHv4LxB8XpR5UrnJ-wcdRlj-OOZ_l_zk4,5582 +torch/include/torch/csrc/jit/tensorexpr/operators/reduction.h,sha256=NVB0AOHmMx0tkKaNHHnHLfxJaumHVWNC3ORXgIrLhE4,1155 +torch/include/torch/csrc/jit/tensorexpr/operators/softmax.h,sha256=tOkx_YTIAy78POs3G8GxUv-byZ39qEK_bBKZ5OruwUU,371 +torch/include/torch/csrc/jit/tensorexpr/reduction.h,sha256=UJv8prSVLTmcpnDS9fOw_i8ADpKcFDynr_G8ARdCnHY,8697 +torch/include/torch/csrc/jit/tensorexpr/registerizer.h,sha256=5P82baOPFf9lQVoO0aecLSQI0kPU7n3w5gGmHLBWTrQ,12540 +torch/include/torch/csrc/jit/tensorexpr/stmt.h,sha256=XOHcbNqYZyOXDk6kRVNW-BMMpigBC4llDkgwQJeBXDo,24321 +torch/include/torch/csrc/jit/tensorexpr/tensor.h,sha256=UESU7EkO6xaMnjlL0ZofRfO5KA6SzNI_8CFLTpM7u40,10793 +torch/include/torch/csrc/jit/tensorexpr/tensorexpr_init.h,sha256=INBGA6k25_MhWFjgjH3vqwPqTUupzoDo-qYARLMW8MA,268 +torch/include/torch/csrc/jit/tensorexpr/types.h,sha256=kDAeYY-9iIfERsFpbGXYf-V7SqhBzqxywI-FnuKeWtA,4310 +torch/include/torch/csrc/jit/tensorexpr/unique_name_manager.h,sha256=36F09N0Fvg7kRVB-7TAU1LZsgxJC9WvaK5XzRBvRUaE,926 +torch/include/torch/csrc/jit/tensorexpr/var_substitutor.h,sha256=i1UteqinYYFTPJzycOUwxHiyW9SAGx92bFujov82c0k,1812 +torch/include/torch/csrc/jit/testing/file_check.h,sha256=GfHH-By3ohBvZHkRvxE08DNKWMV3_Cz2InXbA8-UUAA,2568 +torch/include/torch/csrc/jit/testing/hooks_for_testing.h,sha256=qTVWQIZvaPw2xkzr_hbn3phdtT94Yc2_JCUEahUp1Us,603 +torch/include/torch/csrc/lazy/backend/backend_data.h,sha256=VQ_5Zm7jvFNYY9Vn3e-mkLk37hVolIl-YRC8Lo_-hEw,1205 +torch/include/torch/csrc/lazy/backend/backend_device.h,sha256=4P3bcR4OaDEv8GNncQjBerCshUoeY_9EFkybSVsrY3s,2876 +torch/include/torch/csrc/lazy/backend/backend_interface.h,sha256=NbEdNBfVfnJWA0JTHOixoOQn4aXPKxY-BIeYBbvmWM4,4846 +torch/include/torch/csrc/lazy/backend/lowering_context.h,sha256=y5t4aXVFCZlM6aZFZDB6NbTfi4JB2aIjiXy9DD0nsPk,3308 +torch/include/torch/csrc/lazy/core/cache.h,sha256=O4NjeVhn5TiLcRIUQ5mvTNPac0TVOC1NVPZ3HnRmzVU,3645 +torch/include/torch/csrc/lazy/core/config.h,sha256=wF70zxarRonAuvn3nofxeKY1NXILNO9sqPhLl5MwPUE,913 +torch/include/torch/csrc/lazy/core/debug_util.h,sha256=HPbvpVneHJrn43myzDe1i24-wMCg7254M8TNGdcz13Q,1299 +torch/include/torch/csrc/lazy/core/dynamic_ir.h,sha256=iCbqKMuQU0OoJK5S4tG_dE99jzH5Ldw94DrQtLwdZyA,1586 +torch/include/torch/csrc/lazy/core/hash.h,sha256=5ojcWHoZsN2G4jwzNfaAcAZloWDcBVR6_P-jE6szaec,7290 +torch/include/torch/csrc/lazy/core/helpers.h,sha256=_X2bnEg1MlFhkzxGTvmGyLaJ0m6SCwVdCe3rB4zh0yE,2259 +torch/include/torch/csrc/lazy/core/internal_ops/ltc_ops.h,sha256=Y1dv99_hdJegQM59a1sn2UVVCzG5M81IwNGChLyXtXE,1492 +torch/include/torch/csrc/lazy/core/ir.h,sha256=yKMcXvo7Ys-EsMUh8VvOt5bSOV5SdKgylnB0t9AC9gc,8007 +torch/include/torch/csrc/lazy/core/ir_builder.h,sha256=jqzR0PRk6FDsmy4dbFZXcax1GORiQAsq3SCbzoSI_J4,4738 +torch/include/torch/csrc/lazy/core/ir_dump_util.h,sha256=cnOi7BbGSdYt29JaW0y7_2TveSXKllMuM3eF9hbPP7s,689 +torch/include/torch/csrc/lazy/core/ir_metadata.h,sha256=LV22oumhbrensXigzC6UuJjcycBENC--T3KNVebdgkw,1154 +torch/include/torch/csrc/lazy/core/ir_util.h,sha256=t2vTTSDYuZaljqHqrzx7YXPinZSjrgHQLdKtsimnWP4,1391 +torch/include/torch/csrc/lazy/core/lazy_graph_executor.h,sha256=TVdKCIs61x6jDNmftqdV2nnss-KbIxx0iDk6t2wh6d8,14859 +torch/include/torch/csrc/lazy/core/metrics.h,sha256=v5PGW2mAr_N0x_mzN_CiAUaCmn7MYmd0brsvOrwatmM,8017 +torch/include/torch/csrc/lazy/core/multi_wait.h,sha256=S9a59_NsDmrWvprDvDiiVDq-FjvFv7-hzgEat8g225U,1740 +torch/include/torch/csrc/lazy/core/ops/arithmetic_ir_ops.h,sha256=fjyJJvOW1x0vED4C03fdt_imQkFs1A_2xP1SDQQpWA0,406 +torch/include/torch/csrc/lazy/core/ops/utils.h,sha256=RwVAGc_1DAG5aTpaHRntrYyFO-YPx1Bqfm3XcHq_M4Q,1010 +torch/include/torch/csrc/lazy/core/permutation_util.h,sha256=sUpKHJc5ZtY0fBV4r3hpJ_xzSjmX37TmvrXcrQ_UusM,1277 +torch/include/torch/csrc/lazy/core/shape.h,sha256=X5DJQk1iTk7J11aoEzGRVpAbHa83S6Bhd5ma6efyeUQ,2020 +torch/include/torch/csrc/lazy/core/shape_inference.h,sha256=C5jzjPWPYircFNlm-Jx_CDc-UUpIAmq8Sk-P0o8JMHY,15350 +torch/include/torch/csrc/lazy/core/tensor.h,sha256=_McMNYzsfMiK2FUOhE7_NE5seEfgzwgvzpnhpFXZxbQ,9439 +torch/include/torch/csrc/lazy/core/tensor_impl.h,sha256=m9hDgfipVN0cTPayykC7buE8lmOyFhV6iPT5p8zBZtA,1910 +torch/include/torch/csrc/lazy/core/tensor_util.h,sha256=tz9gZ7ymXbwXYsmJYLGRJ4CgM3ReamNEcnYGct7Lxug,2561 +torch/include/torch/csrc/lazy/core/thread_pool.h,sha256=93Llb28b8IOCi4fzc2t_dxI0KbiosFaUBrfWR6bx-6c,721 +torch/include/torch/csrc/lazy/core/trie.h,sha256=QSiW5yPfjwjCk4b6T-2DxUXH3-cL8r7jMtF9LkvVYiQ,2217 +torch/include/torch/csrc/lazy/core/unique.h,sha256=GHYHoW7xyulSfU5DkUTW75Onlzj5BW8aSyYBbUjN16A,1175 +torch/include/torch/csrc/lazy/core/util.h,sha256=o7zCH3L1Mf2CAOOJj4qq2jxLSB92YnxLOb6e-ZNZeiw,2830 +torch/include/torch/csrc/lazy/python/python_util.h,sha256=J-L_LKLwLCRZQafX1xHfA5IHzlhpwxSDDOcAH25Xt-Y,351 +torch/include/torch/csrc/lazy/ts_backend/config.h,sha256=mAauhrHhWIzAJc-pHcjzFhaVBGuHXZUjiWL2G23BHt8,202 +torch/include/torch/csrc/lazy/ts_backend/dynamic_ir.h,sha256=RQWixJpb5piDUl5VaI1yL_uJXcEatY8YvwKY_WGVnEQ,2503 +torch/include/torch/csrc/lazy/ts_backend/ir_builder.h,sha256=dXSrFc9KaY8-RvcA-6BUHu7h6qy9T26jgZCB2VL9iKY,2416 +torch/include/torch/csrc/lazy/ts_backend/tensor_aten_ops.h,sha256=g5DsT3zcoF-9oEYQ37Amm4jdhL_YRHdB6qPJkqPCU2w,548 +torch/include/torch/csrc/lazy/ts_backend/ts_autograd_functions.h,sha256=LBqUJ_aJwGFV7IPtUzhnbyYhUpO59COTv9gBC_fW2TE,644 +torch/include/torch/csrc/lazy/ts_backend/ts_backend_impl.h,sha256=DCKOCkzy5gI2430ra0nYkt2GMjCW0nGIphJe3TWNeCs,1234 +torch/include/torch/csrc/lazy/ts_backend/ts_eager_fallback.h,sha256=GW6xzyRRYLvdDf1XA78_nT-1bkdeDvPgYyeefhn3piQ,717 +torch/include/torch/csrc/lazy/ts_backend/ts_lowering_context.h,sha256=pPmx22bfOeJ5toBc_7Ey-QAYwIeJIKCoiU5_onXEXA4,4519 +torch/include/torch/csrc/lazy/ts_backend/ts_node.h,sha256=N91HrPG7tJEC1MdZv5Zo3R7jiZ2lzBK5QtSTisI7R3Y,3376 +torch/include/torch/csrc/lazy/ts_backend/ts_node_lowering.h,sha256=TUl69lpUcqybpxrYebLv5EDHgYIhXfyg26GvfrAOknY,484 +torch/include/torch/csrc/onnx/back_compat.h,sha256=zc5K7G4NO3cMvNW8Uz5xvoUNnw5G0sZfc0j5Xwq4i8E,1024 +torch/include/torch/csrc/onnx/init.h,sha256=ZXAqnv9mhvV3QHMdSwzKprQOSAa-rSi3pcABk0aY3a4,146 +torch/include/torch/csrc/onnx/onnx.h,sha256=9ghsm-HHPWO3NC6nNNCfEI1U_H2jZ55SULufWFKPa2w,507 +torch/include/torch/csrc/profiler/api.h,sha256=zjBc3tV-Ei0HPla-xCOry7uHWlQXXMT5nYcJcqyDNZQ,559 +torch/include/torch/csrc/profiler/collection.h,sha256=TfK6T6taYcguS3h9J7SqQj0ndr-qQfgsFWXqcXmH0nU,19596 +torch/include/torch/csrc/profiler/combined_traceback.h,sha256=xwV1K_fHpnblNCdp_69zKLbw2PxESKY80gtskCzA0zs,2457 +torch/include/torch/csrc/profiler/containers.h,sha256=6C5y6IcBwNCwbMo2yKQGOzUen2hdmiGO5YLCm_k5gXw,5957 +torch/include/torch/csrc/profiler/data_flow.h,sha256=_SiPNbsZs7_OiUg9T9A6bxsBIeFLvB2t7ONaIXtCJMk,3675 +torch/include/torch/csrc/profiler/events.h,sha256=0r5a0Ldx__9cdVwQ0ns7mvmn9WwxLwUhEd86I4NnqPU,1063 +torch/include/torch/csrc/profiler/kineto_shim.h,sha256=Ec0f1p-WnFwgnSFe3J0TjcYCUUD3TPtOF9yRwUaVvEo,4068 +torch/include/torch/csrc/profiler/orchestration/observer.h,sha256=nF70GOhRkh575sxwbcTGafSlLl26Y6UwNYWslaGpf8M,5062 +torch/include/torch/csrc/profiler/orchestration/python_tracer.h,sha256=hbu3e45yq-Nn1O4RU_V7dy27vRpalkM5dkUK1k3CGwg,1828 +torch/include/torch/csrc/profiler/orchestration/vulkan.h,sha256=nbVl5pgj47F2WqBW45wwyXLMIzVtg9MCftxONuxb-zU,851 +torch/include/torch/csrc/profiler/perf-inl.h,sha256=YWlKN0RywwTmuFC-4J6ZOISKaD-YZOLufm1KahLcuXw,1460 +torch/include/torch/csrc/profiler/perf.h,sha256=iRZ1J6uEui__ZHpGOdOFkQS-OxKw_40N9SbNFy36BL0,2562 +torch/include/torch/csrc/profiler/stubs/base.h,sha256=mywaYsluaThccsb31UmdIXwXc8SENvAW6DQS6lgqrOY,1725 +torch/include/torch/csrc/profiler/unwind/action.h,sha256=y4w5mzNoSxplA0yv-ZhFD76Z-TZ9j-q1cmip-hVRo7c,1368 +torch/include/torch/csrc/profiler/unwind/communicate.h,sha256=5HZsO6j2g_9RpMis7HORX6NXO7kXaK1rwTjrak2l2e0,1870 +torch/include/torch/csrc/profiler/unwind/dwarf_enums.h,sha256=Ojxlhbz2WvETGEnqFq4XH0Oi7d4zYg4nRU3LgyA6gew,1110 +torch/include/torch/csrc/profiler/unwind/eh_frame_hdr.h,sha256=TMZAYZhDnMFUwnZs7pyqe03h9lOXiILeud9wrQgCHt4,2527 +torch/include/torch/csrc/profiler/unwind/fde.h,sha256=z2rLN7FotZPORf4TbIEPN07N8IU0UxM8FcjmkqHj4b8,11924 +torch/include/torch/csrc/profiler/unwind/lexer.h,sha256=o77ur7xftUskvDlWLxHs467AnDJr8mnlxg9HjWxb6Xg,3041 +torch/include/torch/csrc/profiler/unwind/unwind.h,sha256=Pg2VFzs3K0QJsugYQjQ_l9R6-TlGc1br44n8N4Q1j2k,1084 +torch/include/torch/csrc/profiler/unwind/unwind_error.h,sha256=aXvPAgW0RNBM7TiaKZTR2WCVVlZkuPlC9CQWMRYtD4g,130 +torch/include/torch/csrc/profiler/unwind/unwinder.h,sha256=qWjhN8mS4eLO6ckvbBZnodPSQfZkrCp-8dvAgyWd-E0,2236 +torch/include/torch/csrc/profiler/util.h,sha256=7NOowCtKEDYbOw97RancAedsHb8CrgpvoQu14xo3HVg,4978 +torch/include/torch/csrc/python_dimname.h,sha256=-Bk8OBU36eIs9dyAMtpnfXkfa5KgFVxxrLKjhAem5sM,214 +torch/include/torch/csrc/python_headers.h,sha256=ZjIaoShls4JWN3vgElKkmNlZuulOavbFlgugV5L7R70,649 +torch/include/torch/csrc/serialization.h,sha256=olcwp7eeOqqpLV_hqyjMf6FAn4ppF9vonr7Sflay_T4,681 +torch/include/torch/csrc/tensor/python_tensor.h,sha256=ygnOLM0OHKcJw8mDotS7Ysq62bk7tVtTH-SOZ5rsBx4,1102 +torch/include/torch/csrc/utils.h,sha256=vJbHcZ6SXPCaBvdLrsY6uuwzZBw25FLCjxVmTNLDqo8,9389 +torch/include/torch/csrc/utils/byte_order.h,sha256=Vj4VWPytbhZ5W77-Was0__q8Br9RTU1vRnBFrH8M3zw,5878 +torch/include/torch/csrc/utils/cpp_stacktraces.h,sha256=D131Fmw7A__54HWdJhe5aDqVe5c8oWoWvKrimhNG4IE,171 +torch/include/torch/csrc/utils/cuda_enabled.h,sha256=XBmhhhMQUKhvB5amlyZpB-tV7Lfg8KtSo2F-MAy6nr8,192 +torch/include/torch/csrc/utils/device_lazy_init.h,sha256=LocWYB-Dt55MNjDuhEiW2Kx6UBPpLSMcyx9OKb_QbMw,1705 +torch/include/torch/csrc/utils/disable_torch_function.h,sha256=qcPSbpHM6iiAbD-GG2WRwZOK_lP-z-DjVhvZldWP-wY,1777 +torch/include/torch/csrc/utils/init.h,sha256=zuhbx4d-OR-q_eON2gTWnke7iu1LzzhXSlgaQxnqO5Y,218 +torch/include/torch/csrc/utils/invalid_arguments.h,sha256=dXhIUSgk21JztsfxdrsNWq40fQOVhPLmMWRQocy_q3M,302 +torch/include/torch/csrc/utils/nested.h,sha256=QgZZwwWMtV0LH-NH6TUgZe-fxuSU1dzTDp38dkSkDFQ,331 +torch/include/torch/csrc/utils/numpy_stub.h,sha256=1m2vyb-8t2lQGtylJZrcH2cw8nHX_OEtyKk7Q_jGg34,399 +torch/include/torch/csrc/utils/object_ptr.h,sha256=AUZl7WR4XxSyzIMahypE4_faOXCh6YoiXByY1uOZKxU,1574 +torch/include/torch/csrc/utils/out_types.h,sha256=A6jvfT3NOTvo7ATVGJPe9docyZKpnTCQm6HAG6XGko4,352 +torch/include/torch/csrc/utils/pybind.h,sha256=p4A-FwMGQMhJG_HkxsPq9r26i-G9TXgixkPT4IFnjzE,11582 +torch/include/torch/csrc/utils/pycfunction_helpers.h,sha256=4_LQ4gsIR9hC6vI7cHEW161VW8KxurlJyR3LvHQZxPo,385 +torch/include/torch/csrc/utils/pyobject_preservation.h,sha256=G0h2hb4Ou4yDrLX4UuNhp4-71hOioOugzTzqBilRFzI,181 +torch/include/torch/csrc/utils/python_arg_parser.h,sha256=MkvH34-HB-exo5Vekrr-_HHAtA7UDW4VHAf8j1DYZy4,40794 +torch/include/torch/csrc/utils/python_compat.h,sha256=bPmjp2aFo2ucZKvU6Nt6r1tpeldG7GGedDiuCRNUBTM,817 +torch/include/torch/csrc/utils/python_dispatch.h,sha256=DyERM6ze9ho04k3uHJ0a28k28wm1Z3LbmHMz5KZnF7k,375 +torch/include/torch/csrc/utils/python_numbers.h,sha256=mquLnuQB0huvs1RFfaoiTvCtCiUzMHVc7WpcQ2r2YEQ,5600 +torch/include/torch/csrc/utils/python_raii.h,sha256=rSR7TRx98FU-Z6MR-GMWF8DRvJx6j3SL_5SMFOZ0xKo,2652 +torch/include/torch/csrc/utils/python_scalars.h,sha256=sfPTVG7tE5esB5AqdLCH1ImjRl5saIxYbD4OoVfKZgU,5586 +torch/include/torch/csrc/utils/python_strings.h,sha256=TzdP5dG0xt-C-oATyzfNaNN7ZhKjsADDhI3FUUufJsk,4413 +torch/include/torch/csrc/utils/python_stub.h,sha256=Nigc7ZGrniF0qdLn-Ra4KIicNWTBrgARkJYpxs6Ssek,56 +torch/include/torch/csrc/utils/python_symnode.h,sha256=EL-qPZZEv_FB3eBeKCvkU0CWAU5g2pSV3lJcBC87D_0,8881 +torch/include/torch/csrc/utils/python_torch_function_mode.h,sha256=bP2g9yWSoWZx9dCAsDo4IwMZuJ5arbItk1Qwo5V85qc,537 +torch/include/torch/csrc/utils/python_tuples.h,sha256=zJ4thzUsi2Gc1aOAviCv8r-cBAUPPmmE5n0G2jRauKI,701 +torch/include/torch/csrc/utils/pythoncapi_compat.h,sha256=zHuya17yA0NPrWNADChfl8sEz1GcRuvM8BbOGrY3K0M,19601 +torch/include/torch/csrc/utils/schema_info.h,sha256=KQYX9WiImDzXEA1iORuYUaZmRMajWFugwbzdt0-m-yg,3743 +torch/include/torch/csrc/utils/six.h,sha256=HzpaQpIxOJqfhrEHhKyEXRGwzc_u79Iuqy_Kut7RVi0,1465 +torch/include/torch/csrc/utils/structseq.h,sha256=VKGYfdbDBHoZcE6x2UZ8YlD95xbtWyacxhfIvfTNiGs,173 +torch/include/torch/csrc/utils/tensor_apply.h,sha256=MFUFixOlSCSnKSiNF3LJekiM9jze6E6pmsOqXTobJ34,453 +torch/include/torch/csrc/utils/tensor_dtypes.h,sha256=Zgv-kFqDVOPvwHzKhOklGJrGLi6bd4fRE23ZSoHQDh0,257 +torch/include/torch/csrc/utils/tensor_flatten.h,sha256=FOffkuEZnlUOWQjhLSh0W1cyyu5ZeHA57YPYSL-8Ljw,2770 +torch/include/torch/csrc/utils/tensor_layouts.h,sha256=MX0t-2VXHEuPndSZRGK1dzP81w1J17Z0fv3XwiEGYas,101 +torch/include/torch/csrc/utils/tensor_list.h,sha256=76zcfWoaX_pTmFXAySyT9MfuAEmYTzV936VyimkD4pA,199 +torch/include/torch/csrc/utils/tensor_memoryformats.h,sha256=eN4i77uBVTdPTSIzujDBfNoehh82K8cDI15xehhfRbw,276 +torch/include/torch/csrc/utils/tensor_new.h,sha256=Wh1qVY2aSGmjZFCoBna9P73BclmGGmzgOuxpcsbuhQU,3207 +torch/include/torch/csrc/utils/tensor_numpy.h,sha256=zWwuOXEl4xKnnBF7zc_hLyBaKLQEA-GYFhnpcqb64JU,713 +torch/include/torch/csrc/utils/tensor_qschemes.h,sha256=jIvHQ-q-NXIbJvNBcwze9-j1uaw5JIvTaImpu-G8Df8,199 +torch/include/torch/csrc/utils/tensor_types.h,sha256=5c9KgcbB31VCXw8aq0HfVOh_WD9Im4oa7wydUmsT66c,694 +torch/include/torch/csrc/utils/throughput_benchmark-inl.h,sha256=cR0LTGtMnmEKWKJwC1xydp9ljutn9MPTPlCft54GHIg,5610 +torch/include/torch/csrc/utils/throughput_benchmark.h,sha256=hXZvUKdlKtBEwIUkRfdFh7e115vqnJ4PP-0gFiBXFaE,6910 +torch/include/torch/csrc/utils/torch_dispatch_mode.h,sha256=rMtqSHWp4z7WZg7m1llXxvNILokJIlDFJnFKC4AyHwE,1599 +torch/include/torch/csrc/utils/variadic.h,sha256=lefkAq6FldRidnPPOrojpzGvnL4BjAzwcSadNpc6Jaw,4408 +torch/include/torch/csrc/utils/verbose.h,sha256=P_Dr_oOwiENVdRpzlGTBgJ4KOfl8PJI2ep2vCJeLsNg,138 +torch/include/torch/csrc/xpu/Event.h,sha256=GevWnT3ISB_N-aDQtFHkFPEU7rCcbdH6L1kkCvFeQgU,342 +torch/include/torch/csrc/xpu/Module.h,sha256=aqwqxUnsLYZ1g5nJeBmQYmOLSPJ6nPacKpQvuEWz9XQ,176 +torch/include/torch/csrc/xpu/Stream.h,sha256=Hbb8zcNcXj_JdslvzOROLYr77od5OpFGxFsocDiAaNc,437 +torch/include/torch/custom_class.h,sha256=DRZ1Q2dWYIBXq9CRt1fQAveo2YR8Ac5tSxqfj9o924o,19780 +torch/include/torch/custom_class_detail.h,sha256=mnx4R2IO50vfK7dypO4ApyR9DD_m_TJfCgIO9VD-tmc,7771 +torch/include/torch/extension.h,sha256=jIN4AnAwsUeV6tlDdnaZOlxuABYGNIEwSLtdbhwls9I,213 +torch/include/torch/library.h,sha256=zFVoW3gmvZFJ5P5t0k9CFCaKVCyqOaZjuK072VR84aE,40210 +torch/include/torch/script.h,sha256=5qMfjbmTzP84r3BPgSRhTqyjMFGrsD54pxsE6C1e508,469 +torch/include/xnnpack.h,sha256=YqSOuuPy13xBmJ6t9KajyXpor5Emd3Mj2nPpBZ5yiwI,223141 +torch/jit/__init__.py,sha256=KAcQWOYfZeAhEQTIKWl9WTiLtV3R6_ybA5w-8cygv_I,8270 +torch/jit/__pycache__/__init__.cpython-310.pyc,, +torch/jit/__pycache__/_async.cpython-310.pyc,, +torch/jit/__pycache__/_await.cpython-310.pyc,, +torch/jit/__pycache__/_builtins.cpython-310.pyc,, +torch/jit/__pycache__/_check.cpython-310.pyc,, +torch/jit/__pycache__/_dataclass_impls.cpython-310.pyc,, +torch/jit/__pycache__/_decomposition_utils.cpython-310.pyc,, +torch/jit/__pycache__/_decompositions.cpython-310.pyc,, +torch/jit/__pycache__/_freeze.cpython-310.pyc,, +torch/jit/__pycache__/_fuser.cpython-310.pyc,, +torch/jit/__pycache__/_ir_utils.cpython-310.pyc,, +torch/jit/__pycache__/_logging.cpython-310.pyc,, +torch/jit/__pycache__/_monkeytype_config.cpython-310.pyc,, +torch/jit/__pycache__/_pickle.cpython-310.pyc,, +torch/jit/__pycache__/_recursive.cpython-310.pyc,, +torch/jit/__pycache__/_script.cpython-310.pyc,, +torch/jit/__pycache__/_serialization.cpython-310.pyc,, +torch/jit/__pycache__/_shape_functions.cpython-310.pyc,, +torch/jit/__pycache__/_state.cpython-310.pyc,, +torch/jit/__pycache__/_trace.cpython-310.pyc,, +torch/jit/__pycache__/annotations.cpython-310.pyc,, +torch/jit/__pycache__/frontend.cpython-310.pyc,, +torch/jit/__pycache__/generate_bytecode.cpython-310.pyc,, +torch/jit/__pycache__/quantized.cpython-310.pyc,, +torch/jit/__pycache__/supported_ops.cpython-310.pyc,, +torch/jit/__pycache__/unsupported_tensor_ops.cpython-310.pyc,, +torch/jit/_async.py,sha256=ApqdR0FMnbg9FdppgakJ5LXxPspyFfwKXNia8Huu3t8,3783 +torch/jit/_await.py,sha256=r0eS7JGmrHq4HTKuiwg-8gPO6lk9uW-AshQnN3nN_eo,825 +torch/jit/_builtins.py,sha256=IINQERAr_l6ScalKZsqlE4FPgFysA7w0A9Rqg19td9M,6581 +torch/jit/_check.py,sha256=-_rirrnff8ySqzij-FV0Qiew74fC21YPGfgVQp5E6Ow,9335 +torch/jit/_dataclass_impls.py,sha256=vg7rzK9W16bTIcvPUf9IyLSY2BjiZBPhordYzqrP748,6657 +torch/jit/_decomposition_utils.py,sha256=7qJeMZsIE-PgRetub2jKS3KsKE6c0l8lCz9D6ZYizrQ,375 +torch/jit/_decompositions.py,sha256=eXU06DnPLCLK6an5VE59TlEbWRENBzdc8pgaNGDnfbI,4091 +torch/jit/_freeze.py,sha256=lq28qaD4y8fWngDkjKl65o5s81Us4swDJya4Ao3iSns,9426 +torch/jit/_fuser.py,sha256=N04XvGb9XENVoXWnMfnzjsWm9ZXUvnFwjtv978M2p4Q,7071 +torch/jit/_ir_utils.py,sha256=xh7NhnM84-s9cvLufaKPXrcnBmPZiO6gGKX_8NzmFo8,650 +torch/jit/_logging.py,sha256=AXSPcmOG3GZFileVv9IeUES0wb5kjDTYzzsy5fCyj4E,256 +torch/jit/_monkeytype_config.py,sha256=Xij8iwGnF1FblwHJgj5GrJ-P_oXwesNV9ZbzV7_VO8k,7211 +torch/jit/_passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/jit/_passes/__pycache__/__init__.cpython-310.pyc,, +torch/jit/_passes/__pycache__/_property_propagation.cpython-310.pyc,, +torch/jit/_passes/_property_propagation.py,sha256=OwJRxRjjNidtydXFhtsbrmlfC2bEgdHxYehGNqSvVyo,1436 +torch/jit/_pickle.py,sha256=1YjZMn7zCx3ahGi5IJ1ilzPY3rDEWOBWHySAHgLiYlk,955 +torch/jit/_recursive.py,sha256=tyLx1Vb69QME4W5wdJL6HoY1EAOoflrV8UDZSNDM39w,42753 +torch/jit/_script.py,sha256=FFNi_d1cQmy1IfXYz0fi-srlks1_rLzDd9BNBZT1MgQ,64160 +torch/jit/_serialization.py,sha256=PEbrsQ70lfhOzy9K4XMkFG_D0hMeoBE55czEk6wrupw,9199 +torch/jit/_shape_functions.py,sha256=b-S5YtbnLyS7btqbWwFOUdVXu2T5ManGCpldDM84HyM,44786 +torch/jit/_state.py,sha256=y0_O3kub_ihTzCkVXrf0D-Z7Bdt2ehUxUU9oygJ1_44,3735 +torch/jit/_trace.py,sha256=kw1jL3n_HsHdX9zEnZZXUdWNmOtXrFDuq5tVVKOUlWk,52529 +torch/jit/annotations.py,sha256=6bRE760Xzvfr1bpRPc8LVhSZ7CQP6bnRENmeNOR4WKc,17768 +torch/jit/frontend.py,sha256=cSVYw_k--yFH_2Oluf1W-EznUvhaFlGirZORiUkndvE,44453 +torch/jit/generate_bytecode.py,sha256=cYVH5XLZxoW_dfipurqy7WNU1TTZmK9feDblsvaZeMg,1039 +torch/jit/mobile/__init__.py,sha256=jer-HDF8nsjC_ZlSAA3JBhw29-aMVPY4GatcZjVvPuo,8491 +torch/jit/mobile/__pycache__/__init__.cpython-310.pyc,, +torch/jit/quantized.py,sha256=JacJwYMeM0IStFzFjeult1JdX9pKYuF8TPJgY6_5AoE,3166 +torch/jit/supported_ops.py,sha256=ApJw_EW8h8mGSamiEyK2OItuuSzlQV_Lgn0RdIAnmrQ,10233 +torch/jit/unsupported_tensor_ops.py,sha256=fcadP3YsC1hVNY4XYm26SvJtMlMwFqpFl-nbfStde30,1972 +torch/lib/libc10.so,sha256=195-6eMGKeZth4VtDxmsT7omqtHzAoMuDNUOyOoE7pA,1327001 +torch/lib/libc10_cuda.so,sha256=Z1imi4QyfsZZjz-rjkBdiQBcpUDVDabP_thu-KLi2u0,656217 +torch/lib/libcaffe2_nvrtc.so,sha256=aYxK1zW1HQL9Ci-3lG6Xz71JTCF1jbdQhP3SMfJf2ZY,22889 +torch/lib/libcusparseLt-f80c68d1.so.0,sha256=vm8kU08aqFmY-1imG55xJCgatTnL3hHw9A2dJXlchyg,43229425 +torch/lib/libgomp-a34b3233.so.1,sha256=nrAQIbtY7DaSXa61pWYGv6tVgzLrX1EZ6ZDkwgjtJYE,169089 +torch/lib/libshm.so,sha256=0pSkZcyUjS6IxsCGRy1SL-tMz3BcbRVSi3ek80FB2a0,52745 +torch/lib/libtorch.so,sha256=-lZ17XeEStozh9pxA8dDpEKR-2IK6aY7vGE-g30dAJ8,255873 +torch/lib/libtorch_cpu.so,sha256=Ixww3HwWjqbwehB1qWeO-R5I_XEzRB0pwf2lbTw-OtM,482044169 +torch/lib/libtorch_cuda.so,sha256=djLgbXjqbS6UzIWr0hMnGFWIeJdIV--nXQgc2YRXwok,881666489 +torch/lib/libtorch_cuda_linalg.so,sha256=KgdkbbbN2oXModUXBDTIe-EniVzd5NRaNwRXjqsrT1M,85435777 +torch/lib/libtorch_global_deps.so,sha256=r43vSTmy5sHULBgKjY56iPjx2Vg3DOzAY2YPhEuvvgQ,21177 +torch/lib/libtorch_python.so,sha256=9FL-LN4Xqiz11tigHKDoGBIMtH7-5xYd-pNwOgsCqh0,25990913 +torch/library.py,sha256=uZZAqwl8qWwfPWotp-0skznVtmsdBPyDYXn1mzgoupo,22618 +torch/linalg/__init__.py,sha256=GRvchJYX_fVgO_pqbAE15FxsWurtWpXC5tjIpJPTtB4,113853 +torch/linalg/__pycache__/__init__.cpython-310.pyc,, +torch/masked/__init__.py,sha256=9pvmuojmbv9m5PNgKZOo08h2eVZ-sOpk6bmklVdzxnA,627 +torch/masked/__pycache__/__init__.cpython-310.pyc,, +torch/masked/__pycache__/_docs.cpython-310.pyc,, +torch/masked/__pycache__/_ops.cpython-310.pyc,, +torch/masked/_docs.py,sha256=42ZgYJv8NHG9NlnfQgnASl002Zd5aefHu_Qd_G3USsA,49472 +torch/masked/_ops.py,sha256=UA5zLaZ9h7gBjBWzbfkd6JDVN8Gixw36UmGy_wt61Tg,65300 +torch/masked/maskedtensor/__init__.py,sha256=K62inlHZAKXpPohbbHnlJnrzIQqYpzb4SaHTF4s_hWQ,359 +torch/masked/maskedtensor/__pycache__/__init__.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/_ops_refs.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/binary.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/core.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/creation.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/passthrough.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/reductions.cpython-310.pyc,, +torch/masked/maskedtensor/__pycache__/unary.cpython-310.pyc,, +torch/masked/maskedtensor/_ops_refs.py,sha256=oTLsk_BX9T72zOcAwC4CLIgAm5NGHtuJWf1ZDgJD4PA,16569 +torch/masked/maskedtensor/binary.py,sha256=L5d93FbHlY0qYWsHL3HF4ZHg3XfN1GZ-D1pkS9O0-Ww,5370 +torch/masked/maskedtensor/core.py,sha256=u20OLJNhFf6R7GdYD5-F3aCwc3N4b4QxDEnmycMFvZY,12385 +torch/masked/maskedtensor/creation.py,sha256=AE7pT-oIOLG5KzcsXisS-DJmKyc9MhopEL4sE1r6kvk,527 +torch/masked/maskedtensor/passthrough.py,sha256=q4pxeePTewI607g6YiSBLShDlX00rJv6dT71DDPSo_s,1276 +torch/masked/maskedtensor/reductions.py,sha256=Y79ye5EreVfHgE4k6zNauTJBG4ATSjKMXasL35Xh8V0,5556 +torch/masked/maskedtensor/unary.py,sha256=kmSt8EG7tcYoFYCOCSeTpsfdclt4FsD3XNo5ZZ22Nyo,4128 +torch/monitor/__init__.py,sha256=nR8eJ0FnT8UuTkWSfVe1K5UForibJBNMM1jLo8QTkXg,1213 +torch/monitor/__pycache__/__init__.cpython-310.pyc,, +torch/mps/__init__.py,sha256=EMVwoiXKEycTRneqap8ZwjmWYp78g0bSm9c5lITbZ4k,4265 +torch/mps/__pycache__/__init__.cpython-310.pyc,, +torch/mps/__pycache__/event.cpython-310.pyc,, +torch/mps/__pycache__/profiler.cpython-310.pyc,, +torch/mps/event.py,sha256=8S_hOu0a1noYHjC8DUuskuIAH9GAF83NkaVgHVwxcjw,1656 +torch/mps/profiler.py,sha256=pD71UF-DZRQ7WkwjVL83FEG15Yb9YpIehYhdNm9207w,2345 +torch/multiprocessing/__init__.py,sha256=vv1x-yoQxTU44Gyg5FXPrXV3BZfgnoBWOpqzIPpHRiA,2487 +torch/multiprocessing/__pycache__/__init__.cpython-310.pyc,, +torch/multiprocessing/__pycache__/_atfork.cpython-310.pyc,, +torch/multiprocessing/__pycache__/pool.cpython-310.pyc,, +torch/multiprocessing/__pycache__/queue.cpython-310.pyc,, +torch/multiprocessing/__pycache__/reductions.cpython-310.pyc,, +torch/multiprocessing/__pycache__/spawn.cpython-310.pyc,, +torch/multiprocessing/_atfork.py,sha256=yEhI42cXiCmm3IGI2flgVcur1sZd7urSFLYS3WwkqHQ,762 +torch/multiprocessing/pool.py,sha256=M4P93j12ZHPdQakHYucZdhq8_u4bIOH-UDelyYt1c5Y,1743 +torch/multiprocessing/queue.py,sha256=O4rGYzzye7tEDsEUaTlH7VXGPPqCQKlqRQbFbC4v2Lc,1450 +torch/multiprocessing/reductions.py,sha256=VWp_l6SxLFz4NMLp4i5ufthv4naWg3ubYzjJxEYP9Hk,21779 +torch/multiprocessing/spawn.py,sha256=6WG2_xe14vN_hR-VDEDMv8Lnno_NADLAw2e2WMYUBW4,10370 +torch/nested/__init__.py,sha256=cHmB2Jv8jILnCxoxitd_vPFipN4K6_2Sd-F3X-My3D4,11238 +torch/nested/__pycache__/__init__.cpython-310.pyc,, +torch/nested/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/nested/_internal/__pycache__/__init__.cpython-310.pyc,, +torch/nested/_internal/__pycache__/nested_tensor.cpython-310.pyc,, +torch/nested/_internal/__pycache__/ops.cpython-310.pyc,, +torch/nested/_internal/__pycache__/sdpa.cpython-310.pyc,, +torch/nested/_internal/nested_tensor.py,sha256=ZA-_nQB5wxtMOJcbMA7z1VnALy5GOV9w3Ib6lRDC4qQ,15712 +torch/nested/_internal/ops.py,sha256=vGGD5iXkNtnDtIwHWzk4jX4aXeISOPeHbExkud3Hpes,38577 +torch/nested/_internal/sdpa.py,sha256=YNC9rlmi_ijXWF3hB0TPrZXKHbHP98L-rLkdyY7ZF0c,28384 +torch/nn/__init__.py,sha256=ImmrMbMIuaYDgDyEmwUNY0Mn6wpiEom5Sw_T3iH16TQ,2174 +torch/nn/__pycache__/__init__.cpython-310.pyc,, +torch/nn/__pycache__/_reduction.cpython-310.pyc,, +torch/nn/__pycache__/common_types.cpython-310.pyc,, +torch/nn/__pycache__/cpp.cpython-310.pyc,, +torch/nn/__pycache__/functional.cpython-310.pyc,, +torch/nn/__pycache__/grad.cpython-310.pyc,, +torch/nn/__pycache__/init.cpython-310.pyc,, +torch/nn/__pycache__/parameter.cpython-310.pyc,, +torch/nn/_reduction.py,sha256=GFubErXF9m01WzUcxNSAHVq6YQxsHxdoLqO2VVBzml0,1556 +torch/nn/attention/__init__.py,sha256=N8ti9h48wfcE6Sf30HqvtRG9Nmks1PL3lm9p1oL54Oc,4598 +torch/nn/attention/__pycache__/__init__.cpython-310.pyc,, +torch/nn/attention/__pycache__/_utils.cpython-310.pyc,, +torch/nn/attention/__pycache__/bias.cpython-310.pyc,, +torch/nn/attention/_utils.py,sha256=8gyZepjGT0W3yiy3-R19p7AvBNNrkJTwWQtuwYZV7t4,2016 +torch/nn/attention/bias.py,sha256=mH-HX-U3tc6vSRNH0WfQr0uCLS1ioM-Iq6Z2osqvsno,13036 +torch/nn/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/nn/backends/__pycache__/__init__.cpython-310.pyc,, +torch/nn/backends/__pycache__/thnn.cpython-310.pyc,, +torch/nn/backends/thnn.py,sha256=BKzqnDMCwANVgNYTMKILvPvBnqJDBY0rM7ePUYw1jRo,118 +torch/nn/common_types.py,sha256=M8LbPzJIu9jl-KN2mOHBTenSqJpP4rs8f7f0d1CWr1E,1841 +torch/nn/cpp.py,sha256=sf94YYXT7wwJ7RfBKkQPa8AHMruOCJ4U7SQI1njZgNU,2990 +torch/nn/functional.py,sha256=FsWlu8leM_0rIWF5npQIO1FZJ9kDcsCWfYDq1Qc-3KM,226702 +torch/nn/functional.pyi,sha256=2ukaLDFkzNHvkx-xo-CWazhxahXecWxjV7ZIOwRSldk,23340 +torch/nn/grad.py,sha256=nh0xSnQ2CdcO-bTvkZeQMASe0AfUEY82nQVW66lXPU8,9683 +torch/nn/init.py,sha256=c69QUwndxu9BKWgpNrdEBXDNDJ1SyN4WvJphMArT9MI,21827 +torch/nn/intrinsic/__init__.py,sha256=OhtaKp08Bf-FKk-eNcvNujWkhyU5bkFvkfNkUMX8lLA,1072 +torch/nn/intrinsic/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/modules/__init__.py,sha256=2JlBSE6zO591fF36hPL7DmyXt4ZbTJbJ3u6xiS4eBA4,678 +torch/nn/intrinsic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/modules/__pycache__/fused.cpython-310.pyc,, +torch/nn/intrinsic/modules/fused.py,sha256=uqYu7W0MolWDMdw8kTeFAf_9vpjEW66vwMdZMEmuHIY,901 +torch/nn/intrinsic/qat/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/nn/intrinsic/qat/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/qat/modules/__init__.py,sha256=k99vQqwhgrdNcCFhUs9xb82U_Y1G4LCTbkZJ3gaEgNI,546 +torch/nn/intrinsic/qat/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/qat/modules/__pycache__/conv_fused.cpython-310.pyc,, +torch/nn/intrinsic/qat/modules/__pycache__/linear_fused.cpython-310.pyc,, +torch/nn/intrinsic/qat/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/nn/intrinsic/qat/modules/conv_fused.py,sha256=OIq8fy6Y-0Md2pYfv2Zjygqx1_6olUFYP8f-xzneLUs,1174 +torch/nn/intrinsic/qat/modules/linear_fused.py,sha256=xc7XWxaIYj3WT7jlERgDfuPv6oym8qEo7HBr1emNrIw,454 +torch/nn/intrinsic/qat/modules/linear_relu.py,sha256=gVTtqk0DP6CNgQaecePiKZbMqUHJht8qZbP7qvMEVNc,454 +torch/nn/intrinsic/quantized/__init__.py,sha256=Uf-JCGsr6NGF0RIlvULtAnRljdju3ikCCKWKDmnN0tg,279 +torch/nn/intrinsic/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/quantized/dynamic/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/nn/intrinsic/quantized/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/quantized/dynamic/modules/__init__.py,sha256=lkMt6s828aFw7-gWI756-da8_85esiNfiBZvWYXTZTY,69 +torch/nn/intrinsic/quantized/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/quantized/dynamic/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/nn/intrinsic/quantized/dynamic/modules/linear_relu.py,sha256=mAk1IaHbDUbydRywsAoC5i_lkWmp7BbH1Wmnuoxh0e0,96 +torch/nn/intrinsic/quantized/modules/__init__.py,sha256=f-CbY2BNb5WU5_IEc_CxZYdXFcautBTg1eKGCxBTrtA,253 +torch/nn/intrinsic/quantized/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/intrinsic/quantized/modules/__pycache__/bn_relu.cpython-310.pyc,, +torch/nn/intrinsic/quantized/modules/__pycache__/conv_relu.cpython-310.pyc,, +torch/nn/intrinsic/quantized/modules/__pycache__/linear_relu.cpython-310.pyc,, +torch/nn/intrinsic/quantized/modules/bn_relu.py,sha256=Lu4COiO8pvzJHny9UXqXXv6v9kj6Qc6PvCsJdtujXHo,153 +torch/nn/intrinsic/quantized/modules/conv_relu.py,sha256=4Xxx-Wp87tMHyKcKb4xb0G5jjbFXgox2CCsDdJhyNvE,234 +torch/nn/intrinsic/quantized/modules/linear_relu.py,sha256=9r7rHon00-NJ9wp1qVMRjOxMjiSbA4h_EzS2ecCv7nc,88 +torch/nn/modules/__init__.py,sha256=QYJNhH5iArQl7q6yknUUJGyCrcXIYy4x9kJV82JmiNU,5349 +torch/nn/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/modules/__pycache__/_functions.cpython-310.pyc,, +torch/nn/modules/__pycache__/activation.cpython-310.pyc,, +torch/nn/modules/__pycache__/adaptive.cpython-310.pyc,, +torch/nn/modules/__pycache__/batchnorm.cpython-310.pyc,, +torch/nn/modules/__pycache__/channelshuffle.cpython-310.pyc,, +torch/nn/modules/__pycache__/container.cpython-310.pyc,, +torch/nn/modules/__pycache__/conv.cpython-310.pyc,, +torch/nn/modules/__pycache__/distance.cpython-310.pyc,, +torch/nn/modules/__pycache__/dropout.cpython-310.pyc,, +torch/nn/modules/__pycache__/flatten.cpython-310.pyc,, +torch/nn/modules/__pycache__/fold.cpython-310.pyc,, +torch/nn/modules/__pycache__/instancenorm.cpython-310.pyc,, +torch/nn/modules/__pycache__/lazy.cpython-310.pyc,, +torch/nn/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/modules/__pycache__/loss.cpython-310.pyc,, +torch/nn/modules/__pycache__/module.cpython-310.pyc,, +torch/nn/modules/__pycache__/normalization.cpython-310.pyc,, +torch/nn/modules/__pycache__/padding.cpython-310.pyc,, +torch/nn/modules/__pycache__/pixelshuffle.cpython-310.pyc,, +torch/nn/modules/__pycache__/pooling.cpython-310.pyc,, +torch/nn/modules/__pycache__/rnn.cpython-310.pyc,, +torch/nn/modules/__pycache__/sparse.cpython-310.pyc,, +torch/nn/modules/__pycache__/transformer.cpython-310.pyc,, +torch/nn/modules/__pycache__/upsampling.cpython-310.pyc,, +torch/nn/modules/__pycache__/utils.cpython-310.pyc,, +torch/nn/modules/_functions.py,sha256=gw1eYGf3hmvXsiqOnan4FjH0orv3CtTjyJK_aO9-AGI,11788 +torch/nn/modules/activation.py,sha256=kKWXswYjygLk0WXaYgKJi7MkJ52cLuvQFhiCEBGHAqE,56140 +torch/nn/modules/adaptive.py,sha256=iAV8T9Lj0UsiD1QqgchO8jipjnXYBG4OmhsMOhi4p_A,12164 +torch/nn/modules/batchnorm.py,sha256=86-KfocXjTGyX1tuhP8V5LgHPopSAJb5MRyVC_6FzGE,37988 +torch/nn/modules/channelshuffle.py,sha256=m3FxZt66bbFdBTsmeT0cNMSnVklQZbr-ywZX3ZRheU8,1432 +torch/nn/modules/container.py,sha256=jioYKYEa-YRcuL-SAM5m68rJHvx9a6XXiyHMcLNFQPY,34400 +torch/nn/modules/conv.py,sha256=LermiaZLmN4nUEAfq9EtonnB3Zu8lu2a7DxDlGnQT6g,72637 +torch/nn/modules/distance.py,sha256=r81R0UHbLtZC8BYg0_aXbRSDV5ZMRABas26P2SSX144,3249 +torch/nn/modules/dropout.py,sha256=2k-cedcok4T7qr08W-FtvplQg1cFoRzZcRnfKS-fY70,11127 +torch/nn/modules/flatten.py,sha256=vboG7J4t73SaWpJ9XTyYVZVuAs72kdQUs4ku85b3DBw,5404 +torch/nn/modules/fold.py,sha256=7WWF_N9ZvXpJwzILMZjYqCZ18g4I_Oajcj3m1ge2rA4,12763 +torch/nn/modules/instancenorm.py,sha256=VOXRMU9Plo-L10MT3q9bcrH0f8EQ-i1IS6bk89SmsmQ,19967 +torch/nn/modules/lazy.py,sha256=1ykJGHeSKFromxpQ0F7WandVOFHGjqUJe1DhCsOa7Ck,11731 +torch/nn/modules/linear.py,sha256=ht3GAQ6URZDrOesSv82mcWvl2oNKDzPETAVOmP-tDGU,10528 +torch/nn/modules/loss.py,sha256=liP6f5I5HrZsb8Fjc8PE0MUb2MV5JUkgUymcSGszPqI,91648 +torch/nn/modules/module.py,sha256=7ORbI_eCkBZCTTHSbNa9MX_bg6QGlTtwDjS6VneQccQ,113814 +torch/nn/modules/normalization.py,sha256=kbxlAZxeICDVqC0tROMw0jroSki5hBowUY9-3LTwLbs,11374 +torch/nn/modules/padding.py,sha256=AcImHN9duhY3C44SVqqvDgb_e0OHe6y01I1ZL0R1HMk,30269 +torch/nn/modules/pixelshuffle.py,sha256=QF51OZYKxLmoPTpamQDQCRBsEIk19EPxwnj02paq6Rc,3677 +torch/nn/modules/pooling.py,sha256=RyXrEBH2OZGtJ8jq1pKlQ_09Jm7gcGiSjHYQRkAul90,57576 +torch/nn/modules/rnn.py,sha256=zyfdPDM9oFwRfWAjKugD3fRMoBv15FajIxT9mcd8k9Q,70010 +torch/nn/modules/sparse.py,sha256=_qG23MtG3wN5lHMUJRj5MMvQvKl_E3vbQO6orRpgtCU,23391 +torch/nn/modules/transformer.py,sha256=yiNuYtwCZp3KleezvyORVbn4Z-reTdKQJ1A4lgEo55Y,47154 +torch/nn/modules/upsampling.py,sha256=pfeqMkh32ZxDltVK0jy878h63V1yyaE2YyEOLyW76u4,11312 +torch/nn/modules/utils.py,sha256=s5CkwAReedaxpSZRExiqogoG2s9A1YLkwUWbxsUdLRc,2578 +torch/nn/parallel/__init__.py,sha256=km7Mu0iR61itcFw6ElJaZn_j8qTXQHy518vX0MUyWqI,645 +torch/nn/parallel/__pycache__/__init__.cpython-310.pyc,, +torch/nn/parallel/__pycache__/_functions.cpython-310.pyc,, +torch/nn/parallel/__pycache__/comm.cpython-310.pyc,, +torch/nn/parallel/__pycache__/data_parallel.cpython-310.pyc,, +torch/nn/parallel/__pycache__/distributed.cpython-310.pyc,, +torch/nn/parallel/__pycache__/parallel_apply.cpython-310.pyc,, +torch/nn/parallel/__pycache__/replicate.cpython-310.pyc,, +torch/nn/parallel/__pycache__/scatter_gather.cpython-310.pyc,, +torch/nn/parallel/_functions.py,sha256=7_rjdDRBmXeswoIL8fHcEZEU-O7Hv0xx54h-63EAms0,4829 +torch/nn/parallel/comm.py,sha256=0N9-PQh93EO6nJmNvvEO9vco6zICTM600Sj8bo2bYaQ,10646 +torch/nn/parallel/data_parallel.py,sha256=D_KG9BZNkvBJderH7ozdN4kw1ncsx0RlpQRWs0FKJrw,11541 +torch/nn/parallel/distributed.py,sha256=AKsVpPtWsLlERmmFcrAP9f2HpgPeRWCiz3HuLHwv_Wo,106086 +torch/nn/parallel/parallel_apply.py,sha256=lckEOTyvLiz1NJ6Ka-HBCHF8X02x4kwkt_67wOichRo,4292 +torch/nn/parallel/replicate.py,sha256=dMESH0_hJHIrYhd9bO1PUomybq4AXrNZmtfWtLhHbuk,6757 +torch/nn/parallel/scatter_gather.py,sha256=Hqcd5I2BRqORIWOT36G2W1xpHWGZ-PaBgBiYndcXp4M,4296 +torch/nn/parameter.py,sha256=J-3ZmMuCFLiWnNMBNMuTXDr3CW1rOObHXNqVjUM7dkA,9495 +torch/nn/parameter.pyi,sha256=arTEdWgH39nSpMrNyOKzXp8W5MxkRHDb0tFCDTjkgbw,909 +torch/nn/qat/__init__.py,sha256=H93oKQuFv32Gn9f1PM3z0Rb33HKk2edbGo9kUEXGFcU,367 +torch/nn/qat/__pycache__/__init__.cpython-310.pyc,, +torch/nn/qat/dynamic/__init__.py,sha256=xuz1hBmzVjgh_xTiw4wLtCKcgXgXilirgUQEmjxzLoY,187 +torch/nn/qat/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/nn/qat/dynamic/modules/__init__.py,sha256=juJpue0ixFC8Vq3-HlcHdDRBPTd7H2jLGvdyQFwQzgk,49 +torch/nn/qat/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/qat/dynamic/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/qat/dynamic/modules/linear.py,sha256=6UAtM_9i3TRoQPuOyDnWtXTvNdRYZekKqBTopaHXLxQ,415 +torch/nn/qat/modules/__init__.py,sha256=lsJndKS9ItNcxvZ-93so11_Z3lIQtJRH-Nm5Qn-TP-0,587 +torch/nn/qat/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/qat/modules/__pycache__/conv.cpython-310.pyc,, +torch/nn/qat/modules/__pycache__/embedding_ops.cpython-310.pyc,, +torch/nn/qat/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/qat/modules/conv.py,sha256=EFUZUP7ZVkZF_SxcB-Tto-S8kU9cEUetR-xeFPH63_M,485 +torch/nn/qat/modules/embedding_ops.py,sha256=gVlvELAJNPjJck2TLnDLQNJJ8R_2lncZnY8U_ly6Y4Y,506 +torch/nn/qat/modules/linear.py,sha256=W18E_sx1dwIj03StoKVN_VPKlJYq1hoy4KTCobCbA7M,391 +torch/nn/quantizable/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/nn/quantizable/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantizable/modules/__init__.py,sha256=5H8qKn-MWNN8aECtVfBqeV5pK04GxpTezefPZl9xQyE,253 +torch/nn/quantizable/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantizable/modules/__pycache__/activation.cpython-310.pyc,, +torch/nn/quantizable/modules/__pycache__/rnn.cpython-310.pyc,, +torch/nn/quantizable/modules/activation.py,sha256=JvTGKm47nxF0xOdaJd-rVls-jrJFtYGu-YTZtrs5agI,439 +torch/nn/quantizable/modules/rnn.py,sha256=l1sllwPt0_IBSTm0KJKNKDsIA1vIyg6EFzf0IXbhIDM,475 +torch/nn/quantized/__init__.py,sha256=cwMqCJdFaRQQGM1j4MzVepOmu5t1HIX60-3T0WW-jgc,771 +torch/nn/quantized/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/__pycache__/functional.cpython-310.pyc,, +torch/nn/quantized/_reference/__init__.py,sha256=M0iylhjuqtPcbO2pAVdDg9n9e1ET359nQ9txOEErmMo,37 +torch/nn/quantized/_reference/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__init__.py,sha256=HLAQUjUeDJLCVsRst6ualEUeT9hj_uRV-oMF56Asz4I,988 +torch/nn/quantized/_reference/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__pycache__/conv.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__pycache__/rnn.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__pycache__/sparse.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/__pycache__/utils.cpython-310.pyc,, +torch/nn/quantized/_reference/modules/conv.py,sha256=tfdo_boThHJ-YYIzQmcx6STG8cOJS-NYCMTcysqTPp4,934 +torch/nn/quantized/_reference/modules/linear.py,sha256=Cu-oS3rGRNtFQX8C8yBiLIeORYswqNnFbVw3ds6PMKQ,450 +torch/nn/quantized/_reference/modules/rnn.py,sha256=73pD23A2fMFnmjnjoK_yP3tdT0_8cDNXWmYEHJrtY2c,770 +torch/nn/quantized/_reference/modules/sparse.py,sha256=0mgV1abz95CVu_NJ-uptCtvEzUQiMOiacJvtuqClM7M,525 +torch/nn/quantized/_reference/modules/utils.py,sha256=FirWppy6vEhrbY-mUDlxyFasKMc0750KeUrR0YA_7Y4,792 +torch/nn/quantized/dynamic/__init__.py,sha256=lN8JfmyIwtMWNsOD0hWGgKMVPUXuUb5cu6QOvIlEJxg,58 +torch/nn/quantized/dynamic/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/dynamic/modules/__init__.py,sha256=ubQ6S0qDpPNDkZHnJqgQhjhZI8mEbrANilUqnVggvTE,1037 +torch/nn/quantized/dynamic/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/dynamic/modules/__pycache__/conv.cpython-310.pyc,, +torch/nn/quantized/dynamic/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/quantized/dynamic/modules/__pycache__/rnn.cpython-310.pyc,, +torch/nn/quantized/dynamic/modules/conv.py,sha256=OluHe7u-4cAeV1Isqh3hg5rEQytXPOwRpxuizKeczIc,882 +torch/nn/quantized/dynamic/modules/linear.py,sha256=9hI6zBpmeAs_hCwTr0QeEm7ouFfYjjGq0QHw7lwPvrs,447 +torch/nn/quantized/dynamic/modules/rnn.py,sha256=pM8tQT2LQL5VvqCTjuEUfAdsBUdy6tZzKaxZrp6NXfE,1094 +torch/nn/quantized/functional.py,sha256=YLagkINzH1ksH0zcEEizTr0Wdu8gvziqPkx-elbUkJE,276 +torch/nn/quantized/modules/__init__.py,sha256=1svpPm2TxoH2efXMMbCFo4XRG9MW9VGh93dTItqRW44,2434 +torch/nn/quantized/modules/__pycache__/__init__.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/activation.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/batchnorm.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/conv.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/dropout.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/embedding_ops.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/functional_modules.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/linear.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/normalization.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/rnn.cpython-310.pyc,, +torch/nn/quantized/modules/__pycache__/utils.cpython-310.pyc,, +torch/nn/quantized/modules/activation.py,sha256=XRi47-nXXUz223d1fhqeWOl5pa5aItGxp4IvchgY8LQ,855 +torch/nn/quantized/modules/batchnorm.py,sha256=2-loBNbcXCZdkJLbFxq9V-xbQCQ9fIVMQEiQAkrV4J4,488 +torch/nn/quantized/modules/conv.py,sha256=ox8DKxQDt_UNhc2iWVtQmkSAy7eNLDs-y91_FWHRsYo,883 +torch/nn/quantized/modules/dropout.py,sha256=jQW8VHFmOuihBFOPL3p4SwR0KUqKHXAQOuTBWaxMr7Q,441 +torch/nn/quantized/modules/embedding_ops.py,sha256=noT7AglbpFbKlqZZPDu9VjpAQOaiSu67qL4b8GLN7IM,639 +torch/nn/quantized/modules/functional_modules.py,sha256=5dwT8ysnqbRkc0gQdjkzmcHNGYiJfoLj6z_mvC5ay7w,656 +torch/nn/quantized/modules/linear.py,sha256=Eg2rcE7jrav3zUvuTXuG4lX9PbyBICvA0XBWFXB2Juc,528 +torch/nn/quantized/modules/normalization.py,sha256=Q5HvoR1C07ymBFskdo8y2TUzp_TvTV9D2ATY78axB74,797 +torch/nn/quantized/modules/rnn.py,sha256=NWI5IuH_qaC1YD1ROeoUbodbN3yS0MrZKOhXLmGfPDo,411 +torch/nn/quantized/modules/utils.py,sha256=Zm1edjXDuRsVICYjgkiKSRMCGbIeFLDT4-WquDruY4E,702 +torch/nn/utils/__init__.py,sha256=uIns40AAgT7yoCRESGYiRmpDIAE1BrRJyyeA41TI8as,1073 +torch/nn/utils/__pycache__/__init__.cpython-310.pyc,, +torch/nn/utils/__pycache__/_deprecation_utils.cpython-310.pyc,, +torch/nn/utils/__pycache__/_named_member_accessor.cpython-310.pyc,, +torch/nn/utils/__pycache__/_per_sample_grad.cpython-310.pyc,, +torch/nn/utils/__pycache__/clip_grad.cpython-310.pyc,, +torch/nn/utils/__pycache__/convert_parameters.cpython-310.pyc,, +torch/nn/utils/__pycache__/fusion.cpython-310.pyc,, +torch/nn/utils/__pycache__/init.cpython-310.pyc,, +torch/nn/utils/__pycache__/memory_format.cpython-310.pyc,, +torch/nn/utils/__pycache__/parametrizations.cpython-310.pyc,, +torch/nn/utils/__pycache__/parametrize.cpython-310.pyc,, +torch/nn/utils/__pycache__/prune.cpython-310.pyc,, +torch/nn/utils/__pycache__/rnn.cpython-310.pyc,, +torch/nn/utils/__pycache__/spectral_norm.cpython-310.pyc,, +torch/nn/utils/__pycache__/stateless.cpython-310.pyc,, +torch/nn/utils/__pycache__/weight_norm.cpython-310.pyc,, +torch/nn/utils/_deprecation_utils.py,sha256=Ew7-U21cOKSRYgVsE8-Ze6ttd-CNc7l0Zv6jh5D-7Ng,1646 +torch/nn/utils/_expanded_weights/__init__.py,sha256=xky9oo9e6irPwJixwzIyHy-3mUoPUdQWpl6U5YNavNA,451 +torch/nn/utils/_expanded_weights/__pycache__/__init__.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/conv_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/conv_utils.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/embedding_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/expanded_weights_impl.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/expanded_weights_utils.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/group_norm_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/instance_norm_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/layer_norm_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/__pycache__/linear_expanded_weights.cpython-310.pyc,, +torch/nn/utils/_expanded_weights/conv_expanded_weights.py,sha256=a8RAEv4PSgsAymvFk5VmNTkZSxZwb6SwdHTRORRGPpc,2448 +torch/nn/utils/_expanded_weights/conv_utils.py,sha256=G4gVN35maXgmmPWfa9o9_vlchqkuyj5zEwGNrfZg5R8,9707 +torch/nn/utils/_expanded_weights/embedding_expanded_weights.py,sha256=DKYq63Ulelc9wvcnSbcqZQCAvCigjygeFLdo8ePzqeY,2473 +torch/nn/utils/_expanded_weights/expanded_weights_impl.py,sha256=55iV_xII8T76cazJkEOwldhz39Sm3B_LC_R9awhC9qk,5859 +torch/nn/utils/_expanded_weights/expanded_weights_utils.py,sha256=h7JKp5PPRvh7Xv7kTk9NHAv0f5U1wvbH7NAnlBwwO5I,7324 +torch/nn/utils/_expanded_weights/group_norm_expanded_weights.py,sha256=1j5LeIf2d74n1lzvmOQTPTurSfJk2FIwV2oc8A8HFBY,2938 +torch/nn/utils/_expanded_weights/instance_norm_expanded_weights.py,sha256=kXK4IWsAOENf2QbNTPE22yUcIgTQucOorblmxBHjf58,3249 +torch/nn/utils/_expanded_weights/layer_norm_expanded_weights.py,sha256=4icvbutO1rDJDq0vZaYRRhr4KTNPsGJTg451O7N8uQs,2861 +torch/nn/utils/_expanded_weights/linear_expanded_weights.py,sha256=i5_GUDn53xkOs7_A1ozcDu1gcPorIa_kxIKI8ZiAaNA,2072 +torch/nn/utils/_named_member_accessor.py,sha256=W47nDfSZSZiYcNMP_JztWQq7230nfbZqkVSFUuEnYaM,14217 +torch/nn/utils/_per_sample_grad.py,sha256=p3M4ooliRYZhLrEXOBVNIzj8-HEQ2kRrD0JMQ0WVzdg,5587 +torch/nn/utils/clip_grad.py,sha256=pPwfv7TnvzxOoGwVEMu8Y3JovTRsaCInjK3TvtIHLtw,7119 +torch/nn/utils/convert_parameters.py,sha256=sbhhw_DqSC5kvzeKZQWbj-g9XG8ZAKbpDMXcndjGZyA,3152 +torch/nn/utils/fusion.py,sha256=smHgljjl5qXG-sQUkqq1HkkzOcSj5eyCwQUtxBi2ows,6163 +torch/nn/utils/init.py,sha256=QOETK_0ezJz1AHewx-FHiI2t9nNNat-bign_yX1hpvo,2224 +torch/nn/utils/memory_format.py,sha256=lRtqUO4BS2nX90KTseS98tsUwZHEpLta3fgQ9CNBPBk,7761 +torch/nn/utils/parametrizations.py,sha256=kjbyUi1uv6HsFNfh2yVmW9Vj2ofaDjloa93DYvS9bQY,25189 +torch/nn/utils/parametrize.py,sha256=TdgaHZETc1oQjq0gTQoY7AkpGOd5kcXh0La0V2wf78k,34894 +torch/nn/utils/prune.py,sha256=JpwZHmO_KpvK01T-GDEfYZ4P4m1MuVmSYizIP4rJqsc,57827 +torch/nn/utils/rnn.py,sha256=Ngr9kNHQdnGt9Sx8sxmKn9CRB_WhvdL931nzzPX9WuQ,21263 +torch/nn/utils/spectral_norm.py,sha256=Ox_m89uJAWA2XnFTIOQIgmQ_ItWL3QN8KlkIqI0IyFk,14495 +torch/nn/utils/stateless.py,sha256=1su0IAsgmOkXYFgrC24yDAwE932LWQk9PRmAqy3kbGE,11004 +torch/nn/utils/weight_norm.py,sha256=KV8hbJGvMNJGCADyTLDJYrQyUMoIs6LZ2ap37otYS74,5691 +torch/onnx/__init__.py,sha256=yx1AdhLFvW_ion2jAPJpxOG7RJ9DhgzqTRXlbXhXEso,4619 +torch/onnx/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/__pycache__/_constants.cpython-310.pyc,, +torch/onnx/__pycache__/_deprecation.cpython-310.pyc,, +torch/onnx/__pycache__/_experimental.cpython-310.pyc,, +torch/onnx/__pycache__/_exporter_states.cpython-310.pyc,, +torch/onnx/__pycache__/_globals.cpython-310.pyc,, +torch/onnx/__pycache__/_onnx_supported_ops.cpython-310.pyc,, +torch/onnx/__pycache__/_type_utils.cpython-310.pyc,, +torch/onnx/__pycache__/errors.cpython-310.pyc,, +torch/onnx/__pycache__/operators.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_caffe2.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_helper.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset10.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset11.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset12.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset13.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset14.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset15.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset16.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset17.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset18.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset7.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset8.cpython-310.pyc,, +torch/onnx/__pycache__/symbolic_opset9.cpython-310.pyc,, +torch/onnx/__pycache__/utils.cpython-310.pyc,, +torch/onnx/__pycache__/verification.cpython-310.pyc,, +torch/onnx/_constants.py,sha256=FF3OjL47FAo9tIYd64fvWbUqS8Skzp0OQ77PLC-cgys,608 +torch/onnx/_deprecation.py,sha256=1c6-sbkqIzuubf3QvMt3zaQf36IlOWDZ8j83-LkCiwU,2033 +torch/onnx/_experimental.py,sha256=UPsO6P4mL7RiLdoRMWkX5qxNyttMdUIkKsQ5_ZQ4rpE,1042 +torch/onnx/_exporter_states.py,sha256=RdYRniYLGLlC8GNoRzkG0bqvPT56Qr1RZ5Ma_nE3aPs,1365 +torch/onnx/_globals.py,sha256=RNh59e1PYIeZnrlkiqu4yThnD7WLwkiF9GHFy3-iwyc,2968 +torch/onnx/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/onnx/_internal/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/_beartype.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/exporter.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/io_adapter.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/jit_utils.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/onnx_proto_utils.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/onnxruntime.cpython-310.pyc,, +torch/onnx/_internal/__pycache__/registration.cpython-310.pyc,, +torch/onnx/_internal/_beartype.py,sha256=GiOdWaEZD0azS-Tf4XqXokoM5qhPyQGKU6cQM5bVoU4,4623 +torch/onnx/_internal/diagnostics/__init__.py,sha256=-zJC6TxIO-LS1-gDRI_t3O2WZSAnojr5AH71UwUh4zc,433 +torch/onnx/_internal/diagnostics/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/__pycache__/_diagnostic.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/__pycache__/_rules.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/_diagnostic.py,sha256=ko3GsXuvv4xbrAXqF_le_gw9ER3v4L4wB3sMd1xuQdo,7322 +torch/onnx/_internal/diagnostics/_rules.py,sha256=7wwJn3QF3Ab6qzeDynJ9cUPvHTXVolLDTk_yTBFzlvA,37157 +torch/onnx/_internal/diagnostics/infra/__init__.py,sha256=_zOoWhG-xR49LIA_9wDWEgPDF6nwRekLNUbgwPMfUA4,573 +torch/onnx/_internal/diagnostics/infra/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/__pycache__/_infra.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/__pycache__/context.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/__pycache__/decorator.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/__pycache__/formatter.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/__pycache__/utils.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/_infra.py,sha256=a8V6hknKungqJx9yg0CwtGI2-Sy5D4g3978ZeXSvsRs,9757 +torch/onnx/_internal/diagnostics/infra/context.py,sha256=CkipaHyHP3Ask-QIWBjCZMpI83FpYgQQFfaV_wMqsrU,16305 +torch/onnx/_internal/diagnostics/infra/decorator.py,sha256=hvJt0k5BBtTsARf4o9WnBm6nn9P9Ry3cZiEBFAe_2xA,5542 +torch/onnx/_internal/diagnostics/infra/formatter.py,sha256=zVtLX0O5kO7rru4DjOiX8fiwhKRJYPm3c5zA06w3C4g,3014 +torch/onnx/_internal/diagnostics/infra/sarif/__init__.py,sha256=Uj_QD1YO_8cyF_3xcoyZ05wi5uBgrwKP9fNZrpOwDS4,4984 +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_address.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_artifact.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_artifact_change.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_artifact_content.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_artifact_location.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_attachment.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_code_flow.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_configuration_override.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_conversion.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge_traversal.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_exception.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_properties.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_property_file_reference.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_property_file_references.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_fix.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_graph.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_graph_traversal.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_invocation.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_location.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_location_relationship.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_logical_location.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_message.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_multiformat_message_string.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_node.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_notification.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_physical_location.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_property_bag.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_rectangle.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_region.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_replacement.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_configuration.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor_reference.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor_relationship.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result_provenance.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_run.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_run_automation_details.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_sarif_log.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_special_locations.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_stack.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_stack_frame.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_suppression.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_thread_flow.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_thread_flow_location.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_tool.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_tool_component.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_tool_component_reference.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_translation_metadata.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_version_control_details.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_request.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_response.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/version.cpython-310.pyc,, +torch/onnx/_internal/diagnostics/infra/sarif/_address.py,sha256=ws5WXm5Z4sCx9ZVtCT67FluQUInkR2zKDaMW-QUNa2g,1748 +torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py,sha256=0JJfuGrzAxAmPQcCi29zGoL1MTDusEe0bkd4JZ8Q0tQ,3026 +torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py,sha256=l95-2ctz3d44esToAwN35lbeE6HkAXuETBgezH-ahFc,893 +torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py,sha256=GI4NBRnQD3IEOZdFnny3XNh3gZW_g5LPRYImZ4Y8h3k,1012 +torch/onnx/_internal/diagnostics/infra/sarif/_artifact_location.py,sha256=U9qsrtJXuzR3iTcSYPOmD9Lbih2NBJ6OPlJToDfAXcQ,1061 +torch/onnx/_internal/diagnostics/infra/sarif/_attachment.py,sha256=hLFkgETVh3cCL94A0emFQqAEfcxC2RT0gqdMuLlkxzA,1213 +torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py,sha256=qZJ7C8EL9m1tYrf_sw66PbB3ilJ2fClEAKh3UYcNFKk,935 +torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py,sha256=BREXBUAT2cSNZlpZJ1b59rcGkbooMI_gdusu_Cslcrg,1004 +torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py,sha256=Z3pDN9OPAhaWAGaWlrRNKVOdkLIuF2aAr2pWJRMWBCI,1162 +torch/onnx/_internal/diagnostics/infra/sarif/_edge.py,sha256=av5c6koZeuTyRQCgE6fDBOk-JiOFhyHLx4_hwuuC2DY,983 +torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py,sha256=r2PBm018laYQPM_U8aAevhNx5T57R2lBrTQ2Vqv4b4Y,1083 +torch/onnx/_internal/diagnostics/infra/sarif/_exception.py,sha256=O70XX0b5HkMaSfaQvmnfKx5KxYgQqQ41gXfgOXToyj8,1168 +torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py,sha256=lVFUY8UijDceaBZwrfwVfYGmwk-fzItORnEbjHsr3pY,3816 +torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_reference.py,sha256=hpSt2mZnZRaZ0KNDxYdGUVF0yfarnRNq0nFAhrqmCpI,1120 +torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py,sha256=_VSqpoX1i1-_PCSgalnEhBGMHSas8QUnz5kAoTaY0pk,3901 +torch/onnx/_internal/diagnostics/infra/sarif/_fix.py,sha256=FFAiJYI4CeDtIFld-dKk3HggBBPg4eCcMV3PCOAxmvQ,1069 +torch/onnx/_internal/diagnostics/infra/sarif/_graph.py,sha256=AXliROAwGC_Ff2chkUxqwdmQxswbQ2rqGT_ACsaWpfU,1090 +torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py,sha256=4k00If3e_57WKUBFJncbBjfA5e5ALlpQvoDqb0uCNhU,1423 +torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py,sha256=eLxD0KHZVXD5Puw7VfDMvYbAaXhiZrU_h1cLWf8SBks,4597 +torch/onnx/_internal/diagnostics/infra/sarif/_location.py,sha256=S0uE-9hqa4EU10k_8GSrlQ4bPx7ILk_zar7mCqmGmgw,1610 +torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py,sha256=TTtVOdV-Ht7IP7lyRBGE-UUc2mN_Gb_HeUy9DOxsQIY,964 +torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py,sha256=spq1Legx7q1euHSPpQkY4ZnE0jSrZPtDLY5CoVgcBRI,1314 +torch/onnx/_internal/diagnostics/infra/sarif/_message.py,sha256=VO4FTcUK-7Wl3Diom7lYmuYBjMfa-KwjBY9W1n2TQvk,1062 +torch/onnx/_internal/diagnostics/infra/sarif/_multiformat_message_string.py,sha256=V9d9I84_iYcDPwOs7KUWJ2DjDVcSmNt-Kq4Xaggd_ps,805 +torch/onnx/_internal/diagnostics/infra/sarif/_node.py,sha256=ABeCrjO8hS5B-83MFoUv8gd5IoLMDlbaK1LcWwqS6Mo,1075 +torch/onnx/_internal/diagnostics/infra/sarif/_notification.py,sha256=EptwUCa06LGuLKKfX1on41MZgfa0Lu-fABjlQkXpKlE,1934 +torch/onnx/_internal/diagnostics/infra/sarif/_physical_location.py,sha256=XV3galBCsbtnZ57PJoRbi82MgXYhaaifbGDt6HowLdQ,1337 +torch/onnx/_internal/diagnostics/infra/sarif/_property_bag.py,sha256=lsjMzdnz9g3dIMw9Mtm-0bTU5mQGSZNhEnydYRGyF8A,496 +torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py,sha256=k0VAKUBS4Sk1CWgYfehzAzCZxxOL6uzKM1V0Bkk_GZ4,1159 +torch/onnx/_internal/diagnostics/infra/sarif/_region.py,sha256=J3G25_1N--w2ueUGVGiazuTRUju47d1fJ-48HDgILT8,2031 +torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py,sha256=ydAQKhmy2Mhq0GaPr62wTQstlPQNafSvMh3HYI_VQrU,905 +torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py,sha256=4mShdhYP_MTlK6Xs22kaMej7a57ZCf2eafK7SSjfeG4,1136 +torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor.py,sha256=rUbnXljVoEizpgfmYu-dZOfkSNCkhXQwoAe4eIyUmFg,2746 +torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py,sha256=3mJpF08p5fjqYncR4qjCP7Kma9w3ZkGO9XMAiG5SiCo,1166 +torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py,sha256=y2iu9t6UuREodZkdJtaoNEXgU8Zb0Kd23YQ9gQJQtd4,1110 +torch/onnx/_internal/diagnostics/infra/sarif/_result.py,sha256=lDs8R4v0GxjIQrOw9iWngMbqUGPFotUaAbEoj_QsR4M,5068 +torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py,sha256=wtDg3jxzYu6yLglspmvn2Ul5qb3sl0NNXzet3QfKps8,1551 +torch/onnx/_internal/diagnostics/infra/sarif/_run.py,sha256=_1KntecS40dqYuLcIBpbheGIEXb_5913v-HJc3AvGvc,5306 +torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py,sha256=KRztrseIGyQm0JzBbAQJJ1-oqTwS9pt35MoXzwcpBF4,1136 +torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py,sha256=wsCKQQKrcr9EzvHiIkiNyqbW52yj56VJwsE6v5pEirE,1237 +torch/onnx/_internal/diagnostics/infra/sarif/_special_locations.py,sha256=3YNBPg7CwcivAIf-s6OKur4s-5_xgTvt3pa18qKeuv8,782 +torch/onnx/_internal/diagnostics/infra/sarif/_stack.py,sha256=F2PUk8ubWkIdcFFhZ80pER1iCas4z8O1xH5APb_y02c,859 +torch/onnx/_internal/diagnostics/infra/sarif/_stack_frame.py,sha256=cvgDZszoMaleh_D8UHJPYQ619IVayITX7rWOxEHljm0,1088 +torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py,sha256=GV1eMCGiusg5Ydb-jpewOltknZMKMLznVcFYBUWfluw,1249 +torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow.py,sha256=YD_0OTAvRygQBiWMylIJeELuYxkqAAakECFDPlI4yko,1351 +torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py,sha256=JEYgPHorvlV9zm8rI19-ecugrd_bb5fTxGhQ5jqjbA8,2517 +torch/onnx/_internal/diagnostics/infra/sarif/_tool.py,sha256=CkHTztGsphKqnKxTdVnEsf7IoLj8p-eH15R1puEjJSc,848 +torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py,sha256=x4lP0OcnvV0yBAlu2KkT26fgAR8UcwlwUM0r9Hz_lLM,4987 +torch/onnx/_internal/diagnostics/infra/sarif/_tool_component_reference.py,sha256=E_0IAvLbJZ2sDAbz04FgbrHW20DQX_DScF8tmbE8Eq8,947 +torch/onnx/_internal/diagnostics/infra/sarif/_translation_metadata.py,sha256=SHQNAX9iK8ptU_BkWYcSU-woXdrh3BCNYJUNEVKbON0,1494 +torch/onnx/_internal/diagnostics/infra/sarif/_version_control_details.py,sha256=N8lmfAcHW1BFZXxACnlKwlt1KveA3TL9uRDXoWQ8gEU,1436 +torch/onnx/_internal/diagnostics/infra/sarif/_web_request.py,sha256=d4Scw4N4JuZDGbDIOYQfhLXaPa2_mRUzRgi6B9XHK8Q,1543 +torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py,sha256=-RkuvmR7VQcJ5g56G-5K36T6GjnVTzrUGv7uNM3b3zk,1611 +torch/onnx/_internal/diagnostics/infra/sarif/version.py,sha256=RadhQc9OCzMr6CQB3Anc7bJo315qIHL9UWp7WHwxOL0,185 +torch/onnx/_internal/diagnostics/infra/utils.py,sha256=XsmfnWlCSybicUV4RaBghL0ilv4EboffICGJC3ZUuys,2505 +torch/onnx/_internal/exporter.py,sha256=HTw5MeyTbzHfIqFE55BXB4k9iTB3QYhLwBuWy4KTqy8,63666 +torch/onnx/_internal/fx/__init__.py,sha256=nDN5RQ1wcu4ktXSPWCLgPREAyDWHnhr1EOMqcKSVDZs,172 +torch/onnx/_internal/fx/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/_pass.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/decomposition_skip.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/decomposition_table.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/diagnostics.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/dynamo_graph_extractor.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/fx_onnx_interpreter.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/fx_symbolic_graph_extractor.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/onnxfunction_dispatcher.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/op_validation.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/patcher.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/registration.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/serialization.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/torch_export_graph_extractor.cpython-310.pyc,, +torch/onnx/_internal/fx/__pycache__/type_utils.cpython-310.pyc,, +torch/onnx/_internal/fx/_pass.py,sha256=bM6LOMT7JPudCdu_-chv-DBYr2B3JIUeP8LzUj7jm3s,12480 +torch/onnx/_internal/fx/analysis/__init__.py,sha256=Jgm9-UUuAYClQeIHVaLyJM9J47SiRoZiaXWxwQzvogo,107 +torch/onnx/_internal/fx/analysis/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/fx/analysis/__pycache__/unsupported_nodes.cpython-310.pyc,, +torch/onnx/_internal/fx/analysis/unsupported_nodes.py,sha256=MitmrB9JKi299ChRzL8HL0AnST1CCk3UtN3cY7JIMkU,3386 +torch/onnx/_internal/fx/decomposition_skip.py,sha256=J18EOh-ySFbeY2vf-4bcQfkIKCQZXHLuJ_TxIBJJbes,6680 +torch/onnx/_internal/fx/decomposition_table.py,sha256=O_OxRuwfB3bUDJ_8IDchc3aKD40AqENGqFKq1Fgkab8,5014 +torch/onnx/_internal/fx/diagnostics.py,sha256=IQY0hgB9ELQqKoxym_U9x0unIBABo8ChjJbNJslBtUI,8887 +torch/onnx/_internal/fx/dynamo_graph_extractor.py,sha256=h7j3_AM0zOQueSgnXepiovgGcSVh6bQduPye2ZS-3vw,8359 +torch/onnx/_internal/fx/fx_onnx_interpreter.py,sha256=nQrlIEeWFjOy0E1kbtzlE35I2JWvY-bGGqSdh6yWv1M,36254 +torch/onnx/_internal/fx/fx_symbolic_graph_extractor.py,sha256=XljQ6w6BQJsx-bU0ADmLU_kEBv6N_lVRHq-nldkx5EY,10201 +torch/onnx/_internal/fx/onnxfunction_dispatcher.py,sha256=rZiHMJfcWfY-6WxBFDq0IaJGimjGw1_M4GxhwcFL7HA,38273 +torch/onnx/_internal/fx/op_validation.py,sha256=glabnNDLiU9I7beAcI9-qlmrbnHss7Gnn9yDkbYDG7U,15782 +torch/onnx/_internal/fx/passes/__init__.py,sha256=Wcrdhlwv6ajt8Z2PjYTyOnzZ5cHwpnBHyCPoulf9_yk,551 +torch/onnx/_internal/fx/passes/__pycache__/__init__.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/_utils.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/decomp.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/functionalization.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/modularization.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/readability.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/type_promotion.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/__pycache__/virtualization.cpython-310.pyc,, +torch/onnx/_internal/fx/passes/_utils.py,sha256=0ttHCD1Nb2RgYLnS5RVp0Vis4Ajpg6WLRMiIP2PlUj0,4338 +torch/onnx/_internal/fx/passes/decomp.py,sha256=PpI7kRuZTHGqmU9H6bltp0vo0fCwRlwCvqKDmCqG4RM,3602 +torch/onnx/_internal/fx/passes/functionalization.py,sha256=V_u2mTUjtZZOC1p9W1hHrhU25EiCK0_JSyRDMQagXLE,6616 +torch/onnx/_internal/fx/passes/modularization.py,sha256=-1RzEfqMCH7bB8tCnEsbU_BUpq9iaacbQA88_iT-EhE,34131 +torch/onnx/_internal/fx/passes/readability.py,sha256=yoi_yZ6To7hDcd5Ax1SjprllSoiteAMAjfVt6uOxSGg,5941 +torch/onnx/_internal/fx/passes/type_promotion.py,sha256=9WHhLigu2iwPqj-Og8uEryhMx3Dm2Q47EAxZee2q8yY,67117 +torch/onnx/_internal/fx/passes/virtualization.py,sha256=iLkbIepvLXtsPFolb3wBO5gZGIRgWw_jPt_VX8oDlYE,3868 +torch/onnx/_internal/fx/patcher.py,sha256=Jm0oF_1oVw0QKW5IgOedTBMw4v8vExWbgi64HI7DIbU,5709 +torch/onnx/_internal/fx/registration.py,sha256=jHYsCI4p02qcCkOyX1wZy4sMumE-_WaFxd3dYoAtaTI,3167 +torch/onnx/_internal/fx/serialization.py,sha256=GhkY61UqhvdeEQyR56V_brKuComtKmI7mSCtJUmitrM,10144 +torch/onnx/_internal/fx/torch_export_graph_extractor.py,sha256=EwoiyOP7bUg7nWSnW_hGc--WIqSScYHgTJx3iWIsGkQ,4941 +torch/onnx/_internal/fx/type_utils.py,sha256=RhB2XQoC1P_JNEgHwGgaWhUlvCztxk2wnAaEpUlZ89I,8079 +torch/onnx/_internal/io_adapter.py,sha256=YXslELWeFlbgsAG3PfvcPfaIKoJ6A_BLImqoVZ-AFdA,23122 +torch/onnx/_internal/jit_utils.py,sha256=YJQOJR5TsZYhpSOcKu_z45X0CfDJn1pfoVMBGY5CYJs,14746 +torch/onnx/_internal/onnx_proto_utils.py,sha256=9f8-vwD8hdsg6YCrcD2p7WaI9RgMtmz54tYn76pB5fE,10803 +torch/onnx/_internal/onnxruntime.py,sha256=jnMV3BwIo5Nn-8WzuoiqRXxjq_Mfnff-7HjyTwKx4to,50933 +torch/onnx/_internal/registration.py,sha256=e6mki4e8Mnb4lQRYoebYCFdVCsUKU4vHhHOr9-gzJsk,11072 +torch/onnx/_onnx_supported_ops.py,sha256=eI611nfXwZSGbDc_KTv-oK8wEsgWMWQDpP7lyPFozH4,3304 +torch/onnx/_type_utils.py,sha256=HYDCr1SRctyjiDBzRF8j9QpKloCJhQqdOJs-blPuAXQ,13513 +torch/onnx/errors.py,sha256=NddcVEv1t-eCLJjP17yFxfS3lJrGUhY0MNViTjZ8oZs,3582 +torch/onnx/operators.py,sha256=DwiGlMPOCqDsUtkIe3K6e3au06vPo80nE6pO49XerYw,560 +torch/onnx/symbolic_caffe2.py,sha256=8_L5XwoUFjmE5fHZRrm0dR3e-YbKLZqryi3tAD6NeK4,10908 +torch/onnx/symbolic_helper.py,sha256=T7nMXXRkBqowLBnusC2uQChfeguzpMHzhPlcxO3hBI4,62783 +torch/onnx/symbolic_opset10.py,sha256=Ur841OOwqSzqNCmfXpToJAMX64d651Aeip20lVRxOYA,38265 +torch/onnx/symbolic_opset11.py,sha256=loDjWEefKCEpvknbaBt_o6ztuzPtlJqt4naRBuQ0dZE,59700 +torch/onnx/symbolic_opset12.py,sha256=ujJMeTlBGMfaHdUI1OgldT_cw8sTv5U8b76xOtiawwA,16193 +torch/onnx/symbolic_opset13.py,sha256=aP7fbBtBa3dVcvT8j2L2yhInV0fnXUja8cldb8_n2k4,42118 +torch/onnx/symbolic_opset14.py,sha256=nhfo79xtULt_4BTfY0MySZXhXeqOdcG_3pTO8-TZVns,9528 +torch/onnx/symbolic_opset15.py,sha256=Y8r4f2ls86m4vzmTTfP1xyPaaX65K6V0djA7pTQsbf4,2935 +torch/onnx/symbolic_opset16.py,sha256=pjm-WrdrcoKXzaZ1tm_NkOmgNdiHE0wzUY4RWoEyfL8,6565 +torch/onnx/symbolic_opset17.py,sha256=BC2Lf1U9wTn8TQTvQIIObpxyMTQzQjZXi5itDgyqSVE,7219 +torch/onnx/symbolic_opset18.py,sha256=jQz71o1PoGiucz6-VtoS_10medZVWKSCAKNz9T5CHGE,1736 +torch/onnx/symbolic_opset7.py,sha256=JVydYm3Rh2R4O7MzftttXbktx0nU0BShMU5IEDy6GLY,2091 +torch/onnx/symbolic_opset8.py,sha256=0_uD3oC0QTXqEQzD5t9c3f5AJNbPlsec3KoWp1TJHnU,15059 +torch/onnx/symbolic_opset9.py,sha256=q5LVNdn-v44VxAMYYrMGNox6Jd27_TEtrN4upC7SWPo,241684 +torch/onnx/utils.py,sha256=MHDPUBoLDJfKP3UnMCwktAH6YlvsjVFdL9Okxn4iIoY,83315 +torch/onnx/verification.py,sha256=FJBCSdliLCKUG7MtZzYQ85cOD1xolp5d6iqnNSE1igU,70091 +torch/optim/__init__.py,sha256=5Mm8G0M6JhOX0gM9zPR2CYgVHPzwrVVokbv8m460S7I,1031 +torch/optim/__init__.pyi,sha256=UHcdmdixF9j-dslJ92cxvCtZWwITfK13cZqyBxorAjA,583 +torch/optim/__pycache__/__init__.cpython-310.pyc,, +torch/optim/__pycache__/_functional.cpython-310.pyc,, +torch/optim/__pycache__/adadelta.cpython-310.pyc,, +torch/optim/__pycache__/adagrad.cpython-310.pyc,, +torch/optim/__pycache__/adam.cpython-310.pyc,, +torch/optim/__pycache__/adamax.cpython-310.pyc,, +torch/optim/__pycache__/adamw.cpython-310.pyc,, +torch/optim/__pycache__/asgd.cpython-310.pyc,, +torch/optim/__pycache__/lbfgs.cpython-310.pyc,, +torch/optim/__pycache__/lr_scheduler.cpython-310.pyc,, +torch/optim/__pycache__/nadam.cpython-310.pyc,, +torch/optim/__pycache__/optimizer.cpython-310.pyc,, +torch/optim/__pycache__/radam.cpython-310.pyc,, +torch/optim/__pycache__/rmsprop.cpython-310.pyc,, +torch/optim/__pycache__/rprop.cpython-310.pyc,, +torch/optim/__pycache__/sgd.cpython-310.pyc,, +torch/optim/__pycache__/sparse_adam.cpython-310.pyc,, +torch/optim/__pycache__/swa_utils.cpython-310.pyc,, +torch/optim/_functional.py,sha256=Mo51PvBCX0clwjMPGS_SbWJpJDCQwVYKu1a-QkpZvHw,3320 +torch/optim/_multi_tensor/__init__.py,sha256=8hJ8I7Uob5ZydF3xoA8rXqaVKhphAf9xgKFCs1cQU-A,1010 +torch/optim/_multi_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/optim/adadelta.py,sha256=T72TVuXnPrnzSfT9NzvUsHsMOqWEFUh52OZDUXoqKxA,11273 +torch/optim/adadelta.pyi,sha256=m1Qs3TkjRbgK_ato4PcFZUjab-5aExWnv5GNG1S9lXs,258 +torch/optim/adagrad.py,sha256=upk7qbHjPppjMpkTSsKdzTmtUAH-jTrokky4gWZO6SQ,14217 +torch/optim/adagrad.pyi,sha256=zMc-TKwNfoWysFb8h1NR-q0S14IMThh5gMpf5YTGNp0,310 +torch/optim/adam.py,sha256=4ovxRF2iPBkwS9hN3F6UsIPWR7BBNuPQaPU2aBmebAM,29721 +torch/optim/adam.pyi,sha256=bfvSlSEq8-s4QAe58zwckmWV3yb0a2M4QN0sV8Apgvg,587 +torch/optim/adamax.py,sha256=ZUieEua_Y-3zX6GdHajeD32iC_fWNaw4ohuiuGST6II,15343 +torch/optim/adamax.pyi,sha256=PN8bLokgp7zuYbjkZlXY7Oa6M17d2WzTmOUhMA_B3cM,298 +torch/optim/adamw.py,sha256=wTBd8JgPZwfVJomEZ2geeFfiHiz5Pkyi-ehj8v5wh7I,28554 +torch/optim/adamw.pyi,sha256=-23OYHOk62ZtCsqFO_qjfqC2xGAXZem-YFZ6yXwhODw,591 +torch/optim/asgd.py,sha256=ONZVxQab8d-1P5U8sB8a5iv6IQX3fuBlFpg_NHkV418,14046 +torch/optim/asgd.pyi,sha256=XI_UT3DNorNEpGrHDoFFccTObaO63ZhatZDCgaHXOsg,283 +torch/optim/lbfgs.py,sha256=QTzIzTrgUGeUs3R5Ak1c2gbEV6rIu6J7ogtnf10n_x4,17506 +torch/optim/lbfgs.pyi,sha256=fGehsWo2LK_JwEo9kIAxgxb53kEjzwGUHFUqF_Mr87w,419 +torch/optim/lr_scheduler.py,sha256=b6N-eAPwycOGHjvnBlWlISY6KLXE4gq76F_-qyN_6nQ,78377 +torch/optim/lr_scheduler.pyi,sha256=2YmTKs4rn4ZWexvl06Zd8s5kPoV3_BRSnziLUfyN__0,6988 +torch/optim/nadam.py,sha256=_2-gC2OUBA4wlxamOg8JUovV1NdLkUYmXAbn8lEc7IY,22769 +torch/optim/nadam.pyi,sha256=pq7GeLYTK_N-42I6ST8F9ut4dFHNB0EF24O-0nMDX0I,378 +torch/optim/optimizer.py,sha256=j7RQQ_CElC-WSoPvedpJnpEGLZJarLo0qDxsBzxNYhU,42073 +torch/optim/radam.py,sha256=fMBQXEkXJbeVmBRl658OS1S71T4mUmPIb6iyKbbc8R0,21204 +torch/optim/radam.pyi,sha256=1NyH7UDYKPGYo97_ZGx5UZ7QrMcSBZ28u_9fCO1MBPU,341 +torch/optim/rmsprop.py,sha256=Cxq9hBRFFcvEtBbZGo__wCWDYf6gywCBEfx-w3R--Gg,14379 +torch/optim/rmsprop.pyi,sha256=POZ9uhHsuZDUyfK_hMxBnne_SVV3pWpJn6htXLNrkLM,320 +torch/optim/rprop.py,sha256=gypWaj0kUcCImKWfoDG4PYCHI6rGLrACowiED4gu09k,12291 +torch/optim/rprop.pyi,sha256=EdKBoUMIaaMhwO256g1yuItxgmn_TBGocChFbTKk2jg,282 +torch/optim/sgd.py,sha256=jQ5U_Zlf4YCtDYkM6q0qGyNSofjX-57-Vb72at6eVXQ,17609 +torch/optim/sgd.pyi,sha256=wUfhJZS8qkl8_G7lhVeuekRoctxyIfMZYRQmnXk0Dgo,294 +torch/optim/sparse_adam.py,sha256=o-REuau_vMKZtGc8J04gPZO6qj8jMK-DmDwepiLZTZw,7533 +torch/optim/sparse_adam.pyi,sha256=pfhc3fTexncN1xuyHmGhyO9X_S0klXdZpzyYeQJlCeg,267 +torch/optim/swa_utils.py,sha256=r1cHzqp5ASaimf4ruuS3RnZ1rc7Wz6trRyT01WYLK1Q,16573 +torch/optim/swa_utils.pyi,sha256=wUe8UAuxSSpcOJPGuEihVS87b8THB6vNCsftHItY6WM,830 +torch/overrides.py,sha256=G1dc7W6_nzyh1LScas0PKqRKmX_6ES6FCH9ye8mcoRo,103633 +torch/package/__init__.py,sha256=ZLLvoviHHErV-XQZagde2I4cuNDK49dFLRGUC5oyOFc,388 +torch/package/__pycache__/__init__.cpython-310.pyc,, +torch/package/__pycache__/_digraph.cpython-310.pyc,, +torch/package/__pycache__/_directory_reader.cpython-310.pyc,, +torch/package/__pycache__/_importlib.cpython-310.pyc,, +torch/package/__pycache__/_mangling.cpython-310.pyc,, +torch/package/__pycache__/_mock.cpython-310.pyc,, +torch/package/__pycache__/_package_pickler.cpython-310.pyc,, +torch/package/__pycache__/_package_unpickler.cpython-310.pyc,, +torch/package/__pycache__/_stdlib.cpython-310.pyc,, +torch/package/__pycache__/file_structure_representation.cpython-310.pyc,, +torch/package/__pycache__/find_file_dependencies.cpython-310.pyc,, +torch/package/__pycache__/glob_group.cpython-310.pyc,, +torch/package/__pycache__/importer.cpython-310.pyc,, +torch/package/__pycache__/package_exporter.cpython-310.pyc,, +torch/package/__pycache__/package_importer.cpython-310.pyc,, +torch/package/_digraph.py,sha256=LW8RAC5fUCcIciMJMucH5Bb7VMcEqSippOxrNAvV6kI,5632 +torch/package/_directory_reader.py,sha256=wshQS8tAADGtXSSyNsG-mFkgVVyZNlVdl3QjXHBmNJA,1894 +torch/package/_importlib.py,sha256=Pqopny0484c8hlmEEnLTE2_UeNNBcn_9rlQyG4Rl3K0,2970 +torch/package/_mangling.py,sha256=tTUB6Z7dlcrbX1Wilz5RkWa7TD6OTFz7ToXG8ggBFv0,1854 +torch/package/_mock.py,sha256=6yTrK4HOWJobUaVGt1edXzs3fk3IyzrECbJs29XkmR8,2839 +torch/package/_package_pickler.py,sha256=qn7_IuJQBP1We4FvTv8Pdt4If6jrwtkBCnfN3uu1fto,4622 +torch/package/_package_unpickler.py,sha256=J1UNk_PPkI4v3EcPfvvOHoB6UQcL7LPfjBkTZvkk3yI,965 +torch/package/_stdlib.py,sha256=X7uMbSQ7iBL_bpHhLkTW3xD-7Keno_rqLWfR-UtkhAU,7238 +torch/package/analyze/__init__.py,sha256=RtjmM0jmYQwfuv9mQoKgZQZBij-GQ4cFcJX7_-aihDg,130 +torch/package/analyze/__pycache__/__init__.cpython-310.pyc,, +torch/package/analyze/__pycache__/find_first_use_of_broken_modules.cpython-310.pyc,, +torch/package/analyze/__pycache__/is_from_package.cpython-310.pyc,, +torch/package/analyze/__pycache__/trace_dependencies.cpython-310.pyc,, +torch/package/analyze/find_first_use_of_broken_modules.py,sha256=I1nPusI1vprdIlOO3CWahK_6HPYD_x9fcxSxupf1y-g,1053 +torch/package/analyze/is_from_package.py,sha256=xnYu_xdTqKdosT6pJtZrnrQaG14qGLlwyCBCwqCfu0I,404 +torch/package/analyze/trace_dependencies.py,sha256=vsjk1XltimIbxtBVOITikpedI6oOFpSr4RNBEjk1SA4,2193 +torch/package/file_structure_representation.py,sha256=x6jTVtPtzrGoGp0T_upebB5Ei39ozJH_LUS7iJbaxaE,4700 +torch/package/find_file_dependencies.py,sha256=hSNZXrBqHG4OYcppF_SWVHVTXiezEEDcNdeFYb776iw,3955 +torch/package/glob_group.py,sha256=lrHQfMHTz06Au3C-byKc58yXVbwTQQNBqW-zSDEVKeU,3610 +torch/package/importer.py,sha256=uI2qQF_3CfdMq8ztGc2AkCrMiY3oizINEeLkZun5KzM,8946 +torch/package/package_exporter.py,sha256=GjEnPcdL7QZojrD34pHoL_NZ342TFyFTJxpuZAr8Pcc,50850 +torch/package/package_importer.py,sha256=84pYMoR4FvRi55Cuf5e-e2L2t006OKdojILCHqH0h08,30784 +torch/profiler/__init__.py,sha256=kV5w6rRsAQaHBweHFVa0ZY7wxLyTz6ePyhXK5xn35l4,1434 +torch/profiler/__pycache__/__init__.cpython-310.pyc,, +torch/profiler/__pycache__/_memory_profiler.cpython-310.pyc,, +torch/profiler/__pycache__/_pattern_matcher.cpython-310.pyc,, +torch/profiler/__pycache__/_utils.cpython-310.pyc,, +torch/profiler/__pycache__/itt.cpython-310.pyc,, +torch/profiler/__pycache__/profiler.cpython-310.pyc,, +torch/profiler/__pycache__/python_tracer.cpython-310.pyc,, +torch/profiler/_memory_profiler.py,sha256=m3kGXf7hcJFKuf9jBu3bq-kh9MQySEOWxgEbBEl0R8Q,48091 +torch/profiler/_pattern_matcher.py,sha256=JRpn_q0VUXposZSptYn3DdWkxAajqyE5eTsAzFi3H0g,24755 +torch/profiler/_utils.py,sha256=sZ2vVNlJ9FjIabiFVOYWD0Let2eG6Z5Kuofnz24DQAE,13375 +torch/profiler/itt.py,sha256=xI87h0lcL1pLvhKgPmmsaS9s_IVzj5wLu5jWJbkYQuE,1754 +torch/profiler/profiler.py,sha256=ToyeFWd4xB1GPoT4JmKaMHUA0DkY6zYhUfRaAstOQ5M,33434 +torch/profiler/python_tracer.py,sha256=t2HhbERUPlMtdDrQ2B63QbAwfuK8oFE5GT3uuBCYAaA,497 +torch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/quantization/__init__.py,sha256=Rk2WJDawOJZTsSruwUvgahHHmGEYrRz9eWMZPoh0nxM,2656 +torch/quantization/__pycache__/__init__.cpython-310.pyc,, +torch/quantization/__pycache__/_numeric_suite.cpython-310.pyc,, +torch/quantization/__pycache__/_numeric_suite_fx.cpython-310.pyc,, +torch/quantization/__pycache__/_quantized_conversions.cpython-310.pyc,, +torch/quantization/__pycache__/fake_quantize.cpython-310.pyc,, +torch/quantization/__pycache__/fuse_modules.cpython-310.pyc,, +torch/quantization/__pycache__/fuser_method_mappings.cpython-310.pyc,, +torch/quantization/__pycache__/observer.cpython-310.pyc,, +torch/quantization/__pycache__/qconfig.cpython-310.pyc,, +torch/quantization/__pycache__/quant_type.cpython-310.pyc,, +torch/quantization/__pycache__/quantization_mappings.cpython-310.pyc,, +torch/quantization/__pycache__/quantize.cpython-310.pyc,, +torch/quantization/__pycache__/quantize_fx.cpython-310.pyc,, +torch/quantization/__pycache__/quantize_jit.cpython-310.pyc,, +torch/quantization/__pycache__/stubs.cpython-310.pyc,, +torch/quantization/__pycache__/utils.cpython-310.pyc,, +torch/quantization/_numeric_suite.py,sha256=kGqWAUJhc0DKg9RjXhiKRx7dxfmX-M5Y1w9jAEnU0Z0,779 +torch/quantization/_numeric_suite_fx.py,sha256=LkEYZQLt_CRTe4d_9EAvCzpuKKHTmTjYoXLXcawjN-I,752 +torch/quantization/_quantized_conversions.py,sha256=VDGywIQQtCD_8bqxGIo1hDQKx3lbe9mEWRugfY5Gyxc,4294 +torch/quantization/fake_quantize.py,sha256=AZes9LhE_KB-0Q_nV0Qy5kSOY0N9cvv7NPEpdjTwBz4,1015 +torch/quantization/fuse_modules.py,sha256=eLwRn_McF-cLDjCtgzvd6E3TWh7Fwpp3LuhS1ZrmEKM,731 +torch/quantization/fuser_method_mappings.py,sha256=AWk97tidfAL4jlhmYQgpObMusEsNc8aFAX0sxT3XH6Y,511 +torch/quantization/fx/__init__.py,sha256=s3Wh6JJbmUuv-pk4yieKjDpsHZRUkEqW04jRMT9iJPs,594 +torch/quantization/fx/__pycache__/__init__.cpython-310.pyc,, +torch/quantization/fx/__pycache__/_equalize.cpython-310.pyc,, +torch/quantization/fx/__pycache__/convert.cpython-310.pyc,, +torch/quantization/fx/__pycache__/fuse.cpython-310.pyc,, +torch/quantization/fx/__pycache__/fusion_patterns.cpython-310.pyc,, +torch/quantization/fx/__pycache__/graph_module.cpython-310.pyc,, +torch/quantization/fx/__pycache__/match_utils.cpython-310.pyc,, +torch/quantization/fx/__pycache__/pattern_utils.cpython-310.pyc,, +torch/quantization/fx/__pycache__/prepare.cpython-310.pyc,, +torch/quantization/fx/__pycache__/quantization_patterns.cpython-310.pyc,, +torch/quantization/fx/__pycache__/quantization_types.cpython-310.pyc,, +torch/quantization/fx/__pycache__/utils.cpython-310.pyc,, +torch/quantization/fx/_equalize.py,sha256=8LGj1MjWPuZ9i4hXy2QPmD9BBBFGhiMZtlkf9j5GPuA,1250 +torch/quantization/fx/convert.py,sha256=31cFTuIm23CT4JLdSJBHzi_spOsZs0peGyNzhny_rgk,386 +torch/quantization/fx/fuse.py,sha256=wc8SOcX_IxIWXS-E5WZhj0N6KCxpDHQGTUoAaq2Y9JI,380 +torch/quantization/fx/fusion_patterns.py,sha256=Ijjfig2bxM_YzaoEzsIPTg4NuZG6p2BPgV_Dw2bmYFw,415 +torch/quantization/fx/graph_module.py,sha256=bI7jvFL15dnuHLO8c8-tKebQO16XaWRir9jwIditoXU,573 +torch/quantization/fx/match_utils.py,sha256=ndaJFGvJfXCqUmzEyUEfRiNkDwoYV2Xxd39iFQdD2bo,456 +torch/quantization/fx/pattern_utils.py,sha256=gCBkAZzIvHjpk_wfgW2nP-jFfelkya0Sto9eaWJv2H0,1297 +torch/quantization/fx/prepare.py,sha256=onVEmW0FUj5y3NFZVdGnYVK7KbJWroMF23pNFBSVDk4,386 +torch/quantization/fx/quantization_patterns.py,sha256=iphHpoDc2SP2ooCEYRxteMnbOQ7z_ErQ6w2EgkmvNuI,2086 +torch/quantization/fx/quantization_types.py,sha256=Jo921qhPFWn9AqlZODQOjBvmQYwdXUt_vOWVpwkEvwE,395 +torch/quantization/fx/utils.py,sha256=RlQwgLPd_v1OKtjeSfFNqhbPRHW7a-rZLfKsek3uY8s,723 +torch/quantization/observer.py,sha256=ztgpjHb7Q1mB7f_i32tZRkdj8i7eYQP3uSqVGFDAWDA,1078 +torch/quantization/qconfig.py,sha256=avG-OasJvdG1szQJli3PW8eoNo7TVH6vrLO-Lv14SNE,910 +torch/quantization/quant_type.py,sha256=wwPL8MSv-G6QV5LogvkL4xRJ28Ido0yA7kPzh2dsIo0,399 +torch/quantization/quantization_mappings.py,sha256=yIflm9ncZNnznvmc6oPKxWD4fPA6C44-EeMVbtAcVl0,1147 +torch/quantization/quantize.py,sha256=g8mA0kRJIO2z63PuUcawc9bovat-uVjeUxIKFwvLb-I,804 +torch/quantization/quantize_fx.py,sha256=hBC2pUobd9oeYUliLKlIYE2dQ-6BQvdxg2xTyvkFLa8,736 +torch/quantization/quantize_jit.py,sha256=JNw2_M1d6EITYzYrXlrAsUac_4tX-IDMuAO_7prxhk8,714 +torch/quantization/stubs.py,sha256=ukEM_vZ34I3UdBnhFPn5GFL713MwFlEysXUAfYGshnA,392 +torch/quantization/utils.py,sha256=kOpHHmJ602vEybccn81hVLOHwY0CQ2YdnG9n9kOVcQM,833 +torch/quasirandom.py,sha256=JcYDiJ_6YeJKc3nwHxMlk9y6mcLOG1g66Jm59HliGws,7539 +torch/random.py,sha256=evcwNWMraIcXQ4PwUdyPuHyJGJ7VJhAPMcz3HK498Xo,6870 +torch/return_types.py,sha256=hwEZN_BVpTc0bHktEK-LquYRR1nbBgWlEwabVUdcbgQ,1482 +torch/return_types.pyi,sha256=UOgLLgE9A3s19Sijo1Vdevd9Wh_N6NEybfXcRZt7Maw,13984 +torch/serialization.py,sha256=KtOxsAkQnjpR-LwPgfbjehgKuhvyXoUk3Rr3QnvtHI4,62662 +torch/share/cmake/ATen/ATenConfig.cmake,sha256=Fu4Jh3vhuxYcjsZfQ71erhUpBbyJr0-gwuAk6I7FqKQ,263 +torch/share/cmake/Caffe2/Caffe2Config.cmake,sha256=CLgJIGP-PCTtIsNCzkqDFx12AoUH0rNqJhn2_pCwdv0,5390 +torch/share/cmake/Caffe2/Caffe2Targets-release.cmake,sha256=_hMee-otK3Wog4Dvs2EjYsXY-aEoG4nZGgVnSVpmy8g,2448 +torch/share/cmake/Caffe2/Caffe2Targets.cmake,sha256=ez3cKtQUi8bWLwMsgl8r7Lx8Y3METcS3yMg3essvTnQ,7290 +torch/share/cmake/Caffe2/FindCUDAToolkit.cmake,sha256=XWRBWHiHT1lTgU5q3BSnOG_Yoz4UvelM4IhBPh8aGyY,38342 +torch/share/cmake/Caffe2/FindCUSPARSELT.cmake,sha256=cjNafMBEzBGv0kZAQqMxdpku0Vyf2Yrn3vJ_OVHxdUQ,3068 +torch/share/cmake/Caffe2/FindSYCLToolkit.cmake,sha256=Xp5Gg-3qgQ3AhjmkvTmSXixfbAv9EUsN1fAbpOacZ98,1767 +torch/share/cmake/Caffe2/Modules_CUDA_fix/FindCUDA.cmake,sha256=78mPFyIV7lR9kDJ8vAjJwKUDLpFhbssiLz5tR9CmDxk,525 +torch/share/cmake/Caffe2/Modules_CUDA_fix/FindCUDNN.cmake,sha256=NKwIx_LRJ3uu9oJC9_apdlRooZ-uR_izK1_deByfEQo,3085 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/CMakeInitializeConfigs.cmake,sha256=v1O1FBKmJWk1h-Zbh8M6qVlP4OqVsmCcYD8zwdVfb6Q,1657 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA.cmake,sha256=9zZASjPxjc9LVroI2zPfaP7-R1AdPQcL-bm9QFxtP58,86655 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/make2cmake.cmake,sha256=_KLZxL3AhZehZKubThy4o2C_gEH5mm4h3kMpxLHgajU,3925 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/parse_cubin.cmake,sha256=h3Ka8c-mmE2Majl0s8342faZWVPAaDbO1rM_4m--YzA,3439 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/run_nvcc.cmake,sha256=2KcM296B27vgXYPm_QnN-k-6s16Xkv8NPwP7295j4sE,11813 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindCUDA/select_compute_arch.cmake,sha256=1FbcZO7cAk981JRPzrnfWjh5EQAd6cmnzDqjHtsUzxg,10746 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindPackageHandleStandardArgs.cmake,sha256=aLA1Dg7qyjW9Eya73fiwm2RqiG0FGwPOV64Sm5-Nobc,14902 +torch/share/cmake/Caffe2/Modules_CUDA_fix/upstream/FindPackageMessage.cmake,sha256=ToKFxPt7HSmEA014cFkMZl79quM2gpF7tmcP8h1BuYs,1564 +torch/share/cmake/Caffe2/public/LoadHIP.cmake,sha256=pU7FKyhrV2EZHDM2TF6-lhgSrxRDAPljqxy_sYuPUoQ,12130 +torch/share/cmake/Caffe2/public/cuda.cmake,sha256=YfpUkwBBEhS79x3rJd5BofRL5yrO88-4WY7WR8VQ0EI,15171 +torch/share/cmake/Caffe2/public/gflags.cmake,sha256=YrTkm-nQX6N3mh3tpY9a-i1_s_lAlifW0V_UZdAHS-M,2620 +torch/share/cmake/Caffe2/public/glog.cmake,sha256=zy1mZaicXNUHxSG7eOZ4ZVnbgk5qN-IuG_-jXUi98nk,2320 +torch/share/cmake/Caffe2/public/mkl.cmake,sha256=3n29s5EoL0GDjU8eL0gYEEcyU5Y_UFZJMGWGch0GwmM,831 +torch/share/cmake/Caffe2/public/mkldnn.cmake,sha256=7D8oS35genLaLdSPfgh3foWXQMsa2bUsQnB5WKfKPAA,444 +torch/share/cmake/Caffe2/public/protobuf.cmake,sha256=weW3OuHBIqIt0KpWRWzAnzSCu-AJ9naUfkjxcvaRl5c,4003 +torch/share/cmake/Caffe2/public/utils.cmake,sha256=SprtPrH2OpkGeW5Y_WL9AvtejqqwcIBaoUGho0Pqb3I,22534 +torch/share/cmake/Caffe2/public/xpu.cmake,sha256=V1OYG4Ar7UIJRI9Sq5_z9NNsxeGx8q4-R2bi7ODD-48,643 +torch/share/cmake/Tensorpipe/TensorpipeTargets-release.cmake,sha256=Z2BoA3v4t5CER3JhpvVXPyjHZMXUrxDE2d43oLRvtPg,1767 +torch/share/cmake/Tensorpipe/TensorpipeTargets.cmake,sha256=Du2evHbOEbIHNe9gzv7548p2XUtHcmvnOYX3op4aFG4,3956 +torch/share/cmake/Torch/TorchConfig.cmake,sha256=y5caEAMaVmtZafqOgQ_14TzNNXcTkQTE4LD1CJzMUOI,5945 +torch/share/cmake/Torch/TorchConfigVersion.cmake,sha256=1C4okZJvsymriTajB6fE0WAa4TIUOMOUnZnxhnfVgIU,366 +torch/signal/__init__.py,sha256=Eogmvuz6NdECfSTByt08-ZQw0Fec-GfQNNY77stj3zg,51 +torch/signal/__pycache__/__init__.cpython-310.pyc,, +torch/signal/windows/__init__.py,sha256=agqPFTqIfPJIMisuuSMnTJ3jQY7BKBI-NB6CWVB-j4U,383 +torch/signal/windows/__pycache__/__init__.cpython-310.pyc,, +torch/signal/windows/__pycache__/windows.cpython-310.pyc,, +torch/signal/windows/windows.py,sha256=5yVchnaSty5GmX2epQmELnt5X5G9nlbo81PuU_g8xEE,23329 +torch/sparse/__init__.py,sha256=n3rzRmv2YbgD6GyspUZjvo25rcFew-HcPvWDYp-FyLM,23486 +torch/sparse/__pycache__/__init__.cpython-310.pyc,, +torch/sparse/__pycache__/_semi_structured_conversions.cpython-310.pyc,, +torch/sparse/__pycache__/_semi_structured_ops.cpython-310.pyc,, +torch/sparse/__pycache__/_triton_ops.cpython-310.pyc,, +torch/sparse/__pycache__/_triton_ops_meta.cpython-310.pyc,, +torch/sparse/__pycache__/semi_structured.cpython-310.pyc,, +torch/sparse/_semi_structured_conversions.py,sha256=1hy9FziJS6j4NsBUX_hDtXiZaEjJrKIBsrqIgt6ivkM,11339 +torch/sparse/_semi_structured_ops.py,sha256=68ZUz00wWIfpP33dP-XgGxsD1rJxvQBxhdMwAsnPOTg,5105 +torch/sparse/_triton_ops.py,sha256=AmFJvjNqSR1d7d6f09FiDvwYwHFB7YzOzkuA7n1bpDo,74383 +torch/sparse/_triton_ops_meta.py,sha256=nTV2I88GRckQuXnGs7azWd7xnU4j1OUMdjsm-zkaVuY,242530 +torch/sparse/semi_structured.py,sha256=I5SDvQWsvsYyjY4u56r8a8P6BikYuyQ_1uItDGr4vh4,21555 +torch/special/__init__.py,sha256=brDIsIyu8UXquaAId4w-n6bRg_Iod36xInYmtLBfWJ8,32698 +torch/special/__pycache__/__init__.cpython-310.pyc,, +torch/storage.py,sha256=6AUmFr8f60vs-C0SS88Bk-_B8HnvDW9S6l46-wCFW88,46901 +torch/testing/__init__.py,sha256=bnC5Mu3wJZArYFvrHakjT63kHIlG93HaO0zpXtuxi0Y,165 +torch/testing/__pycache__/__init__.cpython-310.pyc,, +torch/testing/__pycache__/_comparison.cpython-310.pyc,, +torch/testing/__pycache__/_creation.cpython-310.pyc,, +torch/testing/_comparison.py,sha256=Md2mHmSEnr8zT1llz4HqGL8-esBX8xbPhKOlACLVA9I,62901 +torch/testing/_creation.py,sha256=GNWGNA12OoglS9xwz7VJUSUxMr4Dybf_Tfo2d0pfayo,11857 +torch/testing/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/__pycache__/autocast_test_lists.cpython-310.pyc,, +torch/testing/_internal/__pycache__/autograd_function_db.cpython-310.pyc,, +torch/testing/_internal/__pycache__/check_kernel_launches.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_cuda.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_device_type.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_dist_composable.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_distributed.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_dtype.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_fsdp.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_jit.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_methods_invocations.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_mkldnn.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_modules.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_nn.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_optimizers.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_pruning.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_quantization.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_quantized.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_subclass.cpython-310.pyc,, +torch/testing/_internal/__pycache__/common_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/composite_compliance.cpython-310.pyc,, +torch/testing/_internal/__pycache__/control_flow_opinfo_db.cpython-310.pyc,, +torch/testing/_internal/__pycache__/custom_op_db.cpython-310.pyc,, +torch/testing/_internal/__pycache__/dist_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/dynamo_test_failures.cpython-310.pyc,, +torch/testing/_internal/__pycache__/hypothesis_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/inductor_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/jit_metaprogramming_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/jit_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/logging_tensor.cpython-310.pyc,, +torch/testing/_internal/__pycache__/logging_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/quantization_torch_package_models.cpython-310.pyc,, +torch/testing/_internal/__pycache__/static_module.cpython-310.pyc,, +torch/testing/_internal/__pycache__/triton_utils.cpython-310.pyc,, +torch/testing/_internal/__pycache__/two_tensor.cpython-310.pyc,, +torch/testing/_internal/autocast_test_lists.py,sha256=1hNh3A4eX9MyNrVNwjPcBiFt7nlaoYTz18Wd0IA7mSo,24014 +torch/testing/_internal/autograd_function_db.py,sha256=CMto5LUqTyv8m0hsExpvERBQ9-UXnytdwmT2EIVANvI,19426 +torch/testing/_internal/check_kernel_launches.py,sha256=fpt87LoSU6nmsbEI9JVB34z3DQv4Uu-pYxqXre3JMJA,6053 +torch/testing/_internal/codegen/__init__.py,sha256=8QLhisbHub6VJl6egijnrOPKK5QNAe5FJhfcxEelj4Y,22 +torch/testing/_internal/codegen/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/common_cuda.py,sha256=cXVqKlHYy_MCp1mZlIaPx5ZKhNdWpfVYMRzz5h_nKYI,11243 +torch/testing/_internal/common_device_type.py,sha256=jr-Wuf8IKtTJPbkldBcGcr9nRnXmjWHaA_WUPIQwKdM,62924 +torch/testing/_internal/common_dist_composable.py,sha256=sMyH-QpvDrjWTgqHuHKOqsMWvAz1gNsG_efWy_7zD94,3424 +torch/testing/_internal/common_distributed.py,sha256=H53jl4Tbpr3MZvvPw3I_EraQH6a17KUzZO0zLpDF0EA,47251 +torch/testing/_internal/common_dtype.py,sha256=_Z5kM-Z9wYWCuJcqk8U-B8rwV-tyZN860ajhatbL8W8,4431 +torch/testing/_internal/common_fsdp.py,sha256=pzmhIWFrQCkU3cgGYE-EqN6dur8WF02fuYltviFgAJ8,53319 +torch/testing/_internal/common_jit.py,sha256=ACQlL_wDfxAMCd3cBYHKZ-jbx_V9NnvwxE_uKZBGLMY,15853 +torch/testing/_internal/common_methods_invocations.py,sha256=tQkQjMIzm6gA6PEY6VHJKTEq0FT_om6otGLHGG1obd0,1114749 +torch/testing/_internal/common_mkldnn.py,sha256=AEHUbUWDAbJ-y4csGwF9-0I6jMfzVb0AdvvPAtgbCfU,2314 +torch/testing/_internal/common_modules.py,sha256=N-b1OQQpKcT9IWHbKWoyNqszv8DlLQxPqwkI05vZg0w,215879 +torch/testing/_internal/common_nn.py,sha256=9Qr0EiPx2d7CxYW8ZdJFGF68C978AcCH38Jf1KL0aa4,165795 +torch/testing/_internal/common_optimizers.py,sha256=-BjUrkNRWt5Ef3hs1mYG1yg6FdS9OgCJzzSCLhwui3w,76314 +torch/testing/_internal/common_pruning.py,sha256=l4ELXMMubTHmk571M7DWPyu1mPCD0rUNb2bcLE-TGFs,12945 +torch/testing/_internal/common_quantization.py,sha256=FOZQI2HA85UduiuvwQ7X71iwwHhnkteGC5tXBde9wb0,104084 +torch/testing/_internal/common_quantized.py,sha256=h31x20TrhVmHAKh7eUc82nnfCeQDWIqO4awNxV69eM8,8702 +torch/testing/_internal/common_subclass.py,sha256=XUJZFZn7J22ZQBp4-10PKTJw47gf1ZUKS3wy6VvXD9I,7885 +torch/testing/_internal/common_utils.py,sha256=Y2siAlPqUximzYtytJyWs8JruMqar2PrFFNU0RIKtsw,210885 +torch/testing/_internal/composite_compliance.py,sha256=l4V4ek9S0KRIJayWiKUiyqXt0H30Io-0JU7u5dMjy30,25249 +torch/testing/_internal/control_flow_opinfo_db.py,sha256=OHmWawWcCMVEG_JFRS45_JHwoPU3RUMqvbFeGY2EG74,2468 +torch/testing/_internal/custom_op_db.py,sha256=biB8v1S_f9hCREmxX4K2d97wQ-m_pbnQlKHrOYgApb4,16680 +torch/testing/_internal/data/__init__.py,sha256=8QLhisbHub6VJl6egijnrOPKK5QNAe5FJhfcxEelj4Y,22 +torch/testing/_internal/data/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/data/__pycache__/network1.cpython-310.pyc,, +torch/testing/_internal/data/__pycache__/network2.cpython-310.pyc,, +torch/testing/_internal/data/network1.py,sha256=u5gnexSmy8Z8Xn_tPIEps0bM5bxnEzW1bUm2PLdnvEg,161 +torch/testing/_internal/data/network2.py,sha256=Tq_zTkjh8eueBJr_rukytu_YWhwBvddQnlBTEYYf3uA,191 +torch/testing/_internal/dist_utils.py,sha256=ZjMbCSNijyYnROqo0pePQ133h_sh28T_3HT8xmQBniY,7423 +torch/testing/_internal/distributed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/checkpoint_utils.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/common_state_dict.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/ddp_under_dist_autograd_test.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/distributed_test.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/distributed_utils.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/fake_pg.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/multi_threaded_pg.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/pipe_with_ddp_test.cpython-310.pyc,, +torch/testing/_internal/distributed/__pycache__/rpc_utils.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/__init__.py,sha256=8QLhisbHub6VJl6egijnrOPKK5QNAe5FJhfcxEelj4Y,22 +torch/testing/_internal/distributed/_shard/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/__pycache__/test_common.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/sharded_tensor/__init__.py,sha256=P9RvnGe_09LP1qHinqcn0TyqQG_gmov_ytC9kZGO3ig,3174 +torch/testing/_internal/distributed/_shard/sharded_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/sharded_tensor/__pycache__/_test_ops_common.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/sharded_tensor/__pycache__/_test_st_common.cpython-310.pyc,, +torch/testing/_internal/distributed/_shard/sharded_tensor/_test_ops_common.py,sha256=ZeDgmfmagacyLoSc6thJex5lZ5GegK3Z1AN4V3cbFls,4005 +torch/testing/_internal/distributed/_shard/sharded_tensor/_test_st_common.py,sha256=yol-5OPINDFI4TUmyfHK4BsbqZLpA7eN9Ooe57WlKig,1696 +torch/testing/_internal/distributed/_shard/test_common.py,sha256=7fKC5_EwNGoXVweCxUHBYrg3q5Mlie8ZQHemHd3F3Xw,1215 +torch/testing/_internal/distributed/_tensor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/_tensor/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/_tensor/__pycache__/common_dtensor.cpython-310.pyc,, +torch/testing/_internal/distributed/_tensor/common_dtensor.py,sha256=2BDNiw2r9buR9LlI65iWuaJeTShQ-vPXRsvfRTBqOyI,17124 +torch/testing/_internal/distributed/checkpoint_utils.py,sha256=LLB4R5V112J21TaVEwQ43XIAboUWDGhzre__sky0Jc0,1514 +torch/testing/_internal/distributed/common_state_dict.py,sha256=7DWNWPoLvl_Zi9oXcYQYzBtWIjv7sLe7h739ijsArBQ,4228 +torch/testing/_internal/distributed/ddp_under_dist_autograd_test.py,sha256=ytg15s6_twrEqADiVNnVrp-hQktfNaKaQfMietDrLkY,26737 +torch/testing/_internal/distributed/distributed_test.py,sha256=c9ujeAH8rSS-UC4FNicfDjc4va_bxrMqdsogMHkno1U,423706 +torch/testing/_internal/distributed/distributed_utils.py,sha256=XKAm2pgGNQGIODqQojU9EnQdscFLchnslEvFFLtplUk,1943 +torch/testing/_internal/distributed/fake_pg.py,sha256=FnXla2q-s5dhSsY79IxSgFHdrc2MaJsEpYFFoXBCpDg,1040 +torch/testing/_internal/distributed/multi_threaded_pg.py,sha256=T5ry7Om76cLLiMlaS8er0vDvE1lzPzejMu6mUo6Dsfc,17225 +torch/testing/_internal/distributed/nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/nn/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/nn/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/nn/api/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/nn/api/__pycache__/remote_module_test.cpython-310.pyc,, +torch/testing/_internal/distributed/nn/api/remote_module_test.py,sha256=GEnpCVi2-euYMp5cq5_ITsJrn7OXcAsadQq6kE9pGhg,29253 +torch/testing/_internal/distributed/pipe_with_ddp_test.py,sha256=JLs-GV90ugrQS6qR3EVbIdpxsziYXi_LteH7idFwG5U,5175 +torch/testing/_internal/distributed/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/pipeline/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/rpc/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/dist_autograd_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/dist_optimizer_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/faulty_agent_rpc_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/faulty_rpc_agent_test_fixture.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/rpc_agent_test_fixture.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/rpc_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/__pycache__/tensorpipe_rpc_agent_test_fixture.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/dist_autograd_test.py,sha256=IEZvApF3OTL_O1ASYJOjypmL6LO0rKlG4spCJV9HVD4,107700 +torch/testing/_internal/distributed/rpc/dist_optimizer_test.py,sha256=KIPKUS0OV_fi6wtY-bxXi3yoCViwbLUGV5LaeQtPUSY,10625 +torch/testing/_internal/distributed/rpc/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/rpc/examples/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/examples/__pycache__/parameter_server_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/examples/__pycache__/reinforcement_learning_rpc_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/examples/parameter_server_test.py,sha256=j8GNOHo3wJM0sHP9cQtprNpF6UmrCVwKXWCd0EWiN_g,4560 +torch/testing/_internal/distributed/rpc/examples/reinforcement_learning_rpc_test.py,sha256=ag8jC2Nn9SGgKdDB6Z4cgqIcVqw6xCplp9GcvagTUHI,9332 +torch/testing/_internal/distributed/rpc/faulty_agent_rpc_test.py,sha256=uhIyHE2YXdX4ihQVZ1W-PC6AoSCKTzFQ5STBjMwcXyw,14127 +torch/testing/_internal/distributed/rpc/faulty_rpc_agent_test_fixture.py,sha256=yYKNXsXVRXxGXTC67REtyk-4YUmbCPIrYKIs5w9Tttk,2218 +torch/testing/_internal/distributed/rpc/jit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/distributed/rpc/jit/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/jit/__pycache__/dist_autograd_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/jit/__pycache__/rpc_test.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/jit/__pycache__/rpc_test_faulty.cpython-310.pyc,, +torch/testing/_internal/distributed/rpc/jit/dist_autograd_test.py,sha256=PADsx4x72ya9VbLloZkcrEce6N5OOsw5h0cD9Ld65a4,4230 +torch/testing/_internal/distributed/rpc/jit/rpc_test.py,sha256=8_0P5I6iSmFM0_c1ubmobc_q5QuJJqs01IhGbXrS7cw,47279 +torch/testing/_internal/distributed/rpc/jit/rpc_test_faulty.py,sha256=MnWn2VvGtjxBL4-ffExLwdbo0ZJ7OOFV9--Z3ak273Q,8027 +torch/testing/_internal/distributed/rpc/rpc_agent_test_fixture.py,sha256=lcm_w8nJmYvIF46zhq8j274ghzKGNtW8knHvQYpIes0,1908 +torch/testing/_internal/distributed/rpc/rpc_test.py,sha256=qnGWYZiKonZoChdA8OGoKhPC491hkD9SXo0tG0zplms,228853 +torch/testing/_internal/distributed/rpc/tensorpipe_rpc_agent_test_fixture.py,sha256=X16R9HMGXYdeoVtbSooUiQtBHiPGAZmXm66y07ioxUE,1024 +torch/testing/_internal/distributed/rpc_utils.py,sha256=68fvshiw4rxvtp9sPCutUFDBRnNvgEZpL_pEMDRiy00,6711 +torch/testing/_internal/dynamo_test_failures.py,sha256=RQmqiwuRbO7VpUf5CqfN-crrrPSISPBird78Wx-Z-XU,4341 +torch/testing/_internal/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/generated/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/generated/__pycache__/annotated_fn_args.cpython-310.pyc,, +torch/testing/_internal/generated/annotated_fn_args.py,sha256=8kBP51ue-cKUwwR8eZNne6V9H6tO7kIOhA0pV0qaAcM,537826 +torch/testing/_internal/hypothesis_utils.py,sha256=tyjRa4vgdnU4HF7pQvZIYXnNpEpNl_avnC4wcUMS2_k,14691 +torch/testing/_internal/inductor_utils.py,sha256=rWSMaQXB_335BfEGNxx73gljEJFTOUMvlYifluQJyZs,2318 +torch/testing/_internal/jit_metaprogramming_utils.py,sha256=8LoO9mSqAVygg8cjMcsQJsVgkSQrHTluLoQIB39WGmg,32968 +torch/testing/_internal/jit_utils.py,sha256=oyvvPtt8rMYUS7VvYg3UavIA9EQaZMf6dHiUCGHQYWM,33998 +torch/testing/_internal/logging_tensor.py,sha256=VMfTIJ71MSmC2iMGYRhpRaCnk5Ck4SteNkTvRoq8u28,6920 +torch/testing/_internal/logging_utils.py,sha256=_5mCRhCMiuXZlrz3H1Ki2gRUyOAB8B8U-B7rCDQhncI,6719 +torch/testing/_internal/opinfo/__init__.py,sha256=6PWvlARagSjyrZW5xCOA5YGQjLqwaijc36TFX4UrU9g,116 +torch/testing/_internal/opinfo/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/opinfo/__pycache__/core.cpython-310.pyc,, +torch/testing/_internal/opinfo/__pycache__/refs.cpython-310.pyc,, +torch/testing/_internal/opinfo/__pycache__/utils.cpython-310.pyc,, +torch/testing/_internal/opinfo/core.py,sha256=rXiwjRu24-SNaaRyhhmdbS6T6_Nc-dAc0nYbDNhZ6rM,110577 +torch/testing/_internal/opinfo/definitions/__init__.py,sha256=_uEAYpR5_uxJ1PkDpmTFXvzqlDiDkqLn9n9eXxipeRs,476 +torch/testing/_internal/opinfo/definitions/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/_masked.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/fft.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/linalg.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/signal.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/sparse.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/__pycache__/special.cpython-310.pyc,, +torch/testing/_internal/opinfo/definitions/_masked.py,sha256=hxjCb9NKDuOyvq4y0mlovx-fUpliiJe_wiPxkjrjDMY,45433 +torch/testing/_internal/opinfo/definitions/fft.py,sha256=ZVYTf186uJRCMnEjRY6NZYHNMZt9HMOCsVGdrTNNTC8,28321 +torch/testing/_internal/opinfo/definitions/linalg.py,sha256=Lx0Da4dCqFctCMCgzJmIfR9ZHp2lIqtDGurOK0TJbGk,87302 +torch/testing/_internal/opinfo/definitions/signal.py,sha256=aISkZ-CjpKUzgEqPk6CFfqQ4oN2hNSoSd4XQp9EaJ1I,15293 +torch/testing/_internal/opinfo/definitions/sparse.py,sha256=N8SN6oWVo3kL8OSf5N_isBYCuAU87D3dQde7Y9kVtlQ,34210 +torch/testing/_internal/opinfo/definitions/special.py,sha256=skaBKk3VM99k9xLG9PIb-CKdo_a6eU-z48gLgEHj8zM,27642 +torch/testing/_internal/opinfo/refs.py,sha256=ITejvhEohlCDAus21sCwyVr8KYf5EUNRSWXTJJS8peY,8038 +torch/testing/_internal/opinfo/utils.py,sha256=zRa8aABZxUD0NDjM8bS6qUXFZxdzq1ZS3Mva-3ZANA0,8700 +torch/testing/_internal/optests/__init__.py,sha256=o-8t0Cva860Tcw0Ig_-rBr6-9Uuc9bDRWRMG6FgKzbA,372 +torch/testing/_internal/optests/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/optests/__pycache__/aot_autograd.cpython-310.pyc,, +torch/testing/_internal/optests/__pycache__/autograd_registration.cpython-310.pyc,, +torch/testing/_internal/optests/__pycache__/fake_tensor.cpython-310.pyc,, +torch/testing/_internal/optests/__pycache__/generate_tests.cpython-310.pyc,, +torch/testing/_internal/optests/__pycache__/make_fx.cpython-310.pyc,, +torch/testing/_internal/optests/aot_autograd.py,sha256=2yI_bgb9VWQIjJsSvAF3xP3CleGyTXhnwNgMKYq4JgU,6082 +torch/testing/_internal/optests/autograd_registration.py,sha256=NTcmeU6cAPjNIfzcet__ZD4tPZIW2gpXy27U0DQprPo,5692 +torch/testing/_internal/optests/fake_tensor.py,sha256=WuT0PGbogjTGPJeRYo2JiQYoTzj_iZET56L1zkv0W4w,257 +torch/testing/_internal/optests/generate_tests.py,sha256=NAZWj1AgDMpTKaeI-QkiEwobWfPBTdRn4vLlWrCvIqU,32315 +torch/testing/_internal/optests/make_fx.py,sha256=JoLpErQevRZ9iI7GkdRkG6oiZ0GGStVq4tEi9BcxftQ,3298 +torch/testing/_internal/quantization_torch_package_models.py,sha256=DnChjrnLG54TWRhINvfTxOFmNZt5WflDBJDpam4fj9w,951 +torch/testing/_internal/static_module.py,sha256=jJOCFxMOXV_ej0BLdzeEnrurgyN4CLe567O-8XnCRss,866 +torch/testing/_internal/test_module/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/testing/_internal/test_module/__pycache__/__init__.cpython-310.pyc,, +torch/testing/_internal/test_module/__pycache__/future_div.cpython-310.pyc,, +torch/testing/_internal/test_module/__pycache__/no_future_div.cpython-310.pyc,, +torch/testing/_internal/test_module/future_div.py,sha256=298hLJlLz2QCJ80OVQXQM6CgN71nbkFMNnkesgzSnY8,114 +torch/testing/_internal/test_module/no_future_div.py,sha256=sksxzWFUupRBbSThS69P366IwnWBNGJe9EqQx8m5EKM,145 +torch/testing/_internal/triton_utils.py,sha256=jhAYrkhVvDLuEgeSB2-b_sTrTBRuFutf9YpQBJAHRXY,11694 +torch/testing/_internal/two_tensor.py,sha256=4OTAvXWt2r8jSW85aeBH7D8sJg91uLQhUk3nQGrnloI,2944 +torch/torch_version.py,sha256=OAVU9-LvDKXILLYg38VHxj69oAm57kcfUYYk67ENfKY,2462 +torch/types.py,sha256=U7ywj32b9fXLkIJar32y229JRO9mIKN01DJUyhp0kCM,2476 +torch/utils/__init__.py,sha256=9MFIPdzNoY0wRP5E10-W5yZElSwbBaqw8mifj5COmJ4,2368 +torch/utils/__pycache__/__init__.cpython-310.pyc,, +torch/utils/__pycache__/_config_module.cpython-310.pyc,, +torch/utils/__pycache__/_content_store.cpython-310.pyc,, +torch/utils/__pycache__/_contextlib.cpython-310.pyc,, +torch/utils/__pycache__/_cpp_extension_versioner.cpython-310.pyc,, +torch/utils/__pycache__/_cuda_trace.cpython-310.pyc,, +torch/utils/__pycache__/_cxx_pytree.cpython-310.pyc,, +torch/utils/__pycache__/_device.cpython-310.pyc,, +torch/utils/__pycache__/_foreach_utils.cpython-310.pyc,, +torch/utils/__pycache__/_freeze.cpython-310.pyc,, +torch/utils/__pycache__/_import_utils.cpython-310.pyc,, +torch/utils/__pycache__/_mode_utils.cpython-310.pyc,, +torch/utils/__pycache__/_python_dispatch.cpython-310.pyc,, +torch/utils/__pycache__/_pytree.cpython-310.pyc,, +torch/utils/__pycache__/_stats.cpython-310.pyc,, +torch/utils/__pycache__/_traceback.cpython-310.pyc,, +torch/utils/__pycache__/_triton.cpython-310.pyc,, +torch/utils/__pycache__/_typing_utils.cpython-310.pyc,, +torch/utils/__pycache__/_zip.cpython-310.pyc,, +torch/utils/__pycache__/backend_registration.cpython-310.pyc,, +torch/utils/__pycache__/bundled_inputs.cpython-310.pyc,, +torch/utils/__pycache__/checkpoint.cpython-310.pyc,, +torch/utils/__pycache__/collect_env.cpython-310.pyc,, +torch/utils/__pycache__/cpp_backtrace.cpython-310.pyc,, +torch/utils/__pycache__/cpp_extension.cpython-310.pyc,, +torch/utils/__pycache__/deterministic.cpython-310.pyc,, +torch/utils/__pycache__/dlpack.cpython-310.pyc,, +torch/utils/__pycache__/file_baton.cpython-310.pyc,, +torch/utils/__pycache__/flop_counter.cpython-310.pyc,, +torch/utils/__pycache__/hooks.cpython-310.pyc,, +torch/utils/__pycache__/mkldnn.cpython-310.pyc,, +torch/utils/__pycache__/mobile_optimizer.cpython-310.pyc,, +torch/utils/__pycache__/model_zoo.cpython-310.pyc,, +torch/utils/__pycache__/show_pickle.cpython-310.pyc,, +torch/utils/__pycache__/throughput_benchmark.cpython-310.pyc,, +torch/utils/__pycache__/weak.cpython-310.pyc,, +torch/utils/_config_module.py,sha256=pI31s89s7o8rwfKtmQbIqdBN_E842y3n_JGwtM4y3T8,12148 +torch/utils/_content_store.py,sha256=m7UXNUDv4qIyvacW2Y-DL-8tb2ikM8ivV-vC4SWYfHw,9051 +torch/utils/_contextlib.py,sha256=fpbRiiugz_Dt-0QO-QaZNYywYzz1jwYBOnvjzwCHU54,5933 +torch/utils/_cpp_extension_versioner.py,sha256=n3pYPPuHBiTL0YXX8AKIfF3f18Q2V9ni-q1IFyRA_q0,1983 +torch/utils/_cuda_trace.py,sha256=llPZZzSnIZx_KTQ2GmPXsm-fyc3YhucIrh4hqKJI3yM,3214 +torch/utils/_cxx_pytree.py,sha256=Neo51DaVa5OQklUgoMHopmQ5scwN5MePEy2pUidDmX8,33981 +torch/utils/_device.py,sha256=JkstPGsXHmiPy_VhCj5dHq6fO7rMHGf9YdyMXBo05zM,2748 +torch/utils/_foreach_utils.py,sha256=FxWn0_7j5tvf8Ql_WkWJHahNhdZ1FNyD6mbcrmAtKII,2391 +torch/utils/_freeze.py,sha256=GaQjspljkx1QyJmX1YOSDuPmtZNV2vLCSLJe8ZiFbRw,9984 +torch/utils/_import_utils.py,sha256=-Pd1AhAt5-6n65pWXVaiK2izWK0TID17gLOiGXeWwlw,1240 +torch/utils/_mode_utils.py,sha256=bdhzmPEOoAyWFpi_N8H0mLrDcdnIaRPLg12sW04D6Xc,224 +torch/utils/_python_dispatch.py,sha256=wOJNIr7ZPa_DarqVh1s7eM0nG_wo6stiIPHZYxqvisc,23804 +torch/utils/_pytree.py,sha256=NvusgzgpXtMCxmXRWSFr7kMgVjvCu6EXII4jssOKKcM,51686 +torch/utils/_stats.py,sha256=v9hpjA1J5TxEcgV8I13izjjnMEtfbTYRsLIs454dfmY,810 +torch/utils/_sympy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/_sympy/__pycache__/__init__.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/functions.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/interp.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/reference.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/singleton_int.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/solve.cpython-310.pyc,, +torch/utils/_sympy/__pycache__/value_ranges.cpython-310.pyc,, +torch/utils/_sympy/functions.py,sha256=8QGI6pD3h1LMJzBnPzRS0WtAHVlLEpZ_Ge4smI8SGI0,11990 +torch/utils/_sympy/interp.py,sha256=VbX-ZEh7KXrJTKjLr-SQAjQZVasj8-ZOOzbdcKoSpGI,3436 +torch/utils/_sympy/reference.py,sha256=lemwEtYzaqyMF8lBynTuCDaKkIxxNffTUTunR8Ra5l0,4757 +torch/utils/_sympy/singleton_int.py,sha256=TXAUcsVF8zwFe-LOHyHeYkblgn7RE9Y232xRXlQMgdE,2939 +torch/utils/_sympy/solve.py,sha256=7DdP1p7BBXZSOU2_1Px3-tqq31ncioR9EW1KNDAcJP8,6375 +torch/utils/_sympy/value_ranges.py,sha256=nZwXT03vJ769GYnoYMH5XRc2yY2NDsb3X24cwsxQoSc,26533 +torch/utils/_traceback.py,sha256=fnWQmJVuORB_PLUe_wJ3OcbFlbNZB2IhnfLyQTYOgG0,10278 +torch/utils/_triton.py,sha256=XBRyYUjytoOyIQbJAxJFJ6UR9Erw17q_c570RB0giww,3137 +torch/utils/_typing_utils.py,sha256=jsi2FN9VvtbWYKNf2v-nB1mtODLrgy1L--8rK2oOemo,377 +torch/utils/_zip.py,sha256=-07OT--l6VTWg8TbSALMWt6NGoeU5Oj3RElcuZsjxk8,2427 +torch/utils/backcompat/__init__.py,sha256=SlNVS5fa_8ICovkQms2POqb1nYDlWRFz3TRidWHoQYM,667 +torch/utils/backcompat/__pycache__/__init__.cpython-310.pyc,, +torch/utils/backend_registration.py,sha256=Ws628Rp2x6IelvlqYjbexDd677KvGxBkbkMaso645Mw,16810 +torch/utils/benchmark/__init__.py,sha256=VMZoFTt8YGaScu3-5L1uWwMOED8FRYoEBAX37RFJ3c0,411 +torch/utils/benchmark/__pycache__/__init__.cpython-310.pyc,, +torch/utils/benchmark/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/benchmark/examples/__pycache__/__init__.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/blas_compare_setup.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/compare.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/fuzzer.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/op_benchmark.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/simple_timeit.cpython-310.pyc,, +torch/utils/benchmark/examples/__pycache__/spectral_ops_fuzz_test.cpython-310.pyc,, +torch/utils/benchmark/examples/blas_compare_setup.py,sha256=g8upsGcYCN4v_x1wDxyvzyht8Ao4mFSii0VUqFzjZUg,7149 +torch/utils/benchmark/examples/compare.py,sha256=_5h_qKk1qCNWiNPYJ1yrO2s7Szz-aEHcTAPMXHDn37s,2888 +torch/utils/benchmark/examples/fuzzer.py,sha256=1Zn-WEXHghMA8XGT1NGqBzrC9I0QX-ZR04_qu6SpuMg,2623 +torch/utils/benchmark/examples/op_benchmark.py,sha256=Fju6Wnd51zR-ltjZSKVjP2LVmtGKoPOdg7hHwAiKn_4,4176 +torch/utils/benchmark/examples/simple_timeit.py,sha256=-ZXxBv6jUWNKaoDSAIdyFv7s7Jr_5MRDFQUale5ychc,533 +torch/utils/benchmark/examples/spectral_ops_fuzz_test.py,sha256=ZYcLg_IUXSbLcCv8VOvN8JWDJy4EGmihCUw8aK4hdao,4752 +torch/utils/benchmark/op_fuzzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/benchmark/op_fuzzers/__pycache__/__init__.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/__pycache__/binary.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/__pycache__/sparse_binary.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/__pycache__/sparse_unary.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/__pycache__/spectral.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/__pycache__/unary.cpython-310.pyc,, +torch/utils/benchmark/op_fuzzers/binary.py,sha256=uLwDtIzVosONoqYgeWpqovKzLOhb1Er9_9ClF0diO38,4109 +torch/utils/benchmark/op_fuzzers/sparse_binary.py,sha256=vw4fmfPC3JwGOgI8fz13k9wlCwGhgZMQt9nUjIO8drg,4191 +torch/utils/benchmark/op_fuzzers/sparse_unary.py,sha256=cINlZXC8v87lhxOmMuoNCyIvLDSkunGmxbezHawDUEE,3219 +torch/utils/benchmark/op_fuzzers/spectral.py,sha256=qxFUTHZf4YuX6WYrHd2s92-qmcWWy9tMUeNBTcJFlZM,3597 +torch/utils/benchmark/op_fuzzers/unary.py,sha256=OYGfWne_fZWUqZXz_hv2glMpYoO3cvIdWeYcEUF7ZGk,3119 +torch/utils/benchmark/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/benchmark/utils/__pycache__/__init__.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/_stubs.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/common.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/compare.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/compile.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/cpp_jit.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/fuzzer.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/sparse_fuzzer.cpython-310.pyc,, +torch/utils/benchmark/utils/__pycache__/timer.cpython-310.pyc,, +torch/utils/benchmark/utils/_stubs.py,sha256=YapnkkFuitztF2XrMHTR9A2EsGm0lsrhmqTRcHPYhjM,976 +torch/utils/benchmark/utils/common.py,sha256=Oe9uNGIaFe7OuybeDXNcfsnp4aOv9-aKyScBmWT7Rzc,13653 +torch/utils/benchmark/utils/compare.py,sha256=Fy1OMNhbVRNhTbdUmiyn3OC26zBAZ_jTshM9krjTmTo,12321 +torch/utils/benchmark/utils/compile.py,sha256=14bePS2c3Mk2iQ7SWZfCIAkfCeEsUwJatIkeMExjKNI,7523 +torch/utils/benchmark/utils/cpp_jit.py,sha256=Lfphq1CRzmhr0WKibv_A5b2DgeHRVJ8SHGiFGroC_I4,6811 +torch/utils/benchmark/utils/fuzzer.py,sha256=4oJD_lJdORFva8zcawh3VYTrWcrMlfNwt3GAFVCszuA,18218 +torch/utils/benchmark/utils/sparse_fuzzer.py,sha256=qFZbulBusYEEa01YcOLtijrFFe4_3YxTPca2JytuWlE,5140 +torch/utils/benchmark/utils/timeit_template.cpp,sha256=Wzz-o6Yjgq3tkmUTxeRldQxrsETh48T2hwL8xbOkRSg,1009 +torch/utils/benchmark/utils/timer.py,sha256=yjPmylTGRChfeu3aYF5m84MGH9GuNBaqGaRnykNEqJA,21097 +torch/utils/benchmark/utils/valgrind_wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/benchmark/utils/valgrind_wrapper/__pycache__/__init__.cpython-310.pyc,, +torch/utils/benchmark/utils/valgrind_wrapper/__pycache__/timer_interface.cpython-310.pyc,, +torch/utils/benchmark/utils/valgrind_wrapper/callgrind.h,sha256=wK1NVdRImF_4WVLlQrXkufunvE0qLr5dw50v86KPIo0,5744 +torch/utils/benchmark/utils/valgrind_wrapper/compat_bindings.cpp,sha256=ysuof0blt-4g76St1LUrdlZLiaCBKjwjwZXE0L4nI74,813 +torch/utils/benchmark/utils/valgrind_wrapper/timer_callgrind_template.cpp,sha256=ILVnffXHThuakEj3hzKv4usmt8rICdXpSTBeWKz7jU4,1676 +torch/utils/benchmark/utils/valgrind_wrapper/timer_interface.py,sha256=mRzHX_MtLPaSD-lGRXt3dPS_0fIgrsfx3l05G2sUC4Y,36967 +torch/utils/benchmark/utils/valgrind_wrapper/valgrind.h,sha256=8MpV41sjwR0bIML04pxlLIjVuGhRtWdy1Kmtax4jFLI,422653 +torch/utils/bottleneck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/bottleneck/__main__.py,sha256=Uh2fsD3cfveK-e5aLoa0MXO145rji_A2tZ8-v1TIMqg,7191 +torch/utils/bottleneck/__pycache__/__init__.cpython-310.pyc,, +torch/utils/bottleneck/__pycache__/__main__.cpython-310.pyc,, +torch/utils/bundled_inputs.py,sha256=cOlI_u0O6y_qxXQX0zqqnQCYwGOCj1iUmoaA85YrX7s,22468 +torch/utils/checkpoint.py,sha256=TFZZ-blZ1Lv029SDodfOUdpjYWZzKexvy9iFWJ6Qitw,60334 +torch/utils/collect_env.py,sha256=u6d5RnjR91S5HHli_YDhP5khv61E9riPu-NOfJP3tR4,22068 +torch/utils/cpp_backtrace.py,sha256=QplPUghMQv7i2oka1csp5zOVtPHebojb9co2oqWfqGs,456 +torch/utils/cpp_extension.py,sha256=tHtJLL4nzPWlbtMuBO5kvrm8dLZ_LIXDEQ1Z7BwTB_8,105340 +torch/utils/data/__init__.py,sha256=XZqNdyIRIGvowDMh9VjpENdqQIn8M-eGZLXHzgAIHW8,1956 +torch/utils/data/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/__pycache__/backward_compatibility.cpython-310.pyc,, +torch/utils/data/__pycache__/dataloader.cpython-310.pyc,, +torch/utils/data/__pycache__/dataset.cpython-310.pyc,, +torch/utils/data/__pycache__/distributed.cpython-310.pyc,, +torch/utils/data/__pycache__/graph.cpython-310.pyc,, +torch/utils/data/__pycache__/graph_settings.cpython-310.pyc,, +torch/utils/data/__pycache__/sampler.cpython-310.pyc,, +torch/utils/data/_utils/__init__.py,sha256=8BmCjmGwHeVZCGj4xnC-A4vWIi_xzFEuOrCzpa1H-Zk,1596 +torch/utils/data/_utils/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/_utils/__pycache__/collate.cpython-310.pyc,, +torch/utils/data/_utils/__pycache__/fetch.cpython-310.pyc,, +torch/utils/data/_utils/__pycache__/pin_memory.cpython-310.pyc,, +torch/utils/data/_utils/__pycache__/signal_handling.cpython-310.pyc,, +torch/utils/data/_utils/__pycache__/worker.cpython-310.pyc,, +torch/utils/data/_utils/collate.py,sha256=dhDScOXz8c8ilHQ8v7LNV366WrppZHoE7if0oEmjC8c,15032 +torch/utils/data/_utils/fetch.py,sha256=GdRAnSIv8M33zMNNJAa-Qdtm3J7xNPtZ8CiWqXakKkw,1928 +torch/utils/data/_utils/pin_memory.py,sha256=aEIPx0ejhKA2cLQ-SKhKrCmnAHkWW9Vct8K2xU4VV9w,4207 +torch/utils/data/_utils/signal_handling.py,sha256=5R_8bYrrUCJrnQ3BuMeaTl-02T4JKCm6vWXsjMaWHeg,3155 +torch/utils/data/_utils/worker.py,sha256=lb6G88Kza22CIyDr5gS3KYASu3ile9Ko7FgaKYhgb9g,13441 +torch/utils/data/backward_compatibility.py,sha256=C2YszEKwbE-NUpm-THgWe9wcoChZlDAOPH2r3k07npo,212 +torch/utils/data/dataloader.py,sha256=Z04sYkYR6ef78XqV2b3bh6YcymWfL_j-i0a_Ssd0up4,74195 +torch/utils/data/datapipes/__init__.py,sha256=yCobz1Svm4GireCenmOohIBB2ne0mVSJP7sukzkWAC8,61 +torch/utils/data/datapipes/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/datapipes/__pycache__/_decorator.cpython-310.pyc,, +torch/utils/data/datapipes/__pycache__/_hook_iterator.cpython-310.pyc,, +torch/utils/data/datapipes/__pycache__/_typing.cpython-310.pyc,, +torch/utils/data/datapipes/__pycache__/datapipe.cpython-310.pyc,, +torch/utils/data/datapipes/__pycache__/gen_pyi.cpython-310.pyc,, +torch/utils/data/datapipes/_decorator.py,sha256=x9-iaOGFmjNzITn3HtIfUaSSnz6AN-AdHFxNH4J2LyY,7461 +torch/utils/data/datapipes/_hook_iterator.py,sha256=537AUQHRJkpRk04Fxz2kHsVFpzqP399GlhYrzkbiqZo,11604 +torch/utils/data/datapipes/_typing.py,sha256=kB7amEhyNViZ4UvutuElL00SaP95DLWXd0m7CK_Dvf4,15760 +torch/utils/data/datapipes/dataframe/__init__.py,sha256=DG3VrNOAVSK8JORYiJJoJBuS9cHICGQFNevAc5PzwZE,335 +torch/utils/data/datapipes/dataframe/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/datapipes/dataframe/__pycache__/dataframe_wrapper.cpython-310.pyc,, +torch/utils/data/datapipes/dataframe/__pycache__/dataframes.cpython-310.pyc,, +torch/utils/data/datapipes/dataframe/__pycache__/datapipes.cpython-310.pyc,, +torch/utils/data/datapipes/dataframe/__pycache__/structures.cpython-310.pyc,, +torch/utils/data/datapipes/dataframe/dataframe_wrapper.py,sha256=vBOE7KT9du539SfltihYwGu75zsKlJcDMXx4A1LWGNE,3245 +torch/utils/data/datapipes/dataframe/dataframes.py,sha256=SjI65S1mVvtlALB8CdAv-fz4_aIcMdg4gHEI1a4vfco,13356 +torch/utils/data/datapipes/dataframe/datapipes.py,sha256=464cGzIKNWVQRPumHKKcAbyUORytBgDAFwKKqMvLimc,4435 +torch/utils/data/datapipes/dataframe/structures.py,sha256=nhcATRzp1_7Yo7TH55yZR5rMKXhGmSRBbv5EKuTHYJw,578 +torch/utils/data/datapipes/datapipe.py,sha256=w_XT4e7IYkQEGduT23o1RWz2RpCAiGSsl_59gymxmSg,16674 +torch/utils/data/datapipes/datapipe.pyi,sha256=ALaLFIqwOKGyvyUxkqBU8pyKguox-M0HGMEEOYcwDsw,32334 +torch/utils/data/datapipes/gen_pyi.py,sha256=GIkmkA1rEinj5KavO1MBqugV5MhYhAaWnq_or7Z4L9Q,10640 +torch/utils/data/datapipes/iter/__init__.py,sha256=2yQfue4Wyn-RZ_IM9FQwXtOzR_Gf8vBoqKzHkQGfmiM,1942 +torch/utils/data/datapipes/iter/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/callable.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/combinatorics.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/combining.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/filelister.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/fileopener.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/grouping.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/routeddecoder.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/selecting.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/sharding.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/streamreader.cpython-310.pyc,, +torch/utils/data/datapipes/iter/__pycache__/utils.cpython-310.pyc,, +torch/utils/data/datapipes/iter/callable.py,sha256=ByTzp8bG_RNx5JkOUXz5g9wZpY1tKTWQHqQXLASGsy0,9036 +torch/utils/data/datapipes/iter/combinatorics.py,sha256=uCCEieuwJxNkf5t0Lwa6ydbW4mO3SRkPKAaLiKXeBYw,6481 +torch/utils/data/datapipes/iter/combining.py,sha256=YgIor-fKUu_XU_1Wu1MKeXacxv3G_UUrGMJel8DrGFU,26544 +torch/utils/data/datapipes/iter/filelister.py,sha256=Qis-y47Omt37HwbA6RiEUnHM8NYYe4CNsZc_xYtfz20,2513 +torch/utils/data/datapipes/iter/fileopener.py,sha256=x6Qtf28sDzePmjezODPstVOUM1MBXIrL2FZTaDTTd94,2767 +torch/utils/data/datapipes/iter/grouping.py,sha256=wXFrMHSLYy8Rme4W-D1vip38SEWlOFYLLzRk1g5LN-k,12227 +torch/utils/data/datapipes/iter/routeddecoder.py,sha256=KmuVA600kSLmIiJHGai2EY_2bMrv-_Rh56LQYAckYew,2723 +torch/utils/data/datapipes/iter/selecting.py,sha256=0ZpwMyMMRjp6VtnbFT0hmuVxnzHtJg9pTxDJYRM8n6Y,3209 +torch/utils/data/datapipes/iter/sharding.py,sha256=6AN5Kiufg9C3lHzgAydImO8NcCMyZ4LhguGRgvUc45g,3279 +torch/utils/data/datapipes/iter/streamreader.py,sha256=Ze48_FYS7bVrHtqjaiJ-q5NAzBOQjYi4if2PtEaE93c,1402 +torch/utils/data/datapipes/iter/utils.py,sha256=LrREYsnlWcEbFKe8LB0IilUVZvEvdtc9O5ZyMmqM1cg,1782 +torch/utils/data/datapipes/map/__init__.py,sha256=TjyQmY9aPPSsaz4UlfIrVF-4p6D3oO0dnvatLhTolTc,656 +torch/utils/data/datapipes/map/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/datapipes/map/__pycache__/callable.cpython-310.pyc,, +torch/utils/data/datapipes/map/__pycache__/combinatorics.cpython-310.pyc,, +torch/utils/data/datapipes/map/__pycache__/combining.cpython-310.pyc,, +torch/utils/data/datapipes/map/__pycache__/grouping.cpython-310.pyc,, +torch/utils/data/datapipes/map/__pycache__/utils.cpython-310.pyc,, +torch/utils/data/datapipes/map/callable.py,sha256=i4MYuJdPDvqA-aD5faUQltscvKg74e_8uEC0eebK_PA,1826 +torch/utils/data/datapipes/map/combinatorics.py,sha256=KPIZ5EBsULKCBKRQ8JrF-hT6MzDwbIupAjs4mtW6QXs,4169 +torch/utils/data/datapipes/map/combining.py,sha256=960zSG7ezQj2oEw7swZCHROaMDgVPEu_BKPf7JGc34k,3605 +torch/utils/data/datapipes/map/grouping.py,sha256=F2ugH-diNOkNURVCsAqlPrYry7yF51cCwLoWBK53tEI,2443 +torch/utils/data/datapipes/map/utils.py,sha256=vPBAutyCEVrsBoTa_Hto5udF4fMyr_DUDybKN7gydrI,1548 +torch/utils/data/datapipes/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/data/datapipes/utils/__pycache__/__init__.cpython-310.pyc,, +torch/utils/data/datapipes/utils/__pycache__/common.cpython-310.pyc,, +torch/utils/data/datapipes/utils/__pycache__/decoder.cpython-310.pyc,, +torch/utils/data/datapipes/utils/__pycache__/snapshot.cpython-310.pyc,, +torch/utils/data/datapipes/utils/common.py,sha256=3ZtplhEJC1dlEFxbJnugqI4y22Fs5Ez_QOhLbGovE0E,13326 +torch/utils/data/datapipes/utils/decoder.py,sha256=bggs3qUjOZTS-43r6GcbOUhrX89q7OUnfu2ZYi56ONY,11001 +torch/utils/data/datapipes/utils/snapshot.py,sha256=agoPGlHj1B-RupEIAhp90C2sGNSfT3Xt4bcOZ5bcfjk,3046 +torch/utils/data/dataset.py,sha256=q3c7EJaAeFPdUOVeHOsF2jBAMJcTTiM7Ex7dtB60zGg,19142 +torch/utils/data/distributed.py,sha256=j6LFqOp6Sh_wn6z-Gg82ymY9-DL3xOM4CfMExrA1jJg,5950 +torch/utils/data/graph.py,sha256=3muKh5ocH5eIFMWiUkpR7tUTq1Y5NJ2Q7F8Bm_jVh0s,5802 +torch/utils/data/graph_settings.py,sha256=P21zrjYbKkFwBhVIIW6OolNDLOZ51pLlnXT7BGhJfk4,5511 +torch/utils/data/sampler.py,sha256=vbYiOqLrnFf0sgdy0Rjl57hqN2W7bThwu3nbplYg01g,12477 +torch/utils/deterministic.py,sha256=BpY4euUvCC6eHbOsc7hipEV8q_H_GUgpR_8aXaaMIOU,584 +torch/utils/dlpack.py,sha256=eb7fXKDRQcr0oc0P49qpxE1_hsklavXoRSEUI8wPD00,4438 +torch/utils/file_baton.py,sha256=qmWcGdk3jPHLgt5L0vAPsFwUSk8hNDPJ_6PEzMoGhOk,1392 +torch/utils/flop_counter.py,sha256=2SC8lPsbOaOO6TEALIxHckdC9yOPvVnGizIVDgMBM9o,20282 +torch/utils/hipify/__init__.py,sha256=Jzb_RfgvXCrm_SQ4AfeGVi1N36YybxnM5mpyxrnihgI,33 +torch/utils/hipify/__pycache__/__init__.cpython-310.pyc,, +torch/utils/hipify/__pycache__/constants.cpython-310.pyc,, +torch/utils/hipify/__pycache__/cuda_to_hip_mappings.cpython-310.pyc,, +torch/utils/hipify/__pycache__/hipify_python.cpython-310.pyc,, +torch/utils/hipify/__pycache__/version.cpython-310.pyc,, +torch/utils/hipify/constants.py,sha256=XMPSjLLynzylQ_lW3jylmkB2fGUthI3kQqwKJWGSKBk,1200 +torch/utils/hipify/cuda_to_hip_mappings.py,sha256=22Zy5BND9swiq2X7ZacwU4ojDzX5t6Orr1LJ82Wn9Uk,348119 +torch/utils/hipify/hipify_python.py,sha256=eQn_zpRufDuIhp82ntk32LVTqgJN2kkvx_bAd-oeDqI,46425 +torch/utils/hipify/version.py,sha256=RsZjRjMprNcDm97wqRRSk6rTLgTX8N0GyicZyZ8OsBQ,22 +torch/utils/hooks.py,sha256=bdxWCPwzQ5zQxM9N57krvXS4viFgtqPFw7vfcs_zwks,9528 +torch/utils/jit/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +torch/utils/jit/__pycache__/__init__.cpython-310.pyc,, +torch/utils/jit/__pycache__/log_extract.cpython-310.pyc,, +torch/utils/jit/log_extract.py,sha256=AETiMJTS46P_lyJkCfOedUenL7szMSnvDs4WO0J4neU,3754 +torch/utils/mkldnn.py,sha256=J3fqvnMzWHBpRIb8xTeRgj5ro9w3YmmqddmqHnBcgVU,7881 +torch/utils/mobile_optimizer.py,sha256=f17PC3YKkq7I4xOTHvoBCxX_8TgTEVALvEIkrB7AAgI,6423 +torch/utils/model_dump/__init__.py,sha256=vP9n6AkIP2LAlPBmc_3OiZk-AT4jX6Uljh_d8G7lliw,16754 +torch/utils/model_dump/__main__.py,sha256=jYGPuoI11jzWgGKtK1-E550XLfPkrbHq_BRUbLusK-A,79 +torch/utils/model_dump/__pycache__/__init__.cpython-310.pyc,, +torch/utils/model_dump/__pycache__/__main__.cpython-310.pyc,, +torch/utils/model_dump/code.js,sha256=70w_JAT7N8dkWHrpQsA1enZCJK7VJOIy23ukbbbXQAg,19251 +torch/utils/model_dump/htm.mjs,sha256=m-psDFjVL3_BzcZnYkiRT8AIYhFhCY5ERrh_LP4sEH4,1230 +torch/utils/model_dump/preact.mjs,sha256=005yDhrtmGbeMNCyf7SMhNktZT4VisnDde1R-TMD5gk,10078 +torch/utils/model_dump/skeleton.html,sha256=vq4r1yFKZEchXwQmky1zpj3q65MCPDBD7wDt6SqzJGg,384 +torch/utils/model_zoo.py,sha256=o2NC-XaU8fqDXbUBQDv7thQBld_LOK-Ko63GS4x8Iyg,117 +torch/utils/show_pickle.py,sha256=KfoAGvYjukNkB6MHscKvx3gjO-Ry2EPKxepvn3_cTnk,5334 +torch/utils/tensorboard/__init__.py,sha256=9NIYMYOGpyaLBWDL3a1sp44BdncOM2aYXYuZkNsnNJM,434 +torch/utils/tensorboard/__pycache__/__init__.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_caffe2_graph.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_convert_np.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_embedding.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_onnx_graph.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_proto_graph.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_pytorch_graph.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/_utils.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/summary.cpython-310.pyc,, +torch/utils/tensorboard/__pycache__/writer.cpython-310.pyc,, +torch/utils/tensorboard/_caffe2_graph.py,sha256=aQDRkYLJVoSJutLOYKu-27EIOMyaiJnEjOlIkMGas1Q,26528 +torch/utils/tensorboard/_convert_np.py,sha256=RqxOXlMuKXx3jevGoHSI0IRDfumzk9Cfi4NQzUo9PL4,931 +torch/utils/tensorboard/_embedding.py,sha256=9RfoK_QFL9hT0y8hDtGoR9avgUeglMSQBQ97EgBGcPc,3197 +torch/utils/tensorboard/_onnx_graph.py,sha256=gvZyqZ01o9sZk0tY4ZbF4JlZ0q7h7_et_NTgYAi5TB0,1896 +torch/utils/tensorboard/_proto_graph.py,sha256=L9ITCuIlruA_nLRoIInsrZB4hOHOIbFGWVR9O_M4rIE,1731 +torch/utils/tensorboard/_pytorch_graph.py,sha256=2-SAR55nWt5Zf8H7Gkh_VIWEGhnfb8qIGnqbRECDbDk,13852 +torch/utils/tensorboard/_utils.py,sha256=bB7a1K-YoFLxW-ZaC0zPz47r6_EAOLEMQRGSculCI98,4132 +torch/utils/tensorboard/summary.py,sha256=Os1AjgPitcqMPtNe9Cwe7YojudEZjgurAaGaZ4IKl-M,34450 +torch/utils/tensorboard/writer.py,sha256=PcMI39yZG5OPeX3CdBmJf3ePtuvuaUGRGYjXafnqdf8,49373 +torch/utils/throughput_benchmark.py,sha256=PdbXMVXrAzDJCGDxBL1n2pS_RX9_JLYkspzA6-qGIks,6475 +torch/utils/viz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torch/utils/viz/__pycache__/__init__.cpython-310.pyc,, +torch/utils/viz/__pycache__/_cycles.cpython-310.pyc,, +torch/utils/viz/_cycles.py,sha256=sk7G36-3j36deOXvM7uOlyXqNFegRa4DPGP9QwCGQvM,14731 +torch/utils/weak.py,sha256=XvcvHu6eByiTsZBg5nkxqKSpzo5rNQuraRVTKJZOdOs,11043 +torch/version.py,sha256=VN9HRt1lyhSuC_Q-4oPAWbZ4QfQggM6NhFU_qKjqFak,248 +torch/xpu/__init__.py,sha256=-cdX7jIszGCnQ0piWlvMIyeQHByc3CrBjx49XvQedPc,15480 +torch/xpu/__pycache__/__init__.cpython-310.pyc,, +torch/xpu/__pycache__/_utils.cpython-310.pyc,, +torch/xpu/__pycache__/random.cpython-310.pyc,, +torch/xpu/__pycache__/streams.cpython-310.pyc,, +torch/xpu/_utils.py,sha256=JTETOkI3J7tp4SFKV3ukRlvQDO-6Qg850KkJ8wO6gh0,1591 +torch/xpu/random.py,sha256=gIwDBj51xPEfwa4a_xH-1oyTJO9AQdBHPXBC-PgpmEs,5217 +torch/xpu/streams.py,sha256=RWI7Y1ARIOAQfIiYL9y2qC4avqd9oPsuK7uVIefUI3E,5470 +torchgen/__init__.py,sha256=iirTpG38WcCsNMhEbi1dg7_jad6ptk_uzZ-BzaGBFyU,348 +torchgen/__pycache__/__init__.cpython-310.pyc,, +torchgen/__pycache__/code_template.cpython-310.pyc,, +torchgen/__pycache__/context.cpython-310.pyc,, +torchgen/__pycache__/gen.cpython-310.pyc,, +torchgen/__pycache__/gen_aoti_c_shim.cpython-310.pyc,, +torchgen/__pycache__/gen_backend_stubs.cpython-310.pyc,, +torchgen/__pycache__/gen_executorch.cpython-310.pyc,, +torchgen/__pycache__/gen_functionalization_type.cpython-310.pyc,, +torchgen/__pycache__/gen_lazy_tensor.cpython-310.pyc,, +torchgen/__pycache__/gen_vmap_plumbing.cpython-310.pyc,, +torchgen/__pycache__/local.cpython-310.pyc,, +torchgen/__pycache__/model.cpython-310.pyc,, +torchgen/__pycache__/native_function_generation.cpython-310.pyc,, +torchgen/__pycache__/utils.cpython-310.pyc,, +torchgen/__pycache__/yaml_utils.cpython-310.pyc,, +torchgen/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/api/__pycache__/__init__.cpython-310.pyc,, +torchgen/api/__pycache__/autograd.cpython-310.pyc,, +torchgen/api/__pycache__/cpp.cpython-310.pyc,, +torchgen/api/__pycache__/dispatcher.cpython-310.pyc,, +torchgen/api/__pycache__/functionalization.cpython-310.pyc,, +torchgen/api/__pycache__/lazy.cpython-310.pyc,, +torchgen/api/__pycache__/meta.cpython-310.pyc,, +torchgen/api/__pycache__/native.cpython-310.pyc,, +torchgen/api/__pycache__/python.cpython-310.pyc,, +torchgen/api/__pycache__/structured.cpython-310.pyc,, +torchgen/api/__pycache__/translate.cpython-310.pyc,, +torchgen/api/__pycache__/ufunc.cpython-310.pyc,, +torchgen/api/__pycache__/unboxing.cpython-310.pyc,, +torchgen/api/autograd.py,sha256=T7b5zOBBGf-CftiQMd_Q4ivOvOOZQY5-S7Xex3aMMbY,38402 +torchgen/api/cpp.py,sha256=c9lh76NlFisFN9nvNQEcdJEPcObPL-_6LWV2Ax8T2Z8,16456 +torchgen/api/dispatcher.py,sha256=dcD3zGsejoxnIo24j7ZluQlELwlYGN7xt-lhCu1sFf0,3365 +torchgen/api/functionalization.py,sha256=pPJAMcqP5f3_jltdu6UsdUlvG3MfO8UqlAlsKCgRhBk,7571 +torchgen/api/lazy.py,sha256=i_UDcZRVX0KxzSXHFVmRPuGVwiSm6dkn5Ep-sMI5UuQ,17022 +torchgen/api/meta.py,sha256=Nn2a0cqNmu2EFJz6Lyyooty0W8TCHeibs21b5GBEXt4,482 +torchgen/api/native.py,sha256=iWsl_HVvZ0LZNF4r_P59ee-cc6Xezkn__UxKr0E0y90,5136 +torchgen/api/python.py,sha256=7qLdFZWFSCSF_F0qqlrWnW3XCRzXmNhGe2HEjAaRLdM,58569 +torchgen/api/structured.py,sha256=JaybRL0Kbwq8EpYvZePCr5vD5PrhRpEO9wy1NvwOaZc,6115 +torchgen/api/translate.py,sha256=em1ksr3nrIoYRiaCHEZG6KCass1J7SR06fD5EyfZMgs,19179 +torchgen/api/types/__init__.py,sha256=a6PpYNAoVb4KtAclJR8Y8J4I1VcNZ1LIx_SAIdQ2hpk,87 +torchgen/api/types/__pycache__/__init__.cpython-310.pyc,, +torchgen/api/types/__pycache__/signatures.cpython-310.pyc,, +torchgen/api/types/__pycache__/types.cpython-310.pyc,, +torchgen/api/types/__pycache__/types_base.cpython-310.pyc,, +torchgen/api/types/signatures.py,sha256=ACdrryc16bGRWxkBmT2G3S7ZVCkhZIwI5muXAZKZ4XQ,15671 +torchgen/api/types/types.py,sha256=n9bGkaIDAEm_dwqREdAfhOWlnUz7diAvyQe42qJP-p0,6520 +torchgen/api/types/types_base.py,sha256=4FEbQm61mLe3vfjrsO-KNnPjHWNy5fzYQiuoZTrgpRw,8949 +torchgen/api/ufunc.py,sha256=9CBk5dFzYj4xN9idf4zvkpIEav8vNdPIEhPv0wr7IYA,6698 +torchgen/api/unboxing.py,sha256=mS6g3e2Y6ZDfzhhr8y19qgsWGyCgGWd90llgLuatqqM,9460 +torchgen/code_template.py,sha256=z3N3FvXHfvO2aLIu2LoFqe7XGpzbFfzXEyzhGez2KME,2903 +torchgen/context.py,sha256=798e45g0zoR69Xn_4HjTuBRXbuNnyyK-j5_vWOnrs_s,3974 +torchgen/dest/__init__.py,sha256=5tJcjfIVpy5jHVFjkP4L33-zainx1zo2A-IXOt2W5uE,753 +torchgen/dest/__pycache__/__init__.cpython-310.pyc,, +torchgen/dest/__pycache__/lazy_ir.cpython-310.pyc,, +torchgen/dest/__pycache__/lazy_ts_lowering.cpython-310.pyc,, +torchgen/dest/__pycache__/native_functions.cpython-310.pyc,, +torchgen/dest/__pycache__/register_dispatch_key.cpython-310.pyc,, +torchgen/dest/__pycache__/ufunc.cpython-310.pyc,, +torchgen/dest/lazy_ir.py,sha256=nDEzH6CG9-oPkK9zjJeVMF7ElIuhBfsflX-P-rP18j4,29111 +torchgen/dest/lazy_ts_lowering.py,sha256=9QUvL_Z-mGqRfhtK_X2RSEHlGmFOqDr_J8cYJrALUG4,1831 +torchgen/dest/native_functions.py,sha256=A1ouzHcvvEPGQbD6Lc7NFH8ORNYaiNTyL8DRegxctA0,2328 +torchgen/dest/register_dispatch_key.py,sha256=3QK3Hye8l_wrehcAucelT7NgOl-gvTsjl8LD5fxdUWQ,40373 +torchgen/dest/ufunc.py,sha256=GbRnCx5N4J82M3-pJsLPGKuqRIpoZRRpJfQOvwcvGWM,17800 +torchgen/executorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/executorch/__pycache__/__init__.cpython-310.pyc,, +torchgen/executorch/__pycache__/model.cpython-310.pyc,, +torchgen/executorch/__pycache__/parse.cpython-310.pyc,, +torchgen/executorch/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/executorch/api/__pycache__/__init__.cpython-310.pyc,, +torchgen/executorch/api/__pycache__/custom_ops.cpython-310.pyc,, +torchgen/executorch/api/__pycache__/et_cpp.cpython-310.pyc,, +torchgen/executorch/api/__pycache__/unboxing.cpython-310.pyc,, +torchgen/executorch/api/custom_ops.py,sha256=9DXqPHZRXWKj40MkBFVPLOtWTqVhUtQVCni6gqXbYcE,5351 +torchgen/executorch/api/et_cpp.py,sha256=STArjOc3MTSAvAQU1wrITCupiyLv7bS35GLK6UNROaQ,12961 +torchgen/executorch/api/types/__init__.py,sha256=-4pCMsRpHwq2I5yJ-yM4NDXF7wFJ4XJILXRTl8uFxnQ,61 +torchgen/executorch/api/types/__pycache__/__init__.cpython-310.pyc,, +torchgen/executorch/api/types/__pycache__/signatures.cpython-310.pyc,, +torchgen/executorch/api/types/__pycache__/types.cpython-310.pyc,, +torchgen/executorch/api/types/signatures.py,sha256=hpvEEpH5Mn4N3I8o_49429iKtOcwfnxTuq62iFKjuFY,2490 +torchgen/executorch/api/types/types.py,sha256=83ml9nH_8gXjWNxM-XPg_4T59Nc8agIC2tQPsBn6czk,2432 +torchgen/executorch/api/unboxing.py,sha256=WpEP-0ivtnsaoOMHQXSZAm5w7Ji3gJo8obBOHLSsltY,7764 +torchgen/executorch/model.py,sha256=Vs7K0kluYO64I1pas_O8Z-BIxyN8dJ_8sZJpZdjzUPc,7710 +torchgen/executorch/parse.py,sha256=FiAuXT3T2xlKOajjQQ65RZMIzurR5bqLP2FFZ_XxeoA,5423 +torchgen/gen.py,sha256=6bxDFaaNO--A9HQ17iZ7wYVWabuWI4ElZLXn0Jg3guQ,110909 +torchgen/gen_aoti_c_shim.py,sha256=ol1FFKKqCQS4fuGzmmdrgXDIsQpyQrFIrzzKRNzKgrU,14879 +torchgen/gen_backend_stubs.py,sha256=iM2aW5KPY4EIm5bmIJoeVEUYHfsiYB5mePVVKIe-pnU,22374 +torchgen/gen_executorch.py,sha256=3mx28-P6PiduN1P2bRVUrWXlwjmzKbe-JUpzGEYqHKI,36272 +torchgen/gen_functionalization_type.py,sha256=TRd1VVmtZCCvoTa9XzO7Pr0SAwQZo2HHQ-35oSuOAsU,35523 +torchgen/gen_lazy_tensor.py,sha256=6jSRjolxW3Cm6mCXPRfYY1aNzPNU1JbFvucpo1ZdQ-M,23236 +torchgen/gen_vmap_plumbing.py,sha256=BY5rJybZTgodlH744u1rSz6gO7IRnsuwloO6Hxt35J8,9188 +torchgen/local.py,sha256=4-uRxPk3ik_9v_Uf15J02g8DR5RUkqLr6jjMrdELYeA,2091 +torchgen/model.py,sha256=541K-9UprS9Kr2H6FvtaDjGriUsUn7haBAAKrEyPnyA,111319 +torchgen/native_function_generation.py,sha256=vb_qHdNjEZC1LpxADtgNuw2R0CPTEe8XgtEe81Wh-Yc,29550 +torchgen/operator_versions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/operator_versions/__pycache__/__init__.cpython-310.pyc,, +torchgen/operator_versions/__pycache__/gen_mobile_upgraders.cpython-310.pyc,, +torchgen/operator_versions/__pycache__/gen_mobile_upgraders_constant.cpython-310.pyc,, +torchgen/operator_versions/gen_mobile_upgraders.py,sha256=S_UmAjn2NjYItggyO0JDUvaKj7OYkpKHGZCLUEiYFSY,12660 +torchgen/operator_versions/gen_mobile_upgraders_constant.py,sha256=C-U6rHQybm_FTcxsz27RMgJDj464NOLhlOzVjSjEn0w,243 +torchgen/packaged/ATen/native/native_functions.yaml,sha256=siTRXTfVnOCu32p7itWOtf4kJnN4b7E3fo0oXZ4aCao,581965 +torchgen/packaged/ATen/native/tags.yaml,sha256=sJLINHqLeGmBIawEPQE7RZsgzrg38Uq0kLpfbDzizLM,3311 +torchgen/packaged/ATen/templates/ATenOpList.cpp,sha256=YobnhIm91ECCc6uYD2uDOrvFM4WqutKQbQ5x_Fh_5IE,1059 +torchgen/packaged/ATen/templates/CompositeViewCopyKernels.cpp,sha256=H64AHoCBB7MJIECAHNzki8NiTVPND0hy2vJ-KqiSF2c,2077 +torchgen/packaged/ATen/templates/DispatchKeyFunction.h,sha256=npUU8WpU76sZv8oqUQqBpcV_QHT6RW9j42EVTSA6pvA,702 +torchgen/packaged/ATen/templates/DispatchKeyFunctions.h,sha256=iBAyyG_T0y--B0hMJy5Ly0mnUhWLzD8GLJLT5YpDBDQ,1932 +torchgen/packaged/ATen/templates/DispatchKeyFunctions_inl.h,sha256=nlAU0xWHQqRZn7JNV163YgAv5wwlykwsikMyjzZeZkI,824 +torchgen/packaged/ATen/templates/DispatchKeyNativeFunctions.cpp,sha256=DYjxJmYQ5Yegq1XW4hakqjvZo5skNWi2f5ZNLPUyQ4c,184 +torchgen/packaged/ATen/templates/DispatchKeyNativeFunctions.h,sha256=e8lUNJZ4jt0uMHjio6HOupVpMv83DtAaFBudAG6pEDw,384 +torchgen/packaged/ATen/templates/Function.h,sha256=QSbPrsdWGgcW5Wl4a_KSIyHqQEH-3T7h2RM2Q5IQ3dA,507 +torchgen/packaged/ATen/templates/FunctionalInverses.h,sha256=azlMYM1eJqDFCBeDRBEgpKgbeDIsWLIPEWBVyLVoocY,1231 +torchgen/packaged/ATen/templates/Functions.cpp,sha256=NRQfSQo5Ot7SebfjhJtqLregJS222jr-SFY9mZ1Amq4,3024 +torchgen/packaged/ATen/templates/Functions.h,sha256=ORykJWXUsHoaADA5aV4-IOgBTWn7UdIplNBX_1d6ON0,4688 +torchgen/packaged/ATen/templates/LazyIr.h,sha256=mFY0bv2tEUtDp0ypCelVq_RgtbgUA_HW7mikUq6a0-8,575 +torchgen/packaged/ATen/templates/LazyNonNativeIr.h,sha256=KQbjyZ0Q8qK8JcgqAaF-M-ZhvRE5UhTj8JIHyceNK9Y,178 +torchgen/packaged/ATen/templates/MethodOperators.h,sha256=ifirYleNPll8bjo_OYaC8jEuLWIJlP0Asy0xjtdGfQo,830 +torchgen/packaged/ATen/templates/NativeFunction.h,sha256=aC1du7h-uGx3GzxW9GbtCYfL4Rt0bVbG-Ep_wVMgvpo,377 +torchgen/packaged/ATen/templates/NativeFunctions.h,sha256=Cgf_eYRzaczDydEIGxh35wfBBZAF4X6fJt-CFUhTmwM,1160 +torchgen/packaged/ATen/templates/NativeMetaFunction.h,sha256=aUwcQS2n2k_RV0L2CbMY1PWTVzMghD38-PH406UdNq4,463 +torchgen/packaged/ATen/templates/NativeMetaFunctions.h,sha256=mIOwmpkQY9zYolxUXK39c4nRDyG32vBsqEeSDo76p_k,306 +torchgen/packaged/ATen/templates/Operator.h,sha256=ymuBaaHDKS1QZ-7yiHOUmjX-eyCxsjD1v6_ZUGKvz8o,425 +torchgen/packaged/ATen/templates/Operators.cpp,sha256=cjfjkIMtfc8n1w0TDy_JJDJq0DK2cT9DfhkZw3YnTWM,347 +torchgen/packaged/ATen/templates/Operators.h,sha256=oU939CI59Drfg2QlKfkCdU6yVQBVi0y9Ia_kQ0rFC5k,3200 +torchgen/packaged/ATen/templates/RedispatchFunctions.cpp,sha256=pNhfp3gMBw4km2c_4EfeF6ge3DGZi8xtGCnkmjzfpi0,307 +torchgen/packaged/ATen/templates/RedispatchFunctions.h,sha256=RMRWieLHLURueB27BhW7UQty4ZC2MDfzdqskH6OCTTI,893 +torchgen/packaged/ATen/templates/RegisterBackendSelect.cpp,sha256=CbER4E6ck_Csz3WrmSE87QwrlY0rw6gx8A9vOHRx3ek,1998 +torchgen/packaged/ATen/templates/RegisterCodegenUnboxedKernels.cpp,sha256=tux2wSt9RalK0o5AfliXJB3N4diTi-88PwNHOobDbmM,1119 +torchgen/packaged/ATen/templates/RegisterDispatchDefinitions.ini,sha256=E8PNfTGFdvYUkk6YN0K-cfXRf61KazOov2ogDWmDFDU,476 +torchgen/packaged/ATen/templates/RegisterDispatchKey.cpp,sha256=ka3DGWd5YkeXGzxmp7V7568JwLBPnjnBBf82e0Frv_w,1645 +torchgen/packaged/ATen/templates/RegisterFunctionalization.cpp,sha256=lTxayWrPbsg4XHLVMSOkNH9TuQurD8t8mMr4Ls-DhGM,3366 +torchgen/packaged/ATen/templates/RegisterSchema.cpp,sha256=HoLTDNwRhe8xJJucgd6qCkqTglPtxLYCRGCD_4-S0j0,383 +torchgen/packaged/ATen/templates/RegistrationDeclarations.h,sha256=KImic_ILyhxavbGxVna-Ascf--okibalZJlK44a5dic,160 +torchgen/packaged/ATen/templates/TensorBody.h,sha256=Jha5yCU37PXIbC04ghOQbC1KFWQSqELacxrjYac8RJc,29146 +torchgen/packaged/ATen/templates/TensorMethods.cpp,sha256=x541hSdseYz2jdqFdKNHW2cEWAHxzV313FYfHg2s1OQ,2624 +torchgen/packaged/ATen/templates/UfuncCPU.cpp,sha256=LrnISndBkXtdugvOWeRk9ZGYQlztFI5yqytoaZiKOQk,445 +torchgen/packaged/ATen/templates/UfuncCPUKernel.cpp,sha256=paz66F7U6E9e2X-rpbxlVDGcxevcXIOialaEqAaoArc,350 +torchgen/packaged/ATen/templates/UfuncCUDA.cu,sha256=HOBz8yO4QFxxmX_6gCF7L8MJvrGPwGQjoE-qDf8kF9Y,494 +torchgen/packaged/ATen/templates/UnboxingFunctions.cpp,sha256=wwdlYUaaCjXwhlaoqieeO-3fOqoQSBj62j6Is4n-UKY,709 +torchgen/packaged/ATen/templates/UnboxingFunctions.h,sha256=bcs4ET0LLtzs7nSSWhKA8jJzongib5CGlNA5yaExfKw,1026 +torchgen/packaged/ATen/templates/aten_interned_strings.h,sha256=_FM2jXAhATj9GZ66dXXUPx72q2uYnzT8iN4hkTz0rmI,805 +torchgen/packaged/ATen/templates/enum_tag.h,sha256=w3hCov4CToJ5qyHrnadei9907AIZkDLALSOlOZ1gP2Q,179 +torchgen/packaged/autograd/BUILD.bazel,sha256=Jd76gG6LQlmmEKK9IYlDbkVSmc8L5bTvGjG159L3rJA,104 +torchgen/packaged/autograd/README.md,sha256=hGiUzBaCs0wzBhEXB3vkWUXU4Lima6y5_wPKjAoKQ-Q,147 +torchgen/packaged/autograd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/packaged/autograd/__pycache__/__init__.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/context.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_annotated_fn_args.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_autograd.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_autograd_functions.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_inplace_or_view_type.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_python_functions.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_trace_type.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_variable_factories.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_variable_type.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/gen_view_funcs.cpython-310.pyc,, +torchgen/packaged/autograd/__pycache__/load_derivatives.cpython-310.pyc,, +torchgen/packaged/autograd/build.bzl,sha256=P4Ox76V35gWtKl8p08d-av4YEb10BC5Lcr5qHiqK7uE,348 +torchgen/packaged/autograd/context.py,sha256=zGoFTCXNnWbHWdkLRKYxIv2Xg41lEv7evO8WIvg1LKI,943 +torchgen/packaged/autograd/deprecated.yaml,sha256=UbtajzWo89jf1Q5sw8JNJIZT5s-iDBagnrGJthtDS2Q,6250 +torchgen/packaged/autograd/derivatives.yaml,sha256=5C9Qelz6M4ry4Z1xh9C3l6ryCMWnuzLKrzYSSNsDAWM,173423 +torchgen/packaged/autograd/gen_annotated_fn_args.py,sha256=cTpcqGEj2xBDorwmLCVHmdY-19340lLzHONvmFEmVes,4383 +torchgen/packaged/autograd/gen_autograd.py,sha256=lvrRRTed4lMmEYG9IHigovGvyrEc3CvU9OFCuomYrI0,4603 +torchgen/packaged/autograd/gen_autograd_functions.py,sha256=nZ2LzzDov9tMrNJU2Kt4rUFhZz3nnAhwGyuXsqYmB94,32091 +torchgen/packaged/autograd/gen_inplace_or_view_type.py,sha256=i_ycJUdKySO95L-JAwv86Sjq07Rl0rOFYan3lJxythA,22806 +torchgen/packaged/autograd/gen_python_functions.py,sha256=zcz24J6huIqrD6qWXF1GTuO7FHdF_hgNlzMD6SMwNSE,46245 +torchgen/packaged/autograd/gen_trace_type.py,sha256=_ZjiAojVs65yN4L_WhcX4Q23TiFF5keLHUy_mG_kYdg,18926 +torchgen/packaged/autograd/gen_variable_factories.py,sha256=vY-OLC3hBEZpi5poZawF5osX7xu3t7OiqATWnI2CCK8,4478 +torchgen/packaged/autograd/gen_variable_type.py,sha256=Gt7fwkqR5bN-Y6eHji88UmUoj4kx-O_MHwn0gcjp1uM,83380 +torchgen/packaged/autograd/gen_view_funcs.py,sha256=B5iSzCUEAa5aLmnxJwyIiAFETOkeUkYQnZ0KISyPlAQ,11533 +torchgen/packaged/autograd/load_derivatives.py,sha256=Pt3zo9tgQ34-VoQekEP5xU9L7Dpo__3DVcljui2_ftY,40333 +torchgen/packaged/autograd/templates/ADInplaceOrViewType.cpp,sha256=6juXEdMJaxhS1nv6bqUmx-cJLWPyc4Yb3teAeTyEBG4,790 +torchgen/packaged/autograd/templates/Functions.cpp,sha256=T2Mf85iPLHVAs3-Qen3YQ5f6-rSLQPEa9fvxn5wWujs,623 +torchgen/packaged/autograd/templates/Functions.h,sha256=T3ZfumgZc_bVfqLSg1WfqN6pZJm2Laskcl3EY8jx3jA,1575 +torchgen/packaged/autograd/templates/TraceType.cpp,sha256=aqACTyrT05ElIiBLJYkfSgxNjwhum6_QUPDAtXwoKqo,695 +torchgen/packaged/autograd/templates/VariableType.cpp,sha256=40JaiDOkY_86ndvGzap_UWqNg-b_XQQxPqXnsKSMhzc,1859 +torchgen/packaged/autograd/templates/VariableType.h,sha256=CSm2P1Pi37HXFv9FeFhfjbNbzW3GiE5B-c8f4CVHcec,1692 +torchgen/packaged/autograd/templates/ViewFuncs.cpp,sha256=oas1Pw6wWyAfRy2uh5K7fGD3qR60LD2Oiv-B5OW6Tvc,269 +torchgen/packaged/autograd/templates/ViewFuncs.h,sha256=5jQ6RzJPZiiJd0thIxfLn_86_GjIhLgmGtmNdM2C5vc,498 +torchgen/packaged/autograd/templates/annotated_fn_args.py.in,sha256=gRgF9BZmylhyfXrVSAVjg9Y4TUYpq1FgYVd3_hk_9no,199 +torchgen/packaged/autograd/templates/python_enum_tag.cpp,sha256=2cTLq6vaU-qjAXLrChZAnCmpVqA4oDvZLOsBY3GWmDA,495 +torchgen/packaged/autograd/templates/python_fft_functions.cpp,sha256=g8Ub5jh_YhgeourCXjB2zlH15Lm_oGwLa37IjibMoEc,1951 +torchgen/packaged/autograd/templates/python_functions.cpp,sha256=b20LJcBbbQHQ4hTt-2h__DIuk8uHksD4ZVD5csfM43Q,1121 +torchgen/packaged/autograd/templates/python_functions.h,sha256=WX52FzntisoprdObQvGXrzMhehgWZ2rIfnHzgNpX-5U,345 +torchgen/packaged/autograd/templates/python_linalg_functions.cpp,sha256=3NyK1tMOYwAsnxyb1k04RPiN9MQkriblY3GnPVOrfSY,1614 +torchgen/packaged/autograd/templates/python_nested_functions.cpp,sha256=2wivRfIBY8pkU9mqHVQfqnsIff6K1Al-BTJyRFuUeAw,2029 +torchgen/packaged/autograd/templates/python_nn_functions.cpp,sha256=DmCDpzr-eJg35kRP6V_FCO1cuSju11KAX9dYlh9ehV8,3500 +torchgen/packaged/autograd/templates/python_return_types.cpp,sha256=GB75OiT-5X3rmgXZlc30MB67qMlvqkzhrDIfIj1mZp4,1219 +torchgen/packaged/autograd/templates/python_return_types.h,sha256=ZDLPH-bxSjCpeyWLhU6kZsuAxa2pnCgTE57YpxXmDmQ,198 +torchgen/packaged/autograd/templates/python_sparse_functions.cpp,sha256=NW_L2mF7ZrR2FvXtDE7iNfw0BM-wTyUzBa_C1B5RZ7A,1551 +torchgen/packaged/autograd/templates/python_special_functions.cpp,sha256=JqcAExUPCnbzUujY2PIDL5Gap-ZKlltKiZmDTleO_8s,1972 +torchgen/packaged/autograd/templates/python_torch_functions.cpp,sha256=QEgUPJbi5TunkkQog-o6zoIjpLFZ6VFHQYxKe7BUAiw,2601 +torchgen/packaged/autograd/templates/python_variable_methods.cpp,sha256=xpr95Ob6YU9xevFxzP3kYRxWYH57HAYAjxCCFvIwtCw,51354 +torchgen/packaged/autograd/templates/variable_factories.h,sha256=doAqR5o4vMmLvF6MpXwt-g-4018fGN_ZvjdPY4AOOyc,5627 +torchgen/selective_build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/selective_build/__pycache__/__init__.cpython-310.pyc,, +torchgen/selective_build/__pycache__/operator.cpython-310.pyc,, +torchgen/selective_build/__pycache__/selector.cpython-310.pyc,, +torchgen/selective_build/operator.py,sha256=kutwN9yc2Bt7k7h7GV1ts8C1qORjeU-J5zAJW84ASJ8,6507 +torchgen/selective_build/selector.py,sha256=KYfNNS9dWTyygrfDLOEuEAQn3f-Gn2f9wwVxibj5VUM,12606 +torchgen/static_runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +torchgen/static_runtime/__pycache__/__init__.cpython-310.pyc,, +torchgen/static_runtime/__pycache__/config.cpython-310.pyc,, +torchgen/static_runtime/__pycache__/gen_static_runtime_ops.cpython-310.pyc,, +torchgen/static_runtime/__pycache__/generator.cpython-310.pyc,, +torchgen/static_runtime/config.py,sha256=fEMB4EdO8aX47aW13s-nVSy-yM5qIzfXrOYaQkmv3-A,14493 +torchgen/static_runtime/gen_static_runtime_ops.py,sha256=Esr32XW78YkLpGAGhIw6ZsxmkwgI_Pd3j0rh585ijow,7347 +torchgen/static_runtime/generator.py,sha256=Sfe8TR6inZv-FHhJAG6gXBFXutPVMO8I4Uzw3xnGdd4,26374 +torchgen/utils.py,sha256=vKAr8cqbBBQG13vJi-_gRuRm0IOCb6oN7ANE7S4Ch7M,15896 +torchgen/yaml_utils.py,sha256=Xhwu0FkP6tsRKYQi34JG9BfgHclejg_FhI8mAzzD5DM,1080 diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d77a3981e5ea20c488afb479f81f1868349f78c3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.34.2) +Root-Is-Purelib: false +Tag: cp310-cp310-linux_x86_64 + diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/entry_points.txt b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..81f31e07756d03476390e468e9eb4583eb4157ec --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/entry_points.txt @@ -0,0 +1,8 @@ +[console_scripts] +convert-caffe2-to-onnx = caffe2.python.onnx.bin.conversion:caffe2_to_onnx +convert-onnx-to-caffe2 = caffe2.python.onnx.bin.conversion:onnx_to_caffe2 +torchrun = torch.distributed.run:main + +[torchrun.logs_specs] +default = torch.distributed.elastic.multiprocessing:DefaultLogsSpecs + diff --git a/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..90d81bec1d35eb3996334268974885a5398b6c6c --- /dev/null +++ b/venv/lib/python3.10/site-packages/torch-2.3.0.dist-info/top_level.txt @@ -0,0 +1,3 @@ +functorch +torch +torchgen