Add files using upload-large-folder tool

.gitattributes

@@ -499,3 +499,5 @@ moondream/lib/python3.10/site-packages/torch/__pycache__/_tensor_docs.cpython-31
 moondream/lib/python3.10/site-packages/torch/_inductor/codegen/__pycache__/cpp.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 moondream/lib/python3.10/site-packages/torch/fx/experimental/__pycache__/symbolic_shapes.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 moondream/lib/python3.10/site-packages/sympy/solvers/ode/__pycache__/single.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+moondream/lib/python3.10/site-packages/sympy/core/__pycache__/numbers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+moondream/lib/python3.10/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/exceptions.pyi

@@ -0,0 +1,43 @@
+from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple, Union
+
+from django.forms.utils import ErrorDict
+
+class FieldDoesNotExist(Exception): ...
+class AppRegistryNotReady(Exception): ...
+
+class ObjectDoesNotExist(Exception):
+    silent_variable_failure: bool = ...
+
+class MultipleObjectsReturned(Exception): ...
+class SuspiciousOperation(Exception): ...
+class SuspiciousMultipartForm(SuspiciousOperation): ...
+class SuspiciousFileOperation(SuspiciousOperation): ...
+class DisallowedHost(SuspiciousOperation): ...
+class DisallowedRedirect(SuspiciousOperation): ...
+class TooManyFieldsSent(SuspiciousOperation): ...
+class RequestDataTooBig(SuspiciousOperation): ...
+class PermissionDenied(Exception): ...
+class ViewDoesNotExist(Exception): ...
+class MiddlewareNotUsed(Exception): ...
+class ImproperlyConfigured(Exception): ...
+class FieldError(Exception): ...
+
+NON_FIELD_ERRORS: str
+
+class ValidationError(Exception):
+    error_dict: Any = ...
+    error_list: Any = ...
+    message: Any = ...
+    code: Any = ...
+    params: Any = ...
+    def __init__(self, message: Any, code: Optional[str] = ..., params: Optional[Mapping[str, Any]] = ...) -> None: ...
+    @property
+    def message_dict(self) -> Dict[str, List[str]]: ...
+    @property
+    def messages(self) -> List[str]: ...
+    def update_error_dict(
+        self, error_dict: Mapping[str, Any]
+    ) -> Union[Dict[str, List[ValidationError]], ErrorDict]: ...
+    def __iter__(self) -> Iterator[Union[Tuple[str, List[str]], str]]: ...
+
+class EmptyResultSet(Exception): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/mail/__init__.pyi

@@ -0,0 +1,48 @@
+from typing import Any, List, Optional, Tuple
+
+from .message import (
+    BadHeaderError as BadHeaderError,
+    DEFAULT_ATTACHMENT_MIME_TYPE as DEFAULT_ATTACHMENT_MIME_TYPE,
+    EmailMessage as EmailMessage,
+    EmailMultiAlternatives as EmailMultiAlternatives,
+    SafeMIMEMultipart as SafeMIMEMultipart,
+    SafeMIMEText as SafeMIMEText,
+    forbid_multi_line_headers as forbid_multi_line_headers,
+)
+from .utils import CachedDnsName as CachedDnsName, DNS_NAME as DNS_NAME
+
+def get_connection(backend: Optional[str] = ..., fail_silently: bool = ..., **kwds: Any) -> Any: ...
+def send_mail(
+    subject: str,
+    message: str,
+    from_email: Optional[str],
+    recipient_list: List[str],
+    fail_silently: bool = ...,
+    auth_user: Optional[str] = ...,
+    auth_password: Optional[str] = ...,
+    connection: Optional[Any] = ...,
+    html_message: Optional[str] = ...,
+) -> int: ...
+def send_mass_mail(
+    datatuple: List[Tuple[str, str, str, List[str]]],
+    fail_silently: bool = ...,
+    auth_user: Optional[str] = ...,
+    auth_password: Optional[str] = ...,
+    connection: Optional[Any] = ...,
+) -> int: ...
+def mail_admins(
+    subject: str,
+    message: str,
+    fail_silently: bool = ...,
+    connection: Optional[Any] = ...,
+    html_message: Optional[str] = ...,
+) -> None: ...
+def mail_managers(
+    subject: str,
+    message: str,
+    fail_silently: bool = ...,
+    connection: Optional[Any] = ...,
+    html_message: Optional[str] = ...,
+) -> None: ...
+
+outbox: List[EmailMessage] = ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/mail/backends/dummy.pyi

@@ -0,0 +1,3 @@
+from django.core.mail.backends.base import BaseEmailBackend
+
+class EmailBackend(BaseEmailBackend): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/mail/utils.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+class CachedDnsName:
+    def get_fqdn(self) -> str: ...
+
+DNS_NAME: Any

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/paginator.pyi

@@ -0,0 +1,62 @@
+from typing import Dict, List, Optional, Protocol, Sequence, Union
+
+from django.db.models.base import Model
+from django.db.models.query import QuerySet
+
+class UnorderedObjectListWarning(RuntimeWarning): ...
+class InvalidPage(Exception): ...
+class PageNotAnInteger(InvalidPage): ...
+class EmptyPage(InvalidPage): ...
+
+class _SupportsLen(Protocol):
+    def __len__(self) -> int: ...
+
+class _SupportsCount(Protocol):
+    def count(self) -> int: ...
+
+class _SupportsOrdered(Protocol):
+    ordered: bool = ...
+
+class Paginator:
+    object_list: QuerySet = ...
+    per_page: int = ...
+    orphans: int = ...
+    allow_empty_first_page: bool = ...
+    def __init__(
+        self,
+        object_list: Union[_SupportsLen, _SupportsCount, _SupportsOrdered],
+        per_page: Union[int, str],
+        orphans: int = ...,
+        allow_empty_first_page: bool = ...,
+    ) -> None: ...
+    def validate_number(self, number: Optional[Union[float, str]]) -> int: ...
+    def get_page(self, number: Optional[int]) -> Page: ...
+    def page(self, number: Union[int, str]) -> Page: ...
+    @property
+    def count(self) -> int: ...
+    @property
+    def num_pages(self) -> int: ...
+    @property
+    def page_range(self) -> range: ...
+
+QuerySetPaginator = Paginator
+
+class Page(Sequence):
+    object_list: QuerySet = ...
+    number: int = ...
+    paginator: Paginator = ...
+    def __init__(
+        self,
+        object_list: Union[List[Dict[str, str]], List[Model], List[int], QuerySet, str],
+        number: int,
+        paginator: Paginator,
+    ) -> None: ...
+    def __getitem__(self, item): ...
+    def __len__(self): ...
+    def has_next(self) -> bool: ...
+    def has_previous(self) -> bool: ...
+    def has_other_pages(self) -> bool: ...
+    def next_page_number(self) -> int: ...
+    def previous_page_number(self) -> int: ...
+    def start_index(self) -> int: ...
+    def end_index(self) -> int: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/serializers/__init__.pyi

@@ -0,0 +1,31 @@
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Type, Union
+
+from django.db.models.base import Model
+
+from .base import (
+    DeserializationError as DeserializationError,
+    DeserializedObject,
+    Deserializer as Deserializer,
+    M2MDeserializationError as M2MDeserializationError,
+    SerializationError as SerializationError,
+    Serializer as Serializer,
+    SerializerDoesNotExist as SerializerDoesNotExist,
+)
+
+BUILTIN_SERIALIZERS: Any
+
+class BadSerializer:
+    internal_use_only: bool = ...
+    exception: BaseException = ...
+    def __init__(self, exception: BaseException) -> None: ...
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+def register_serializer(format: str, serializer_module: str, serializers: Optional[Dict[str, Any]] = ...) -> None: ...
+def unregister_serializer(format: str) -> None: ...
+def get_serializer(format: str) -> Union[Type[Serializer], BadSerializer]: ...
+def get_serializer_formats() -> List[str]: ...
+def get_public_serializer_formats() -> List[str]: ...
+def get_deserializer(format: str) -> Union[Callable, Type[Deserializer]]: ...
+def serialize(format: str, queryset: Iterable[Model], **options: Any) -> Any: ...
+def deserialize(format: str, stream_or_string: Any, **options: Any) -> Iterator[DeserializedObject]: ...
+def sort_dependencies(app_list: Iterable[Any]) -> List[Type[Model]]: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/serializers/base.pyi

@@ -0,0 +1,87 @@
+from datetime import date
+from io import BufferedReader, StringIO, TextIOWrapper
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Type, Union, Collection
+from uuid import UUID
+
+from django.core.management.base import OutputWrapper
+from django.db.models.base import Model
+from django.db.models.fields.related import ForeignKey, ManyToManyField
+
+from django.db.models.fields import Field
+
+class SerializerDoesNotExist(KeyError): ...
+class SerializationError(Exception): ...
+
+class DeserializationError(Exception):
+    @classmethod
+    def WithData(
+        cls, original_exc: Exception, model: str, fk: Union[int, str], field_value: Optional[Union[List[str], str]]
+    ) -> DeserializationError: ...
+
+class M2MDeserializationError(Exception):
+    original_exc: Exception = ...
+    pk: List[str] = ...
+    def __init__(self, original_exc: Exception, pk: Union[List[str], str]) -> None: ...
+
+class ProgressBar:
+    progress_width: int = ...
+    output: None = ...
+    total_count: int = ...
+    prev_done: int = ...
+    def __init__(self, output: Optional[Union[StringIO, OutputWrapper]], total_count: int) -> None: ...
+    def update(self, count: int) -> None: ...
+
+class Serializer:
+    internal_use_only: bool = ...
+    progress_class: Any = ...
+    stream_class: Any = ...
+    options: Dict[str, Any] = ...
+    stream: Any = ...
+    selected_fields: Optional[Collection[str]] = ...
+    use_natural_foreign_keys: bool = ...
+    use_natural_primary_keys: bool = ...
+    first: bool = ...
+    def serialize(
+        self,
+        queryset: Iterable[Model],
+        *,
+        stream: Optional[Any] = ...,
+        fields: Optional[Collection[str]] = ...,
+        use_natural_foreign_keys: bool = ...,
+        use_natural_primary_keys: bool = ...,
+        progress_output: Optional[Any] = ...,
+        object_count: int = ...,
+        **options: Any
+    ) -> Any: ...
+    def start_serialization(self) -> None: ...
+    def end_serialization(self) -> None: ...
+    def start_object(self, obj: Any) -> None: ...
+    def end_object(self, obj: Any) -> None: ...
+    def handle_field(self, obj: Any, field: Any) -> None: ...
+    def handle_fk_field(self, obj: Any, field: Any) -> None: ...
+    def handle_m2m_field(self, obj: Any, field: Any) -> None: ...
+    def getvalue(self) -> Optional[Union[bytes, str]]: ...
+
+class Deserializer:
+    options: Dict[str, Any] = ...
+    stream: Any = ...
+    def __init__(self, stream_or_string: Union[BufferedReader, TextIOWrapper, str], **options: Any) -> None: ...
+    def __iter__(self) -> Deserializer: ...
+    def __next__(self) -> None: ...
+
+class DeserializedObject:
+    object: Any = ...
+    m2m_data: Dict[str, List[int]] = ...
+    deferred_fields: Mapping[Field, Any]
+    def __init__(
+        self,
+        obj: Model,
+        m2m_data: Optional[Dict[str, List[int]]] = ...,
+        deferred_fields: Optional[Mapping[Field, Any]] = ...,
+    ) -> None: ...
+    def save(self, save_m2m: bool = ..., using: Optional[str] = ..., **kwargs: Any) -> None: ...
+    def save_deferred_fields(self, using: Optional[str] = ...) -> None: ...
+
+def build_instance(Model: Type[Model], data: Dict[str, Optional[Union[date, int, str, UUID]]], db: str) -> Model: ...
+def deserialize_m2m_values(field: ManyToManyField, field_value: Any, using: str) -> List[Any]: ...
+def deserialize_fk_value(field: ForeignKey, field_value: Any, using: str) -> Any: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/serializers/json.pyi

@@ -0,0 +1,17 @@
+import json
+from typing import Any, Dict
+
+from django.core.serializers.python import Serializer as PythonSerializer
+
+class Serializer(PythonSerializer):
+    json_kwargs: Dict[str, Any]
+
+def Deserializer(stream_or_string: Any, **options: Any) -> None: ...
+
+class DjangoJSONEncoder(json.JSONEncoder):
+    allow_nan: bool
+    check_circular: bool
+    ensure_ascii: bool
+    indent: int
+    skipkeys: bool
+    sort_keys: bool

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/validators.pyi

@@ -0,0 +1,121 @@
+from decimal import Decimal
+from re import RegexFlag
+from typing import Any, Callable, Collection, Dict, List, Optional, Pattern, Tuple, Union
+
+from django.core.files.base import File
+
+EMPTY_VALUES: Any
+
+_Regex = Union[str, Pattern[str]]
+_ErrorMessage = Union[str, Any]
+
+def _lazy_re_compile(regex: _Regex, flags: int = ...): ...
+
+class RegexValidator:
+    regex: _Regex = ...
+    message: str = ...
+    code: str = ...
+    inverse_match: bool = ...
+    flags: int = ...
+    def __init__(
+        self,
+        regex: Optional[_Regex] = ...,
+        message: Optional[_ErrorMessage] = ...,
+        code: Optional[str] = ...,
+        inverse_match: Optional[bool] = ...,
+        flags: Optional[RegexFlag] = ...,
+    ) -> None: ...
+    def __call__(self, value: Optional[str]) -> None: ...
+
+class URLValidator(RegexValidator):
+    ul: str = ...
+    ipv4_re: str = ...
+    ipv6_re: str = ...
+    hostname_re: str = ...
+    domain_re: str = ...
+    tld_re: str = ...
+    host_re: str = ...
+    schemes: List[str] = ...
+    def __init__(self, schemes: Optional[Collection[str]] = ..., **kwargs: Any) -> None: ...
+
+integer_validator: RegexValidator = ...
+
+def validate_integer(value: Optional[Union[float, str]]) -> None: ...
+
+class EmailValidator:
+    message: str = ...
+    code: str = ...
+    user_regex: Pattern = ...
+    domain_regex: Pattern = ...
+    literal_regex: Pattern = ...
+    domain_whitelist: List[str] = ...
+    def __init__(
+        self,
+        message: Optional[_ErrorMessage] = ...,
+        code: Optional[str] = ...,
+        whitelist: Optional[Collection[str]] = ...,
+    ) -> None: ...
+    def __call__(self, value: Optional[str]) -> None: ...
+    def validate_domain_part(self, domain_part: str) -> bool: ...
+
+validate_email: EmailValidator = ...
+slug_re: Pattern = ...
+validate_slug: RegexValidator = ...
+slug_unicode_re: Pattern = ...
+validate_unicode_slug: RegexValidator = ...
+
+def validate_ipv4_address(value: str) -> None: ...
+def validate_ipv6_address(value: str) -> None: ...
+def validate_ipv46_address(value: str) -> None: ...
+
+_IPValidator = Tuple[Callable[[Any], None], str]
+ip_address_validator_map: Dict[str, _IPValidator]
+
+def ip_address_validators(protocol: str, unpack_ipv4: bool) -> _IPValidator: ...
+def int_list_validator(
+    sep: str = ..., message: Optional[_ErrorMessage] = ..., code: str = ..., allow_negative: bool = ...
+) -> RegexValidator: ...
+
+validate_comma_separated_integer_list: Any
+
+class BaseValidator:
+    message: str = ...
+    code: str = ...
+    limit_value: Any = ...
+    def __init__(self, limit_value: Any, message: Optional[_ErrorMessage] = ...) -> None: ...
+    def __call__(self, value: Any) -> None: ...
+    def compare(self, a: Any, b: Any) -> bool: ...
+    def clean(self, x: Any) -> Any: ...
+
+class MaxValueValidator(BaseValidator): ...
+class MinValueValidator(BaseValidator): ...
+class MinLengthValidator(BaseValidator): ...
+class MaxLengthValidator(BaseValidator): ...
+
+class DecimalValidator:
+    messages: Dict[str, str] = ...
+    max_digits: int = ...
+    decimal_places: int = ...
+    def __init__(self, max_digits: Optional[Union[int, str]], decimal_places: Optional[Union[int, str]]) -> None: ...
+    def __call__(self, value: Decimal) -> None: ...
+
+class FileExtensionValidator:
+    message: str = ...
+    code: str = ...
+    allowed_extensions: List[str] = ...
+    def __init__(
+        self,
+        allowed_extensions: Optional[Collection[str]] = ...,
+        message: Optional[_ErrorMessage] = ...,
+        code: Optional[str] = ...,
+    ) -> None: ...
+    def __call__(self, value: File) -> None: ...
+
+def get_available_image_extensions() -> List[str]: ...
+def validate_image_file_extension(value: File) -> None: ...
+
+class ProhibitNullCharactersValidator:
+    message: str = ...
+    code: str = ...
+    def __init__(self, message: Optional[_ErrorMessage] = ..., code: Optional[str] = ...) -> None: ...
+    def __call__(self, value: Any) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/core/wsgi.pyi

@@ -0,0 +1,3 @@
+from django.core.handlers.wsgi import WSGIHandler
+
+def get_wsgi_application() -> WSGIHandler: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/migrations/autodetector.pyi

@@ -0,0 +1,67 @@
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+from django.db.migrations.graph import MigrationGraph
+from django.db.migrations.migration import Migration
+from django.db.migrations.operations.base import Operation
+from django.db.migrations.questioner import MigrationQuestioner
+from django.db.migrations.state import ProjectState
+from django.db.models.fields import Field
+
+class MigrationAutodetector:
+    from_state: ProjectState = ...
+    to_state: ProjectState = ...
+    questioner: MigrationQuestioner = ...
+    existing_apps: Set[Any] = ...
+    def __init__(
+        self, from_state: ProjectState, to_state: ProjectState, questioner: Optional[MigrationQuestioner] = ...
+    ) -> None: ...
+    def changes(
+        self,
+        graph: MigrationGraph,
+        trim_to_apps: Optional[Set[str]] = ...,
+        convert_apps: Optional[Set[str]] = ...,
+        migration_name: Optional[str] = ...,
+    ) -> Dict[str, List[Migration]]: ...
+    def deep_deconstruct(self, obj: Any) -> Any: ...
+    def only_relation_agnostic_fields(
+        self, fields: List[Tuple[str, Field]]
+    ) -> List[Tuple[str, List[Any], Dict[str, Union[Callable, int, str]]]]: ...
+    def check_dependency(
+        self, operation: Operation, dependency: Tuple[str, str, Optional[str], Union[bool, str]]
+    ) -> bool: ...
+    def add_operation(
+        self,
+        app_label: str,
+        operation: Operation,
+        dependencies: Optional[List[Tuple[str, str, Optional[str], Union[bool, str]]]] = ...,
+        beginning: bool = ...,
+    ) -> None: ...
+    def swappable_first_key(self, item: Tuple[str, str]) -> Tuple[str, str]: ...
+    renamed_models: Any = ...
+    renamed_models_rel: Any = ...
+    def generate_renamed_models(self) -> None: ...
+    def generate_created_models(self) -> None: ...
+    def generate_created_proxies(self) -> None: ...
+    def generate_deleted_models(self) -> None: ...
+    def generate_deleted_proxies(self) -> None: ...
+    renamed_fields: Any = ...
+    def generate_renamed_fields(self) -> None: ...
+    def generate_added_fields(self) -> None: ...
+    def generate_removed_fields(self) -> None: ...
+    def generate_altered_fields(self) -> None: ...
+    def create_altered_indexes(self) -> None: ...
+    def generate_added_indexes(self) -> None: ...
+    def generate_removed_indexes(self) -> None: ...
+    def generate_altered_unique_together(self) -> None: ...
+    def generate_altered_index_together(self) -> None: ...
+    def generate_altered_db_table(self) -> None: ...
+    def generate_altered_options(self) -> None: ...
+    def generate_altered_order_with_respect_to(self) -> None: ...
+    def generate_altered_managers(self) -> None: ...
+    def arrange_for_graph(
+        self, changes: Dict[str, List[Migration]], graph: MigrationGraph, migration_name: Optional[str] = ...
+    ) -> Dict[str, List[Migration]]: ...
+    @classmethod
+    def suggest_name(cls, ops: List[Operation]) -> str: ...
+    @classmethod
+    def parse_number(cls, name: str) -> int: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/base.pyi

@@ -0,0 +1,17 @@
+from typing import Any, List
+
+class Operation:
+    reversible: bool = ...
+    reduces_to_sql: bool = ...
+    atomic: bool = ...
+    elidable: bool = ...
+    serialization_expand_args: Any = ...
+    def deconstruct(self): ...
+    def state_forwards(self, app_label: Any, state: Any) -> None: ...
+    def database_forwards(self, app_label: Any, schema_editor: Any, from_state: Any, to_state: Any) -> None: ...
+    def database_backwards(self, app_label: Any, schema_editor: Any, from_state: Any, to_state: Any) -> None: ...
+    def describe(self): ...
+    def references_model(self, name: str, app_label: str = ...) -> bool: ...
+    def references_field(self, model_name: str, name: str, app_label: str = ...) -> bool: ...
+    def allow_migrate_model(self, connection_alias: Any, model: Any): ...
+    def reduce(self, operation: Operation, in_between: List[Operation], app_label: str = ...) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/models.pyi

@@ -0,0 +1,87 @@
+from typing import Any, Collection, Dict, List, Optional, Sequence, Tuple, Union
+
+from django.db.migrations.operations.base import Operation
+from django.db.models.indexes import Index
+from django.db.models.manager import Manager
+
+from django.db.models.constraints import BaseConstraint
+from django.db.models.fields import Field
+
+class ModelOperation(Operation):
+    name: str = ...
+    def __init__(self, name: str) -> None: ...
+    def name_lower(self) -> str: ...
+
+class CreateModel(ModelOperation):
+    fields: Sequence[Tuple[str, Field]] = ...
+    options: Any = ...
+    bases: Optional[Sequence[Union[type, str]]] = ...
+    managers: Optional[Sequence[Tuple[str, Manager]]] = ...
+    def __init__(
+        self,
+        name: str,
+        fields: Sequence[Tuple[str, Field]],
+        options: Optional[Dict[str, Any]] = ...,
+        bases: Optional[Sequence[Union[type, str]]] = ...,
+        managers: Optional[Sequence[Tuple[str, Manager]]] = ...,
+    ) -> None: ...
+    def model_to_key(self, model: str) -> List[str]: ...
+
+class DeleteModel(ModelOperation): ...
+
+class RenameModel(ModelOperation):
+    old_name: Any = ...
+    new_name: Any = ...
+    def __init__(self, old_name: str, new_name: str) -> None: ...
+    def old_name_lower(self) -> str: ...
+    def new_name_lower(self) -> str: ...
+
+class AlterModelTable(ModelOperation):
+    table: Optional[str] = ...
+    def __init__(self, name: str, table: Optional[str]) -> None: ...
+
+class ModelOptionOperation(ModelOperation): ...
+class FieldRelatedOptionOperation(ModelOptionOperation): ...
+
+class AlterUniqueTogether(FieldRelatedOptionOperation):
+    option_name: str = ...
+    unique_together: Collection[Sequence[str]] = ...
+    def __init__(self, name: str, unique_together: Optional[Collection[Sequence[str]]]) -> None: ...
+
+class AlterIndexTogether(FieldRelatedOptionOperation):
+    option_name: str = ...
+    index_together: Collection[Sequence[str]] = ...
+    def __init__(self, name: str, index_together: Optional[Collection[Sequence[str]]]) -> None: ...
+
+class AlterOrderWithRespectTo(FieldRelatedOptionOperation):
+    order_with_respect_to: str = ...
+    def __init__(self, name: str, order_with_respect_to: str) -> None: ...
+
+class AlterModelOptions(ModelOptionOperation):
+    ALTER_OPTION_KEYS: Any = ...
+    options: Dict[str, str] = ...
+    def __init__(self, name: str, options: Dict[str, Any]) -> None: ...
+
+class AlterModelManagers(ModelOptionOperation):
+    managers: Any = ...
+    def __init__(self, name: Any, managers: Any) -> None: ...
+
+class IndexOperation(Operation):
+    option_name: str = ...
+    def model_name_lower(self): ...
+
+class AddIndex(IndexOperation):
+    model_name: str = ...
+    index: Index = ...
+    def __init__(self, model_name: str, index: Union[str, Index]) -> None: ...
+
+class RemoveIndex(IndexOperation):
+    model_name: str = ...
+    name: str = ...
+    def __init__(self, model_name: str, name: Union[str, Index]) -> None: ...
+
+class AddConstraint(IndexOperation):
+    def __init__(self, model_name: str, constraint: BaseConstraint): ...
+
+class RemoveConstraint(IndexOperation):
+    def __init__(self, model_name: str, name: str) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/migrations/utils.pyi

@@ -0,0 +1,10 @@
+from typing import Any
+
+COMPILED_REGEX_TYPE: Any
+
+class RegexObject:
+    pattern: str = ...
+    flags: int = ...
+    def __init__(self, obj: Any) -> None: ...
+
+def get_migration_name_timestamp() -> str: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/migrations/writer.pyi

@@ -0,0 +1,40 @@
+from typing import Any, List, Set, Tuple, Union, Type
+
+from django.db.migrations.migration import Migration
+from django.db.migrations.operations.base import Operation
+from django.db.migrations.operations.models import CreateModel
+from django.db.migrations.serializer import BaseSerializer
+
+class SettingsReference(str):
+    def __init__(self, value: str, setting_name: str) -> None: ...
+
+class OperationWriter:
+    operation: CreateModel = ...
+    buff: List[Any] = ...
+    indentation: int = ...
+    def __init__(self, operation: Operation, indentation: int = ...) -> None: ...
+    def serialize(self) -> Tuple[str, Set[str]]: ...
+    def indent(self) -> None: ...
+    def unindent(self) -> None: ...
+    def feed(self, line: str) -> None: ...
+    def render(self) -> str: ...
+
+class MigrationWriter:
+    migration: Migration = ...
+    needs_manual_porting: bool = ...
+    def __init__(self, migration: Union[type, Migration], include_header: bool = ...) -> None: ...
+    def as_string(self) -> str: ...
+    @property
+    def basedir(self) -> str: ...
+    @property
+    def filename(self) -> str: ...
+    @property
+    def path(self) -> str: ...
+    @classmethod
+    def serialize(cls, value: Any) -> Tuple[str, Set[str]]: ...
+    @classmethod
+    def register_serializer(cls, type_: type, serializer: Type[BaseSerializer]) -> None: ...
+    @classmethod
+    def unregister_serializer(cls, type_: type) -> None: ...
+
+MIGRATION_TEMPLATE: str

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/fields/related_lookups.pyi

@@ -0,0 +1,48 @@
+from collections import OrderedDict
+from typing import Any, List, Tuple, Type, Iterable
+
+from django.db.models.expressions import Expression
+from django.db.models.lookups import (
+    BuiltinLookup,
+    Exact,
+    GreaterThan,
+    GreaterThanOrEqual,
+    In,
+    IsNull,
+    LessThan,
+    LessThanOrEqual,
+)
+
+from django.db.models.fields import Field
+
+class MultiColSource:
+    alias: str
+    field: Field
+    sources: Tuple[Field, Field]
+    targets: Tuple[Field, Field]
+    contains_aggregate: bool = ...
+    output_field: Field = ...
+    def __init__(
+        self, alias: str, targets: Tuple[Field, Field], sources: Tuple[Field, Field], field: Field
+    ) -> None: ...
+    def relabeled_clone(self, relabels: OrderedDict) -> MultiColSource: ...
+    def get_lookup(self, lookup: str) -> Type[BuiltinLookup]: ...
+
+def get_normalized_value(value: Any, lhs: Expression) -> Tuple[None]: ...
+
+class RelatedIn(In):
+    bilateral_transforms: List[Any]
+    lhs: Expression
+    rhs: Any = ...
+    def get_prep_lookup(self) -> Iterable[Any]: ...
+
+class RelatedLookupMixin:
+    rhs: Any = ...
+    def get_prep_lookup(self) -> Any: ...
+
+class RelatedExact(RelatedLookupMixin, Exact): ...
+class RelatedLessThan(RelatedLookupMixin, LessThan): ...
+class RelatedGreaterThan(RelatedLookupMixin, GreaterThan): ...
+class RelatedGreaterThanOrEqual(RelatedLookupMixin, GreaterThanOrEqual): ...
+class RelatedLessThanOrEqual(RelatedLookupMixin, LessThanOrEqual): ...
+class RelatedIsNull(RelatedLookupMixin, IsNull): ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/fields/reverse_related.pyi

@@ -0,0 +1,110 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+
+from django.db.models.base import Model
+from django.db.models.fields.related import ForeignKey, OneToOneField, RelatedField
+from django.db.models.lookups import BuiltinLookup, StartsWith
+from django.db.models.query_utils import FilteredRelation, PathInfo
+from django.db.models.sql.where import WhereNode
+
+from django.db.models.fields import AutoField, Field
+from .mixins import FieldCacheMixin
+
+class ForeignObjectRel(FieldCacheMixin):
+    many_to_many: bool
+    many_to_one: bool
+    one_to_many: bool
+    one_to_one: bool
+    auto_created: bool = ...
+    concrete: bool = ...
+    editable: bool = ...
+    is_relation: bool = ...
+    related_model: Type[Model]
+    null: bool = ...
+    field: RelatedField = ...
+    model: Union[Type[Model], str] = ...
+    related_name: Optional[str] = ...
+    related_query_name: Optional[str] = ...
+    limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ...
+    parent_link: bool = ...
+    on_delete: Callable = ...
+    symmetrical: bool = ...
+    multiple: bool = ...
+    field_name: Optional[str] = ...
+    def __init__(
+        self,
+        field: RelatedField,
+        to: Union[Type[Model], str],
+        related_name: Optional[str] = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ...,
+        parent_link: bool = ...,
+        on_delete: Optional[Callable] = ...,
+    ) -> None: ...
+    @property
+    def hidden(self) -> bool: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def remote_field(self) -> RelatedField: ...
+    @property
+    def target_field(self) -> AutoField: ...
+    def get_lookup(self, lookup_name: str) -> Type[BuiltinLookup]: ...
+    def get_internal_type(self) -> str: ...
+    @property
+    def db_type(self) -> Callable: ...
+    def get_choices(
+        self, include_blank: bool = ..., blank_choice: List[Tuple[str, str]] = ...
+    ) -> List[Tuple[int, str]]: ...
+    def is_hidden(self) -> bool: ...
+    def get_joining_columns(self) -> Tuple: ...
+    def get_extra_restriction(
+        self, where_class: Type[WhereNode], alias: str, related_alias: str
+    ) -> Optional[Union[StartsWith, WhereNode]]: ...
+    def set_field_name(self) -> None: ...
+    def get_accessor_name(self, model: Optional[Type[Model]] = ...) -> Optional[str]: ...
+    def get_path_info(self, filtered_relation: Optional[FilteredRelation] = ...) -> List[PathInfo]: ...
+
+class ManyToOneRel(ForeignObjectRel):
+    def __init__(
+        self,
+        field: ForeignKey,
+        to: Union[Type[Model], str],
+        field_name: Optional[str],
+        related_name: Optional[str] = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ...,
+        parent_link: bool = ...,
+        on_delete: Callable = ...,
+    ) -> None: ...
+    def get_related_field(self) -> Field: ...
+
+class OneToOneRel(ManyToOneRel):
+    def __init__(
+        self,
+        field: OneToOneField,
+        to: Union[Type[Model], str],
+        field_name: Optional[str],
+        related_name: Optional[str] = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Optional[Dict[str, str]] = ...,
+        parent_link: bool = ...,
+        on_delete: Callable = ...,
+    ) -> None: ...
+
+class ManyToManyRel(ForeignObjectRel):
+    through: Optional[Union[Type[Model], str]] = ...
+    through_fields: Optional[Tuple[str, str]] = ...
+    db_constraint: bool = ...
+    def __init__(
+        self,
+        field: RelatedField,
+        to: Union[Type[Model], str],
+        related_name: Optional[str] = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Any = ...,
+        symmetrical: bool = ...,
+        through: Optional[Union[Type[Model], str]] = ...,
+        through_fields: Optional[Tuple[str, str]] = ...,
+        db_constraint: bool = ...,
+    ) -> None: ...
+    def get_related_field(self) -> Field: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/sql/__init__.pyi

@@ -0,0 +1,8 @@
+from .query import Query as Query, RawQuery as RawQuery
+
+from .subqueries import (
+    InsertQuery as InsertQuery,
+    AggregateQuery as AggregateQuery,
+    DeleteQuery as DeleteQuery,
+    UpdateQuery as UpdateQuery,
+)

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/sql/constants.pyi

@@ -0,0 +1,14 @@
+from typing import Dict, Pattern, Tuple
+
+GET_ITERATOR_CHUNK_SIZE: int = ...
+
+MULTI: str = ...
+SINGLE: str = ...
+CURSOR: str = ...
+NO_RESULTS: str = ...
+
+ORDER_PATTERN: Pattern = ...
+ORDER_DIR: Dict[str, Tuple[str, str]] = ...
+
+INNER: str = ...
+LOUTER: str = ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/sql/datastructures.pyi

@@ -0,0 +1,49 @@
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from django.db.models.fields.mixins import FieldCacheMixin
+from django.db.models.query_utils import FilteredRelation, PathInfo
+from django.db.models.sql.compiler import SQLCompiler
+
+class MultiJoin(Exception):
+    level: int = ...
+    names_with_path: List[Tuple[str, List[PathInfo]]] = ...
+    def __init__(self, names_pos: int, path_with_names: List[Tuple[str, List[PathInfo]]]) -> None: ...
+
+class Empty: ...
+
+class Join:
+    table_name: str = ...
+    parent_alias: str = ...
+    table_alias: Optional[str] = ...
+    join_type: str = ...
+    join_cols: Tuple = ...
+    join_field: FieldCacheMixin = ...
+    nullable: bool = ...
+    filtered_relation: Optional[FilteredRelation] = ...
+    def __init__(
+        self,
+        table_name: str,
+        parent_alias: str,
+        table_alias: Optional[str],
+        join_type: str,
+        join_field: FieldCacheMixin,
+        nullable: bool,
+        filtered_relation: Optional[FilteredRelation] = ...,
+    ) -> None: ...
+    def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, List[Union[int, str]]]: ...
+    def relabeled_clone(self, change_map: Union[Dict[str, str], OrderedDict]) -> Join: ...
+    def equals(self, other: Union[BaseTable, Join], with_filtered_relation: bool) -> bool: ...
+    def demote(self) -> Join: ...
+    def promote(self) -> Join: ...
+
+class BaseTable:
+    join_type: Any = ...
+    parent_alias: Any = ...
+    filtered_relation: Any = ...
+    table_name: str = ...
+    table_alias: Optional[str] = ...
+    def __init__(self, table_name: str, alias: Optional[str]) -> None: ...
+    def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, List[Any]]: ...
+    def relabeled_clone(self, change_map: OrderedDict) -> BaseTable: ...
+    def equals(self, other: Join, with_filtered_relation: bool) -> bool: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/sql/subqueries.pyi

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Type, Union
+
+from django.db.models.base import Model
+from django.db.models.expressions import Case
+from django.db.models.query import QuerySet
+from django.db.models.sql.query import Query
+from django.db.models.sql.where import WhereNode
+
+from django.db.models.fields import Field
+
+class DeleteQuery(Query):
+    select: Tuple
+    where_class: Type[WhereNode]
+    where: WhereNode = ...
+    def do_query(self, table: str, where: WhereNode, using: str) -> int: ...
+    def delete_batch(self, pk_list: Union[List[int], List[str]], using: str) -> int: ...
+    def delete_qs(self, query: QuerySet, using: str) -> int: ...
+
+class UpdateQuery(Query):
+    select: Tuple
+    where_class: Type[WhereNode]
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    where: WhereNode = ...
+    def update_batch(self, pk_list: List[int], values: Dict[str, Optional[int]], using: str) -> None: ...
+    def add_update_values(self, values: Dict[str, Any]) -> None: ...
+    def add_update_fields(self, values_seq: List[Tuple[Field, Optional[Type[Model]], Case]]) -> None: ...
+    def add_related_update(self, model: Type[Model], field: Field, value: Union[int, str]) -> None: ...
+    def get_related_updates(self) -> List[UpdateQuery]: ...
+
+class InsertQuery(Query):
+    select: Tuple
+    where: WhereNode
+    where_class: Type[WhereNode]
+    fields: Iterable[Field] = ...
+    objs: List[Model] = ...
+    raw: bool = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def insert_values(self, fields: Iterable[Field], objs: List[Model], raw: bool = ...) -> None: ...
+
+class AggregateQuery(Query):
+    select: Tuple
+    sub_params: Tuple
+    where: WhereNode
+    where_class: Type[WhereNode]
+    def add_subquery(self, query: Query, using: str) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/jedi/third_party/django-stubs/django-stubs/db/models/sql/where.pyi

@@ -0,0 +1,46 @@
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from django.db.models.expressions import Expression
+from django.db.models.sql.compiler import SQLCompiler
+from django.db.models.sql.query import Query
+from django.utils import tree
+
+AND: str
+OR: str
+
+class WhereNode(tree.Node):
+    connector: str
+    contains_aggregate: bool
+    contains_over_clause: bool
+    negated: bool
+    default: Any = ...
+    resolved: bool = ...
+    conditional: bool = ...
+    def split_having(self, negated: bool = ...) -> Tuple[Optional[WhereNode], Optional[WhereNode]]: ...
+    def as_sql(self, compiler: SQLCompiler, connection: Any) -> Any: ...
+    def get_group_by_cols(self) -> List[Expression]: ...
+    def relabel_aliases(self, change_map: Union[Dict[Optional[str], str], OrderedDict]) -> None: ...
+    def clone(self) -> WhereNode: ...
+    def relabeled_clone(self, change_map: Union[Dict[Optional[str], str], OrderedDict]) -> WhereNode: ...
+    def resolve_expression(self, *args: Any, **kwargs: Any) -> WhereNode: ...
+
+class NothingNode:
+    contains_aggregate: bool = ...
+    def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Any: ...
+
+class ExtraWhere:
+    contains_aggregate: bool = ...
+    sqls: List[str] = ...
+    params: Optional[Union[List[int], List[str]]] = ...
+    def __init__(self, sqls: List[str], params: Optional[Union[List[int], List[str]]]) -> None: ...
+    def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Tuple[str, Union[List[int], List[str]]]: ...
+
+class SubqueryConstraint:
+    contains_aggregate: bool = ...
+    alias: str = ...
+    columns: List[str] = ...
+    targets: List[str] = ...
+    query_object: Query = ...
+    def __init__(self, alias: str, columns: List[str], targets: List[str], query_object: Query) -> None: ...
+    def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, Tuple]: ...

moondream/lib/python3.10/site-packages/sympy/core/__pycache__/numbers.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:664d8fdbb3bf4a5cd7cc0392aa3f4820db05b7d0f40376589a0fe53c5c6a4b46
+size 118094

moondream/lib/python3.10/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:256cd4bffb598483da5a6dc2b2e889b8cecefcde8623a4986d929a516b9bba80
+size 132096

moondream/lib/python3.10/site-packages/torch/include/ATen/Dimname.h

@@ -0,0 +1 @@
+#include <ATen/core/Dimname.h>

moondream/lib/python3.10/site-packages/torch/include/ATen/Tensor.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <ATen/core/Tensor.h>

moondream/lib/python3.10/site-packages/torch/include/ATen/TensorUtils.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <ATen/DimVector.h>
+#include <ATen/EmptyTensor.h>
+#include <ATen/Tensor.h>
+#include <ATen/TensorGeometry.h>
+#include <ATen/Utils.h>
+
+#include <utility>
+
+// These functions are NOT in Utils.h, because this file has a dep on Tensor.h
+
+#define TORCH_CHECK_TENSOR_ALL(cond, ...) \
+  TORCH_CHECK((cond)._is_all_true().item<bool>(), __VA_ARGS__);
+
+namespace at {
+
+// The following are utility functions for checking that arguments
+// make sense.  These are particularly useful for native functions,
+// which do NO argument checking by default.
+
+struct TORCH_API TensorArg {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
+  const Tensor& tensor;
+  const char* name;
+  int pos; // 1-indexed
+  TensorArg(const Tensor& tensor, const char* name, int pos)
+      : tensor(tensor), name(name), pos(pos) {}
+  // Try to mitigate any possibility of dangling reference to temporaries.
+  // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+  TensorArg(Tensor&& tensor, const char* name, int pos) = delete;
+  const Tensor* operator->() const {
+    return &tensor;
+  }
+  const Tensor& operator*() const {
+    return tensor;
+  }
+};
+
+struct TORCH_API TensorGeometryArg {
+  TensorGeometry tensor;
+  const char* name;
+  int pos; // 1-indexed
+  /* implicit */ TensorGeometryArg(TensorArg arg)
+      : tensor(TensorGeometry{arg.tensor}), name(arg.name), pos(arg.pos) {}
+  TensorGeometryArg(TensorGeometry tensor, const char* name, int pos)
+      : tensor(std::move(tensor)), name(name), pos(pos) {}
+  const TensorGeometry* operator->() const {
+    return &tensor;
+  }
+  const TensorGeometry& operator*() const {
+    return tensor;
+  }
+};
+
+// A string describing which function did checks on its input
+// arguments.
+// TODO: Consider generalizing this into a call stack.
+using CheckedFrom = const char*;
+
+// The undefined convention: singular operators assume their arguments
+// are defined, but functions which take multiple tensors will
+// implicitly filter out undefined tensors (to make it easier to perform
+// tests which should apply if the tensor is defined, and should not
+// otherwise.)
+//
+// NB: This means that the n-ary operators take lists of TensorArg,
+// not TensorGeometryArg, because the Tensor to TensorGeometry
+// conversion will blow up if you have undefined tensors.
+
+TORCH_API std::ostream& operator<<(
+    std::ostream& out,
+    const TensorGeometryArg& t);
+TORCH_API void checkDim(
+    CheckedFrom c,
+    const Tensor& tensor,
+    const char* name,
+    int pos, // 1-indexed
+    int64_t dim);
+TORCH_API void checkDim(CheckedFrom c, const TensorGeometryArg& t, int64_t dim);
+// NB: this is an inclusive-exclusive range
+TORCH_API void checkDimRange(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim_start,
+    int64_t dim_end);
+TORCH_API void checkSameDim(
+    CheckedFrom c,
+    const TensorGeometryArg& t1,
+    const TensorGeometryArg& t2);
+TORCH_API void checkContiguous(CheckedFrom c, const TensorGeometryArg& t);
+TORCH_API void checkAllContiguous(CheckedFrom c, at::ArrayRef<TensorArg> ts);
+TORCH_API void checkSize(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    IntArrayRef sizes);
+TORCH_API void checkSize_symint(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    c10::SymIntArrayRef sizes);
+TORCH_API void checkSize(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim,
+    int64_t size);
+TORCH_API void checkSize_symint(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim,
+    const c10::SymInt& size);
+TORCH_API void checkNumel(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t numel);
+TORCH_API void checkSameNumel(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+TORCH_API void checkAllSameNumel(CheckedFrom c, ArrayRef<TensorArg> tensors);
+TORCH_API void checkScalarType(CheckedFrom c, const TensorArg& t, ScalarType s);
+TORCH_API void checkScalarTypes(
+    CheckedFrom c,
+    const TensorArg& t,
+    at::ArrayRef<ScalarType> l);
+TORCH_API void checkSameGPU(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+TORCH_API void checkAllSameGPU(CheckedFrom c, ArrayRef<TensorArg> tensors);
+TORCH_API void checkSameType(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+TORCH_API void checkAllSameType(CheckedFrom c, ArrayRef<TensorArg> tensors);
+TORCH_API void checkSameSize(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+TORCH_API void checkAllSameSize(CheckedFrom c, ArrayRef<TensorArg> tensors);
+TORCH_API void checkDefined(CheckedFrom c, const TensorArg& t);
+TORCH_API void checkAllDefined(CheckedFrom c, at::ArrayRef<TensorArg> t);
+
+// FixMe: does TensorArg slow things down?
+TORCH_API void checkBackend(
+    CheckedFrom c,
+    at::ArrayRef<Tensor> t,
+    at::Backend backend);
+
+TORCH_API void checkDeviceType(
+    CheckedFrom c,
+    at::ArrayRef<Tensor> tensors,
+    at::DeviceType device_type);
+
+TORCH_API void checkLayout(CheckedFrom c, const Tensor& t, Layout layout);
+
+TORCH_API void checkLayout(
+    CheckedFrom c,
+    at::ArrayRef<Tensor> tensors,
+    at::Layout layout);
+
+// Methods for getting data_ptr if tensor is defined
+TORCH_API void* maybe_data_ptr(const Tensor& tensor);
+TORCH_API void* maybe_data_ptr(const TensorArg& tensor);
+
+TORCH_API void check_dim_size(
+    const Tensor& tensor,
+    int64_t dim,
+    int64_t dim_size,
+    int64_t size);
+
+namespace detail {
+TORCH_API std::vector<int64_t> defaultStrides(IntArrayRef sizes);
+
+TORCH_API c10::optional<std::vector<int64_t>> computeStride(
+    IntArrayRef oldshape,
+    IntArrayRef oldstride,
+    IntArrayRef newshape);
+
+TORCH_API c10::optional<SymDimVector> computeStride(
+    c10::SymIntArrayRef oldshape,
+    c10::SymIntArrayRef oldstride,
+    c10::SymIntArrayRef newshape);
+
+TORCH_API c10::optional<DimVector> computeStride(
+    IntArrayRef oldshape,
+    IntArrayRef oldstride,
+    const DimVector& newshape);
+
+} // namespace detail
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/core/Dict_inl.h

@@ -0,0 +1,209 @@
+#pragma once
+
+#include <ATen/core/ivalue.h>
+#include <c10/util/hash.h>
+
+namespace c10 {
+namespace detail {
+inline bool DictKeyEqualTo::operator()(const IValue& lhs, const IValue& rhs) const {
+  if (lhs.isTensor() && rhs.isTensor()) {
+    // for tensors, we compare only by identity (following how it's done in Python).
+    return lhs.is(rhs);
+  }
+  // Otherwise, we first compare by identity for efficiency, then by value (see:
+  // [container equality])
+  return _fastEqualsForContainer(lhs, rhs);
+}
+}
+
+template<class T> decltype(auto) getTypePtr();
+std::string toString(const Type& type);
+
+namespace impl {
+
+template<class Key, class Value>
+Dict<Key, Value> toTypedDict(GenericDict dict) {
+  TORCH_INTERNAL_ASSERT(*getTypePtr<Key>() == *dict.impl_->elementTypes.keyType, "Tried to cast a Dict<", toString(*dict.impl_->elementTypes.keyType), ", ", toString(*dict.impl_->elementTypes.valueType) ,"> to a Dict<", toString(*getTypePtr<Key>()), ", ", toString(*getTypePtr<Value>()), ">. Key types mismatch.");
+  TORCH_INTERNAL_ASSERT(*getTypePtr<Value>() == *dict.impl_->elementTypes.valueType, "Tried to cast a Dict<", toString(*dict.impl_->elementTypes.keyType), ", ", toString(*dict.impl_->elementTypes.valueType) ,"> to a Dict<", toString(*getTypePtr<Key>()), ", ", toString(*getTypePtr<Value>()), ">. Value types mismatch.");
+
+  return Dict<Key, Value>(std::move(dict.impl_));
+}
+
+template<class Key, class Value>
+GenericDict toGenericDict(Dict<Key, Value> dict) {
+  return GenericDict(std::move(dict.impl_));
+}
+}
+
+namespace detail {
+
+inline size_t DictKeyHash::operator()(const IValue& ivalue) const {
+  if (ivalue.isInt()) {
+    return std::hash<int64_t>()(ivalue.toInt());
+  } else if (ivalue.isString()) {
+    return std::hash<c10::string_view>()(ivalue.toStringView());
+  } else if (ivalue.isDouble()) {
+    return std::hash<double>()(ivalue.toDouble());
+  } else if (ivalue.isComplexDouble()) {
+    return c10::hash<c10::complex<double>>()(ivalue.toComplexDouble());
+  } else if (ivalue.isBool()) {
+    return std::hash<bool>()(ivalue.toBool());
+  } else if (ivalue.isTensor()) {
+    return std::hash<TensorImpl*>()(ivalue.toTensor().unsafeGetTensorImpl());
+  } else if (ivalue.isDevice()) {
+    return std::hash<Device>()(ivalue.toDevice());
+  } else {
+    throw std::runtime_error(
+        "Can't hash IValues with tag '" + ivalue.tagKind() + "'");
+  }
+}
+
+inline intrusive_ptr<DictImpl> DictImpl::copy() const {
+  return make_intrusive<DictImpl>(dict, elementTypes);
+}
+
+}
+
+template<class Key, class Value>
+Dict<Key, Value>::Dict()
+  :Dict(make_intrusive<detail::DictImpl>(
+      detail::DictImpl::dict_map_type(),
+      detail::DictImpl::DictElementTypes{getTypePtr<Key>(), getTypePtr<Value>()})) {
+  static_assert(!std::is_same<Key, IValue>::value, "This constructor is not valid for Dict<IValue, _>. Please use c10::impl::GenericDict(keyType, valueType) instead.");
+  static_assert(!std::is_same<Value, IValue>::value, "This constructor is not valid for Dict<_, IValue>. Please use c10::impl::GenericDict(keyType, valueType) instead.");
+}
+
+template<class Key, class Value>
+Dict<Key, Value>::Dict(TypePtr keyType, TypePtr valueType)
+: Dict(make_intrusive<detail::DictImpl>(
+    detail::DictImpl::dict_map_type(),
+    detail::DictImpl::DictElementTypes {std::move(keyType), std::move(valueType)})) {
+  static_assert(std::is_same<Key, IValue>::value, "This constructor is only valid for c10::impl::GenericDict.");
+  static_assert(std::is_same<Value, IValue>::value, "This constructor is only valid for c10::impl::GenericDict.");
+}
+
+template<class Key, class Value>
+Dict<Key, Value>::Dict(c10::intrusive_ptr<detail::DictImpl>&& impl): impl_(std::move(impl)) {}
+
+template<class Key, class Value>
+Dict<Key, Value> Dict<Key, Value>::copy() const {
+  return Dict<Key, Value>(impl_->copy());
+}
+
+template<class Key, class Value>
+typename Dict<Key, Value>::iterator Dict<Key, Value>::begin() const {
+  return iterator{impl_->dict.begin()};
+}
+
+template<class Key, class Value>
+typename Dict<Key, Value>::iterator Dict<Key, Value>::end() const {
+  return iterator{impl_->dict.end()};
+}
+
+template<class Key, class Value>
+bool Dict<Key, Value>::empty() const {
+  return impl_->dict.empty();
+}
+
+template<class Key, class Value>
+typename Dict<Key, Value>::size_type Dict<Key, Value>::size() const {
+  return impl_->dict.size();
+}
+
+template<class Key, class Value>
+void Dict<Key, Value>::clear() const {
+  impl_->dict.clear();
+}
+
+template<class Key, class Value>
+template<class Key_, class Value_>
+std::pair<typename Dict<Key, Value>::iterator, bool> Dict<Key, Value>::insert(Key_&& key, Value_&& value) const {
+  static_assert(std::is_constructible<Key, Key_>::value, "Wrong type for the key argument of Dict::insert");
+  static_assert(std::is_constructible<Value, Value_>::value, "Wrong type for the value argument of Dict::insert");
+  auto inserted = impl_->dict.emplace(
+      Key(std::forward<Key_>(key)),
+      Value(std::forward<Value_>(value)));
+  return {iterator{inserted.first}, inserted.second};
+}
+
+template<class Key, class Value>
+template<class Key_, class Value_>
+std::pair<typename Dict<Key, Value>::iterator, bool> Dict<Key, Value>::insert_or_assign(Key_&& key, Value_&& value) const {
+  static_assert(std::is_constructible<Key, Key_>::value, "Wrong type for the key argument of Dict::insert_or_assign");
+  static_assert(std::is_constructible<Value, Value_>::value, "Wrong type for the value argument of Dict::insert_or_assign");
+  auto inserted = impl_->dict.insert_or_assign(
+    Key(std::forward<Key_>(key)),
+    Value(std::forward<Value_>(value)));
+  return {iterator{inserted.first}, inserted.second};
+}
+
+template<class Key, class Value>
+void Dict<Key, Value>::erase(iterator iter) const {
+  impl_->dict.erase(iter.entryRef_.iterator_);
+}
+
+template<class Key, class Value>
+C10_NODISCARD size_t Dict<Key, Value>::erase(const Key& key) const {
+  return impl_->dict.erase(key);
+}
+
+template<class Key, class Value>
+Value Dict<Key, Value>::at(const Key& key) const {
+  return impl_->dict.at(key).template to<Value>();
+}
+
+template<class Key, class Value>
+typename Dict<Key, Value>::iterator Dict<Key, Value>::find(const Key& key) const {
+  return iterator{impl_->dict.find(key)};
+}
+
+template<class Key, class Value>
+bool Dict<Key, Value>::contains(const Key& key) const {
+  return end() != find(key);
+}
+
+template<class Key, class Value>
+void Dict<Key, Value>::reserve(size_type count) const {
+  impl_->dict.reserve(count);
+}
+
+template<class Key, class Value>
+TypePtr Dict<Key, Value>::keyType() const {
+  return impl_->elementTypes.keyType;
+}
+
+template<class Key, class Value>
+TypePtr Dict<Key, Value>::valueType() const {
+  return impl_->elementTypes.valueType;
+}
+template <class Key, class Value>
+void Dict<Key, Value>::unsafeSetKeyType(TypePtr t) {
+  impl_->elementTypes.keyType = std::move(t);
+}
+
+template <class Key, class Value>
+void Dict<Key, Value>::unsafeSetValueType(TypePtr t) {
+  impl_->elementTypes.valueType = std::move(t);
+}
+
+template <class Key_, class Value_>
+bool operator==(const Dict<Key_, Value_>& lhs, const Dict<Key_, Value_>& rhs) {
+  // Dicts with the same identity trivially compare equal.
+  if (lhs.impl_ == rhs.impl_) {
+    return true;
+  }
+
+  // Otherwise compare the values
+  return *lhs.impl_ == *rhs.impl_;
+}
+
+template <class Key_, class Value_>
+bool operator!=(const Dict<Key_, Value_>& lhs, const Dict<Key_, Value_>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <class Key, class Value>
+bool Dict<Key, Value>::is(const Dict& rhs) const {
+  return this->impl_ == rhs.impl_;
+}
+}

moondream/lib/python3.10/site-packages/torch/include/ATen/core/NestedIntSymNodeImpl.h

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <c10/core/ConstantSymNodeImpl.h>
+#include <c10/core/SymNodeImpl.h>
+#include <c10/macros/Export.h>
+#include <c10/util/Exception.h>
+#include <c10/util/Optional.h>
+#include <c10/util/intrusive_ptr.h>
+#include <cstdint>
+#include <string>
+
+namespace c10 {
+
+// The motivating usecase for this is to represent the ragged size structure
+// of a jagged tensor [B, [s_0, s_1, s_2], D] as a single integer j0. This
+// allows us to simply return [B, j0, D] if someone queries for the size of our
+// tensor.
+//
+// Morally we define comparison between two nested ints to return true if
+// that comparison holds for all corresponding elements of the arrays they
+// represent. Comparison between a nested int and a plain int is defined
+// similarly.
+//
+// To simulate this desired behavior but also avoid the O(N) cost of checking,
+// we associate each raggedness pattern with an integer "id" that can be used as
+// a proxy to evaluate equality. We also constrain the range of values for this
+// as to enable inequality checks.
+//
+// We also support a positive integer scalar "coeff" that is used for computing
+// strides. For example given, a [B, j0, D] tensor, it can be strided in two
+// different ways: [D * j0, D, 1] and [j0, 1, sum(j0)]. The coeff is used to
+// differentiate the two cases.
+//
+// During tracing the strides of the outputs need to be a function of the size
+// and strides of the inputs so it is important that NestedIntSymNode itself is
+// able to express this.
+class TORCH_API NestedIntSymNodeImpl : public SymNodeImpl {
+ public:
+  // CAUTION: you should probably not be constructing these directly; please
+  // the higher-level API in python instead (TODO: actually introduce that).
+  explicit NestedIntSymNodeImpl(int64_t val, int64_t coeff)
+      : val_(val), coeff_(coeff) {}
+
+  bool bool_() override {
+    return false;
+  }
+
+  bool is_int() override {
+    return true;
+  }
+
+  bool is_float() override {
+    return false;
+  }
+
+  bool is_bool() override {
+    return false;
+  }
+
+  bool is_nested_int() const override {
+    return true;
+  }
+
+  bool has_hint() override {
+    return true;
+  }
+
+  c10::SymNode wrap_int(int64_t num) override {
+    return SymNode(c10::make_intrusive<ConstantSymNodeImpl<int64_t>>(num));
+  };
+
+  int64_t guard_int(const char* file, int64_t line) override {
+    TORCH_CHECK(false);
+  }
+
+  double guard_float(const char* file, int64_t line) override {
+    TORCH_CHECK(false, "not a float");
+  }
+
+  bool guard_bool(const char* file, int64_t line) override {
+    TORCH_CHECK(false, "not a bool");
+  }
+
+  int64_t int_() override {
+    TORCH_CHECK(false);
+  }
+
+  std::string str() override {
+    if (coeff_ == 1) {
+      return "j" + std::to_string(val_);
+    }
+    return std::to_string(coeff_) + "*j" + std::to_string(val_);
+  }
+
+  // NOTE [ Inequalities with nested int ]
+  //
+  // The semantics of nested int when it comes to relations is that it is
+  // treated as integer known to be within a certain range,
+  //
+  //     j0 \in [2, int64_t::max]
+  //
+  // allowing us to answer queries like j0 >= 1 (True), and j0 == 0 (False).
+  // This is a useful default range for the raggedness pattern of a jagged
+  // tensor (1) since sizes are non-negative, and (2) we need to get past 0/1
+  // specialization checks.
+  //
+  // [ Indeterminate inequalities error out ]
+  //
+  // Given the semantic defined above, certain relations like j0 < 3 are thus
+  // indeterminable. In our impl today, evaluating such relations error
+  //
+  // It may seem convenient to just define indeterminate relations to return
+  // False, but the implementation we maintain in parallel using sympy does not
+  // allow this.
+  //
+  // Sympy only allows overriding of Ge. The other relations (Lt, Gt, Le) are,
+  // by consequence, all derived from Ge e.g., Lt(a, b) := !Ge(a, b). This
+  // would mean that means that if we define the indeterminate j0 >= 3 to be
+  // False, the also indeterminate j0 < 3 will be evaluated to be True!
+  //
+  // [ Coefficient are assumed positive ]
+  //
+  // For the purpose of computing inequalities, we consider the coefficient of
+  // the nested int to be a positive integer.
+  //
+  // Thus, no modifications are needed to the logic since
+  // j0 >= k implies coeff * j0 >= k
+  //
+  c10::SymNode eq(const c10::SymNode& other) override;
+  c10::SymNode ne(const c10::SymNode& other) override;
+  c10::SymNode ge(const c10::SymNode& other) override;
+  c10::SymNode gt(const c10::SymNode& other) override;
+  c10::SymNode lt(const c10::SymNode& other) override;
+  c10::SymNode le(const c10::SymNode& other) override;
+  c10::SymNode mul(const c10::SymNode& other) override;
+
+  c10::optional<int64_t> nested_int() override {
+    return val_;
+  }
+
+  c10::optional<int64_t> nested_int_coeff() override {
+    return coeff_;
+  }
+
+  bool is_symbolic() override {
+    return false;
+  }
+
+#define DEFINE_BINARY_NOT_SUPPORTED(name)                           \
+  c10::SymNode name(const c10::SymNode& other) override {           \
+    TORCH_CHECK(false, #name " not supported by NestedIntSymNode"); \
+  }
+
+  DEFINE_BINARY_NOT_SUPPORTED(add)
+  DEFINE_BINARY_NOT_SUPPORTED(sub)
+  DEFINE_BINARY_NOT_SUPPORTED(truediv)
+  DEFINE_BINARY_NOT_SUPPORTED(pow)
+  DEFINE_BINARY_NOT_SUPPORTED(floordiv)
+  DEFINE_BINARY_NOT_SUPPORTED(mod)
+  DEFINE_BINARY_NOT_SUPPORTED(sym_min)
+  DEFINE_BINARY_NOT_SUPPORTED(sym_max)
+  DEFINE_BINARY_NOT_SUPPORTED(sym_and)
+  DEFINE_BINARY_NOT_SUPPORTED(sym_or)
+
+#undef DEFINE_BINARY_NOT_SUPPORTED
+
+#define DEFINE_NOT_SUPPORTED(name)                                     \
+  c10::SymNode name() override {                                       \
+    TORCH_CHECK(false, #name " is not supported by NestedIntSymNode"); \
+  }
+
+  DEFINE_NOT_SUPPORTED(sym_not)
+  DEFINE_NOT_SUPPORTED(ceil)
+  DEFINE_NOT_SUPPORTED(floor)
+  DEFINE_NOT_SUPPORTED(neg)
+  DEFINE_NOT_SUPPORTED(clone)
+  DEFINE_NOT_SUPPORTED(sym_float)
+
+#undef DEFINE_NOT_SUPPORTED
+
+ private:
+  int64_t val_;
+  int64_t coeff_;
+};
+
+} // namespace c10

moondream/lib/python3.10/site-packages/torch/include/ATen/core/Reduction.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace at {
+namespace Reduction {
+
+// NB: Keep this in sync with Reduction class in torch/nn/_reduction.py
+// These constants control the reduction behavior of loss functions.
+// Ideally, this would be a scoped enum, but jit doesn't support that
+enum Reduction {
+  None,             // Do not reduce
+  Mean,             // (Possibly weighted) mean of losses
+  Sum,              // Sum losses
+  END
+};
+} // namespace Reduction
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/core/Scalar.h

@@ -0,0 +1 @@
+#include <c10/core/Scalar.h>

moondream/lib/python3.10/site-packages/torch/include/ATen/core/TorchDispatchUtils.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <torch/library.h>
+#include <ATen/core/dispatch/Dispatcher.h>
+#include <c10/util/ArrayRef.h>
+#include <c10/util/Optional.h>
+#include <c10/core/impl/TorchDispatchModeTLS.h>
+
+namespace at {
+namespace impl {
+
+TORCH_API bool tensor_has_dispatch(const at::Tensor& t);
+TORCH_API bool tensorlist_has_dispatch(at::ITensorListRef li);
+TORCH_API bool tensorlist_has_dispatch(const c10::List<c10::optional<at::Tensor>>& li);
+using c10::impl::dispatch_mode_enabled;
+
+}}

moondream/lib/python3.10/site-packages/torch/include/ATen/core/blob.h

@@ -0,0 +1,208 @@
+#pragma once
+
+#include <cstddef>
+#include <sstream>
+#include <type_traits>
+#include <typeinfo>
+#include <vector>
+
+#include <c10/util/intrusive_ptr.h>
+#include <c10/util/typeid.h>
+#include <c10/macros/Macros.h>
+
+namespace caffe2 {
+
+class Tensor;
+
+/**
+ * @brief Blob is a general container that hosts a typed pointer.
+ *
+ * A Blob hosts a pointer as well as its type, and takes charge of deleting it
+ * properly when the blob is deallocated or re-allocated with a new type. A blob
+ * could contain anything, although the most common case is to contain a Tensor.
+ */
+class TORCH_API Blob final : public c10::intrusive_ptr_target {
+ public:
+  /**
+   * Initializes an empty Blob.
+   */
+  Blob() noexcept : meta_(), pointer_(nullptr), has_ownership_(false) {}
+  ~Blob() override {
+    Reset();
+  }
+
+  Blob(Blob&& other) noexcept : Blob() {
+    swap(other);
+  }
+
+  Blob& operator=(Blob&& other) noexcept {
+    Blob(std::move(other)).swap(*this);
+    return *this;
+  }
+
+  /**
+   * Checks if the content stored in the blob is of type T.
+   */
+  template <class T>
+  bool IsType() const noexcept {
+    return meta_.Match<T>();
+  }
+
+  /**
+   * Returns the meta info of the blob.
+   */
+  const TypeMeta meta() const noexcept {
+    return meta_;
+  }
+
+  /**
+   * Returns a printable typename of the blob.
+   */
+  c10::string_view TypeName() const noexcept {
+    return meta_.name();
+  }
+
+  /**
+   * @brief Gets the const reference of the stored object. The code checks if
+   * the stored object is of the desired type.
+   */
+  // TODO(jerryzh): add a Get(c10::DeviceType) function?
+  template <class T>
+  const T& Get() const {
+    TORCH_INTERNAL_ASSERT(
+        IsType<T>(),
+        "wrong type for the Blob instance. Blob contains ",
+        meta_.name(),
+        " while caller expects ",
+        TypeMeta::TypeName<T>());
+    // TODO: after we add Get<Tensor>(c10::DeviceType)
+    // and changed all the callsites, we can add
+    // a static assert here to enforce T != Tensor
+    return *static_cast<const T*>(pointer_);
+  }
+
+  const void* GetRaw() const noexcept {
+    return pointer_;
+  }
+  void* GetRaw() noexcept {
+    return pointer_;
+  }
+
+  /**
+   * @brief Gets a mutable pointer to the stored object.
+   *
+   * If the current object is not of the right type, a new object is created
+   * and the old object is freed. Note that type T should have a default
+   * constructor. Otherwise, create the object yourself first, and use
+   * Reset().
+   */
+  template <class T>
+  T* GetMutable() {
+    static_assert(
+        std::is_default_constructible<T>::value,
+        "GetMutable can't be called with non-default-constructible types. "
+        "Try using specialized methods");
+    if (IsType<T>()) {
+      return static_cast<T*>(pointer_);
+    } else {
+      // TODO Re-enable logging
+      // VLOG(1) << "Create new mutable object " << TypeMeta::TypeName<T>();
+      return Reset<T>(new T());
+    }
+  }
+
+  template <class T>
+  T* GetMutableOrNull() {
+    if (IsType<T>()) {
+      return static_cast<T*>(pointer_);
+    } else {
+      return nullptr;
+    }
+  }
+
+  /**
+   * Sets the underlying object to the allocated one. The Blob then takes over
+   * the ownership of the passed in pointer. If there is already an object in
+   * the Blob, the old object is freed.
+   *
+   * This is used when the underlying class T does not have a default ctor, or
+   * complex initializations needs to be done outside the blob.
+   */
+  template <class T>
+  T* Reset(T* allocated) {
+    free_();
+    meta_ = TypeMeta::Make<T>();
+    pointer_ = static_cast<void*>(allocated);
+    has_ownership_ = true;
+    return allocated;
+  }
+
+  /**
+   * Sets the underlying object to the allocated one, but does not take over
+   * the ownership of the passed in pointer. If there is already an object in
+   * the Blob, the old object is freed.
+   *
+   * Unlike Reset, this does not take over the ownership of the pointer and the
+   * caller is responsible for making sure that the lifetime of the allocated
+   * blob outlasts the lifetime of any access to this blob, until another Reset
+   * call is made or the blob is destructed.
+   */
+  template <class T>
+  typename std::remove_const<T>::type* ShareExternal(
+      typename std::remove_const<T>::type* allocated) {
+    return static_cast<T*>(ShareExternal(
+        static_cast<void*>(allocated),
+        TypeMeta::Make<typename std::remove_const<T>::type>()));
+  }
+
+  void* ShareExternal(void* allocated, const TypeMeta meta) {
+    free_();
+    meta_ = meta;
+    pointer_ = allocated;
+    has_ownership_ = false;
+    return allocated;
+  }
+
+  /**
+   * Resets the Blob to an empty one.
+   */
+  void Reset() {
+    free_();
+    pointer_ = nullptr;
+    meta_ = TypeMeta();
+    has_ownership_ = false;
+  }
+
+  /**
+   * @brief Swaps the underlying storage of two blobs.
+   */
+  void swap(Blob& rhs) {
+    using std::swap;
+    swap(meta_, rhs.meta_);
+    swap(pointer_, rhs.pointer_);
+    swap(has_ownership_, rhs.has_ownership_);
+  }
+
+ private:
+  void free_() {
+    if (has_ownership_ && pointer_ != nullptr) {
+      (*meta_.deleteFn())(pointer_);
+    }
+  }
+
+  TypeMeta meta_;
+  void* pointer_;
+  bool has_ownership_;
+
+  C10_DISABLE_COPY_AND_ASSIGN(Blob);
+};
+
+inline void swap(Blob& lhs, Blob& rhs) {
+  lhs.swap(rhs);
+}
+
+inline std::ostream& operator<<(std::ostream& out, const Blob& v) {
+  return out << "Blob[" << v.TypeName() << "]";
+}
+
+} // namespace caffe2

moondream/lib/python3.10/site-packages/torch/include/ATen/core/ivalue_to.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <string>
+
+namespace at {
+class Tensor;
+} // namespace at
+
+namespace c10 {
+struct IValue;
+namespace detail {
+// Determine the return type of `IValue::to() const &`. It's a const
+// reference when possible and a copy otherwise. It is in this
+// separate header so that List can use it as well.
+template<typename T>
+struct ivalue_to_const_ref_overload_return {
+  using type = T;
+};
+
+template<>
+struct ivalue_to_const_ref_overload_return<at::Tensor> {
+  using type = const at::Tensor&;
+};
+
+template<>
+struct ivalue_to_const_ref_overload_return<std::string> {
+  using type = const std::string&;
+};
+
+template<>
+struct ivalue_to_const_ref_overload_return<IValue> {
+  using type = const IValue&;
+};
+
+} // namespace detail
+} // namespace c10

moondream/lib/python3.10/site-packages/torch/include/ATen/core/jit_type_base.h

@@ -0,0 +1,719 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <ATen/core/qualified_name.h>
+#include <ATen/core/type_ptr.h>
+#include <c10/core/SymInt.h>
+#include <c10/core/SymFloat.h>
+#include <c10/core/SymBool.h>
+#include <c10/core/SymIntArrayRef.h>
+#include <c10/macros/Macros.h>
+#include <c10/util/ArrayRef.h>
+#include <c10/util/Exception.h>
+#include <c10/util/Optional.h>
+
+namespace c10 {
+
+#define C10_FORALL_TYPES(_) \
+  _(AnyType)                \
+  _(EnumType)               \
+  _(AnyEnumType)            \
+  _(TensorType)             \
+  _(StorageType)            \
+  _(TupleType)              \
+  _(ListType)               \
+  _(DictType)               \
+  _(NumberType)             \
+  _(FloatType)              \
+  _(ComplexType)            \
+  _(FutureType)             \
+  _(AwaitType)              \
+  _(RRefType)               \
+  _(IntType)                \
+  _(NoneType)               \
+  _(StringType)             \
+  _(GeneratorType)          \
+  _(QuantizerType)          \
+  _(BoolType)               \
+  _(OptionalType)           \
+  _(VarType)                \
+  _(DeviceObjType)          \
+  _(StreamObjType)          \
+  _(FunctionType)           \
+  _(ClassType)              \
+  _(PyObjectType)           \
+  _(CapsuleType)            \
+  _(InterfaceType)          \
+  _(QSchemeType)            \
+  _(ScalarTypeType)         \
+  _(LayoutType)             \
+  _(MemoryFormatType)       \
+  _(AnyListType)            \
+  _(AnyTupleType)           \
+  _(AnyClassType)           \
+  _(SymIntType)             \
+  _(SymFloatType)           \
+  _(SymBoolType)            \
+  _(UnionType)              \
+  _(DynamicType)
+
+enum class TypeKind {
+#define DEFINE_TYPE(T) T,
+  C10_FORALL_TYPES(DEFINE_TYPE)
+#undef DEFINE_TYPE
+};
+
+TORCH_API const char* typeKindToString(TypeKind kind);
+
+struct Type;
+struct SharedType;
+
+// Use this to customize how a Type is printed using `annotation_str()`. If
+// c10::nullopt is returned, `annotation_str()` falls through to its default
+// implementation.
+using TypePrinter = std::function<c10::optional<std::string>(const Type&)>;
+
+namespace detail {
+template <typename T>
+struct IsSingletonType : public std::integral_constant<bool, false> {};
+} // namespace detail
+#define TORCH_DECLARE_SINGLETON(Type) \
+  struct Type;                                                          \
+  namespace detail { \
+  template <> struct IsSingletonType<Type> : public std::integral_constant<bool, true> {}; \
+  }
+
+TORCH_DECLARE_SINGLETON(AnyType);
+TORCH_DECLARE_SINGLETON(AnyEnumType);
+TORCH_DECLARE_SINGLETON(NumberType);
+TORCH_DECLARE_SINGLETON(FloatType);
+TORCH_DECLARE_SINGLETON(ComplexType);
+TORCH_DECLARE_SINGLETON(IntType);
+TORCH_DECLARE_SINGLETON(BoolType);
+TORCH_DECLARE_SINGLETON(StringType);
+TORCH_DECLARE_SINGLETON(StorageType);
+TORCH_DECLARE_SINGLETON(NoneType);
+TORCH_DECLARE_SINGLETON(GeneratorType);
+TORCH_DECLARE_SINGLETON(QuantizerType);
+TORCH_DECLARE_SINGLETON(QSchemeType);
+TORCH_DECLARE_SINGLETON(DeviceObjType);
+TORCH_DECLARE_SINGLETON(StreamObjType);
+TORCH_DECLARE_SINGLETON(CapsuleType);
+TORCH_DECLARE_SINGLETON(PyObjectType);
+TORCH_DECLARE_SINGLETON(ScalarTypeType);
+TORCH_DECLARE_SINGLETON(LayoutType);
+TORCH_DECLARE_SINGLETON(MemoryFormatType);
+TORCH_DECLARE_SINGLETON(AnyListType);
+TORCH_DECLARE_SINGLETON(AnyTupleType);
+TORCH_DECLARE_SINGLETON(AnyClassType);
+
+namespace detail {
+template <typename T, typename Enable = void>
+struct CastReturnType {
+  using type = std::shared_ptr<T>;
+};
+
+template <typename T>
+struct CastReturnType<T, typename std::enable_if<IsSingletonType<T>::value>::type> {
+  using type = SingletonTypePtr<T>;
+};
+
+template <typename T, typename Enable = void>
+struct CastConstReturnType {
+  using type = std::shared_ptr<const T>;
+};
+
+template <typename T>
+struct CastConstReturnType<T, typename std::enable_if<IsSingletonType<T>::value>::type> {
+  using type = SingletonTypePtr<const T>;
+};
+
+template <typename T>
+struct as_shared_type {
+  using type = SharedType*;
+};
+
+template <typename T>
+struct as_shared_type<const T*> {
+  using type = const SharedType *;
+};
+} // namespace detail
+
+struct TORCH_API Type {
+  friend TORCH_API bool operator==(const Type& lhs, const Type& rhs);
+  private:
+  TypeKind kind_;
+
+  protected:
+  Type(TypeKind kind) : kind_(kind) {}
+
+  Type(const Type&) = default;
+  Type& operator=(const Type&) = default;
+  Type(Type&&) noexcept = default;
+  Type& operator=(Type&&) noexcept = default;
+
+  virtual std::string annotation_str_impl(TypePrinter /*printer*/) const {
+    return str();
+  }
+  // a == b
+  virtual bool equals(const Type& rhs) const = 0;
+  // a == b <=> b == a
+  virtual bool symmetric() const {
+    return true;
+  }
+
+ public:
+  template <typename T>
+  class SingletonOrSharedTypePtr {
+   public:
+    using element_type = typename std::shared_ptr<T>::element_type;
+
+    SingletonOrSharedTypePtr() = default;
+
+    /* implicit */ SingletonOrSharedTypePtr(std::shared_ptr<T> x)
+        : repr_(std::move(x)) {}
+
+    template <typename U, std::enable_if_t<std::is_convertible<U*, T*>::value, bool> = true>
+    /* implicit */ SingletonOrSharedTypePtr(std::shared_ptr<U> x)
+        : repr_(std::move(x)) {}
+
+    /* implicit */ SingletonOrSharedTypePtr(std::nullptr_t)
+        : repr_(nullptr) {}
+
+    /* implicit */ SingletonOrSharedTypePtr(SingletonTypePtr<T> p)
+        : repr_(p) {}
+
+    template <typename U, std::enable_if_t<std::is_convertible<U*, T*>::value, bool> = true>
+    /* implicit */ SingletonOrSharedTypePtr(SingletonTypePtr<U> p)
+        : repr_(SingletonTypePtr<T>(p.get())) {}
+
+
+    // We need to support construction from T* for pybind. The problem
+    // is that it's not clear if we are supposed to be taking shared
+    // ownership or not.
+    //
+    // Case 1: if T is known statically to derive from SharedType, we should use
+    // shared_from_this() and take shared_ownership.
+    //
+    // Case 2: if T is exactly Type, we need to do a dynamic_cast to
+    // check if it's a SharedType and do the right thing.
+    //
+    // Case 3: Otherwise, T is not a SharedType. (debug-check this
+    // assumption!) Use a singleton pointer.
+
+    template <typename U = T, std::enable_if_t<std::is_base_of<SharedType, U>::value, bool> = true>
+    /* implicit */ SingletonOrSharedTypePtr(T* p) : SingletonOrSharedTypePtr(static_cast<typename detail::as_shared_type<U>::type>(p)->shared_from_this()) {}
+
+    template <typename U = T, std::enable_if_t<std::is_same<Type, U>::value, bool> = true>
+    /* implicit */ SingletonOrSharedTypePtr(T* p) {
+      if (auto* shared_p = dynamic_cast<typename detail::as_shared_type<U>::type>(p)) {
+        repr_ = Repr(shared_p->shared_from_this());
+      } else {
+        repr_ = Repr(p);
+      }
+    }
+
+    template <typename U = T, std::enable_if_t<!std::is_same<Type, U>::value && !std::is_base_of<SharedType, U>::value, bool> = true>
+    /* implicit */ SingletonOrSharedTypePtr(T* p)
+        : repr_(p) {
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(dynamic_cast<typename detail::as_shared_type<U>::type>(p) == nullptr);
+    }
+
+    SingletonOrSharedTypePtr(const SingletonOrSharedTypePtr&) = default;
+    SingletonOrSharedTypePtr(SingletonOrSharedTypePtr&&) noexcept = default;
+    SingletonOrSharedTypePtr& operator=(const SingletonOrSharedTypePtr&) = default;
+    SingletonOrSharedTypePtr& operator=(SingletonOrSharedTypePtr&&) noexcept = default;
+
+    T* get() const {
+      return repr_.isSharedAndNonNull() ? repr_.shared_.repr_.get() : static_cast<T*>(repr_.rawRepr().first);
+    }
+
+    operator bool() const {
+      return repr_.isNonNull();
+    }
+
+    bool operator==(std::nullptr_t) const {
+      return !repr_.isNonNull();
+    }
+
+    bool operator!=(std::nullptr_t) const {
+      return repr_.isNonNull();
+    }
+
+    template <typename U = T, std::enable_if_t<!std::is_same<std::remove_const_t<U>, void>::value, bool> = true>
+    U& operator*() const {
+      return *get();
+    }
+
+    T* operator->() const {
+      return get();
+    }
+
+  private:
+    // NOTE: SharedPtrWrapper exists to work around a baffling bug in
+    // nvcc; see comment in destroy() below.
+    struct SharedPtrWrapper {
+      SharedPtrWrapper(std::shared_ptr<T> &&x)
+          : repr_(std::move(x)) {}
+      std::shared_ptr<T> repr_;
+    };
+    union Repr {
+      Repr() : Repr(nullptr) {}
+
+      explicit Repr(std::shared_ptr<T> x)
+          : shared_(std::move(x)) {}
+
+      explicit Repr(std::nullptr_t)
+          : singletonRepr_(nullptr) {}
+
+      explicit Repr(SingletonTypePtr<T> p)
+          : singletonRepr_(p.get()) {}
+
+      ~Repr() {
+        destroy();
+      }
+
+      // NOTE: the only non-UB way to access our null state is through
+      // rawRepr(), because our copy operation doesn't preserve which
+      // union member is active for null pointers.
+      Repr(const Repr& rhs) {
+        if (rhs.isSharedAndNonNull()) {
+          new (&shared_) SharedPtrWrapper(rhs.shared_);
+        } else {
+          singletonRepr_.singleton_ = static_cast<T*>(rhs.rawRepr().first);
+          TORCH_INTERNAL_ASSERT_DEBUG_ONLY(rhs.singletonRepr_.unused_ == nullptr);
+          singletonRepr_.unused_ = nullptr;
+        }
+      }
+
+      Repr(Repr&& rhs) noexcept {
+        if (rhs.isSharedAndNonNull()) {
+          new (&shared_) SharedPtrWrapper(std::move(rhs.shared_));
+        } else {
+          singletonRepr_.singleton_ = static_cast<T*>(rhs.rawRepr().first);
+          TORCH_INTERNAL_ASSERT_DEBUG_ONLY(rhs.singletonRepr_.unused_ == nullptr);
+          singletonRepr_.unused_ = nullptr;
+        }
+      }
+
+      Repr& operator=(const Repr& rhs) {
+        if (&rhs == this) {
+          return *this;
+        }
+        if (rhs.isSharedAndNonNull()) {
+          if (isSharedAndNonNull()) {
+            shared_ = rhs.shared_;
+          } else {
+            new (&shared_) SharedPtrWrapper(rhs.shared_);
+          }
+        } else {
+          if (isSharedAndNonNull()) {
+            destroy();
+          }
+          singletonRepr_.singleton_ = static_cast<T*>(rhs.rawRepr().first);
+          TORCH_INTERNAL_ASSERT_DEBUG_ONLY(rhs.rawRepr().nullIfSingleton_ == nullptr);
+          singletonRepr_.unused_ = nullptr;
+        }
+        return *this;
+      }
+
+      Repr& operator=(Repr&& rhs) noexcept {
+        if (&rhs == this) {
+          return *this;
+        }
+        if (rhs.isSharedAndNonNull()) {
+          if (isSharedAndNonNull()) {
+            shared_ = std::move(rhs.shared_);
+          } else {
+            new (&shared_) SharedPtrWrapper(std::move(rhs.shared_));
+          }
+        } else {
+          if (isSharedAndNonNull()) {
+            destroy();
+          }
+          singletonRepr_.singleton_ = static_cast<T*>(rhs.rawRepr().first);
+          TORCH_INTERNAL_ASSERT_DEBUG_ONLY(rhs.rawRepr().nullIfSingleton_ == nullptr);
+          singletonRepr_.unused_ = nullptr;
+        }
+        return *this;
+      }
+
+      SharedPtrWrapper shared_;
+
+      struct SingletonRepr {
+        explicit SingletonRepr(T* s) : singleton_(s) {}
+        T* singleton_;
+        void* unused_ = nullptr;
+      } singletonRepr_;
+      struct RawRepr {
+        void* first;
+        void* nullIfSingleton_;
+      };
+
+      // It is UB to read the singleton part of Repr if it was
+      // constructed as a shared_ptr and vice versa, but memcpying out
+      // the representation is always OK, so here's an accessor to obey
+      // the letter of the law.
+      RawRepr rawRepr() const {
+        RawRepr repr{};
+        memcpy(&repr, reinterpret_cast<const char *>(this), sizeof(RawRepr));
+        return repr;
+      }
+
+      bool isNonNull() const {
+        auto repr = rawRepr();
+        TORCH_INTERNAL_ASSERT_DEBUG_ONLY(repr.nullIfSingleton_ == nullptr || repr.first != nullptr);
+        return repr.first != nullptr;
+      }
+
+      bool isSharedAndNonNull() const {
+        return rawRepr().nullIfSingleton_ != nullptr;
+      }
+
+     private:
+      void destroy() {
+        if (isSharedAndNonNull()) {
+          // Without SharedPtrWrapper, this line would read
+          // `shared_.~shared_ptr()` and nvcc would complain with
+          // "error: expected primary-expression before '>' token"
+          // referring to the "t" in "shared_ptr". SharedPtrWrapper
+          // exists to work around this compiler bug.
+          shared_.~SharedPtrWrapper();
+        }
+      }
+    } repr_;
+  };
+
+  using TypePtr = SingletonOrSharedTypePtr<Type>;
+  using Ptr = TypePtr;
+  using ElementType = Type;
+
+  // subtyping relation. By default, we return true for the case
+  // when the type is exactly equal or if this <: T where rhs = Optional[T]
+
+  // if this returns false and the why_not stream is non-null, it contains
+  // additional details that describe why this is not a subtype of 'rhs'.
+  // This additional information should only contain details that are not
+  // obvious from the annotation_str() that describes the type. For instance it
+  // is clear that `int <: str` is false but not clear why `Foo <: InterfaceBar`
+  // might be false.
+  virtual bool isSubtypeOfExt(const Type& rhs, std::ostream* why_not) const;
+  virtual bool is_module() const;
+  bool isSubtypeOf(const Type& rhs) const {
+    return isSubtypeOfExt(rhs, nullptr);
+  }
+  // Compatibility shims to accommodate existing code that passes shared_ptrs
+  // around. Ideally, we would just delete this, but it should be harmless.
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOf(const std::shared_ptr<T>& rhs) const {
+    return isSubtypeOf(*rhs);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOf(const SingletonOrSharedTypePtr<T>& rhs) const {
+    return isSubtypeOf(*rhs);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOf(SingletonTypePtr<T> rhs) const {
+    return isSubtypeOf(*rhs);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOfExt(const SingletonOrSharedTypePtr<T>& rhs, std::ostream* why_not) const {
+    return isSubtypeOfExt(*rhs, why_not);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOfExt(const std::shared_ptr<T>& rhs, std::ostream* why_not) const {
+    return isSubtypeOfExt(*rhs, why_not);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_base_of<Type, T>::value, bool>::type
+  isSubtypeOfExt(SingletonTypePtr<T> rhs, std::ostream* why_not) const {
+    return isSubtypeOfExt(*rhs, why_not);
+  }
+
+  // How this type will appear in FunctionSchema declarations
+  virtual std::string str() const = 0;
+
+  // How this type will appear as if it were a type annotation in Python
+  // which is sometimes different than how it appears in declarations (e.g.
+  // int[] vs List[int])
+  //
+  // Takes a custom printer that users can pass in to customize the output of
+  // this method.
+  std::string annotation_str(TypePrinter printer) const {
+    if (printer) {
+      // the printer can return nullopt to fall through to the default impl
+      if (auto renamed = printer(*this)) {
+        return *renamed;
+      }
+    }
+    return annotation_str_impl(std::move(printer));
+  }
+  std::string annotation_str() const {
+    // Overload instead of define a default value for `printer` to help
+    // debuggers out.
+    return annotation_str(nullptr);
+  }
+
+  // Returns a human readable string that includes additional information like
+  // "type is inferred rather than explicitly defined" to help construct more
+  // user-friendly messages.
+  virtual std::string repr_str() const {
+    return annotation_str();
+  }
+
+  TypeKind kind() const {
+    return kind_;
+  }
+
+  virtual bool isUnionType() const {
+    return false;
+  }
+
+  virtual bool requires_grad() const {
+    for (const auto& ct : containedTypes()) {
+      if (ct->requires_grad()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Dynamically cast this object to the subclass indicated by the
+  // template variable, returning nullptr if the cast is invalid.
+  template <typename T, std::enable_if_t<!detail::IsSingletonType<T>::value, bool> = true>
+  typename detail::CastReturnType<T>::type cast() {
+    if (T::Kind == kind()) {
+      return std::static_pointer_cast<T>(static_cast<T*>(this)->shared_from_this());
+    }
+    return nullptr;
+  }
+  template <typename T, std::enable_if_t<detail::IsSingletonType<T>::value, bool> = true>
+  typename detail::CastReturnType<T>::type cast() {
+    if (T::Kind == kind()) {
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(this == T::get().get());
+      return typename detail::CastReturnType<T>::type(static_cast<T*>(this));
+    }
+    return nullptr;
+  }
+  template <typename T, std::enable_if_t<!detail::IsSingletonType<T>::value, bool> = true>
+  typename detail::CastConstReturnType<T>::type cast() const {
+    if (T::Kind == kind()) {
+      return std::static_pointer_cast<const T>(static_cast<const T*>(this)->shared_from_this());
+    }
+    return nullptr;
+  }
+  template <typename T, std::enable_if_t<detail::IsSingletonType<T>::value, bool> = true>
+  typename detail::CastConstReturnType<T>::type cast() const {
+    if (T::Kind == kind()) {
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(this == T::get().get());
+      return typename detail::CastConstReturnType<T>::type(static_cast<const T*>(this));
+    }
+    return nullptr;
+  }
+  template <typename T>
+  T* castRaw() {
+    if (T::Kind == kind()) {
+      return static_cast<T*>(this);
+    }
+    return nullptr;
+  }
+  template <typename T>
+  const T* castRaw() const {
+    if (T::Kind == kind()) {
+      return static_cast<const T*>(this);
+    }
+    return nullptr;
+  }
+  template <typename T>
+  auto expect() {
+    auto r = cast<T>();
+    AT_ASSERT(r);
+    return r;
+  }
+  template <typename T>
+  auto expect() const {
+    auto r = cast<const T>();
+    AT_ASSERT(r);
+    return r;
+  }
+  template <typename T>
+  T& expectRef() {
+    auto* r = castRaw<T>();
+    AT_ASSERT(r);
+    return *r;
+  }
+  template <typename T>
+  const T& expectRef() const {
+    auto* r = castRaw<const T>();
+    AT_ASSERT(r);
+    return *r;
+  }
+  virtual ~Type() = default;
+  virtual bool hasFreeVariables() const {
+    return false;
+  }
+  // list of types this type contains, e.g. for a List then element type of a
+  // list for a tuple, the types of the tuple elements
+  virtual at::ArrayRef<TypePtr> containedTypes() const {
+    return {};
+  }
+  virtual TypePtr containedType(size_t i) const {
+    return containedTypes().at(i);
+  }
+  virtual size_t containedTypeSize() const {
+    return containedTypes().size();
+  }
+  // create a new version of this type, replacing its contained types with
+  // contained_types
+  TypePtr withContained(std::vector<TypePtr> contained_types);
+  // per-type constructor, you only need to override this if the
+  // containedTypes() is not empty
+  virtual TypePtr createWithContained(
+      std::vector<TypePtr> /*contained_types*/) const {
+    AT_ERROR(
+        "type with contained types did not overload createWithContained: ",
+        str());
+  }
+
+};
+
+template <typename T>
+using SingletonOrSharedTypePtr = Type::SingletonOrSharedTypePtr<T>;
+
+
+template <typename T, typename U>
+bool operator==(const SingletonOrSharedTypePtr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return (void*)x.get() == (void*)y.get();
+}
+
+template <typename T, typename U>
+bool operator==(const SingletonOrSharedTypePtr<T>& x, const std::shared_ptr<U>& y) {
+  return (void*)x.get() == (void*)y.get();
+}
+
+template <typename T, typename U>
+bool operator==(const std::shared_ptr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return (void*)x.get() == (void*)y.get();
+}
+
+template <typename T, typename U>
+bool operator==(const SingletonOrSharedTypePtr<T>& x, const SingletonTypePtr<U>& y) {
+  return (void*)x.get() == (void*)y.get();
+}
+
+template <typename T, typename U>
+bool operator==(const SingletonTypePtr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return (void*)x.get() == (void*)y.get();
+}
+
+template <typename T, typename U>
+bool operator!=(const SingletonOrSharedTypePtr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return !(x == y);
+}
+
+template <typename T, typename U>
+bool operator!=(const SingletonOrSharedTypePtr<T>& x, const std::shared_ptr<U>& y) {
+  return !(x == y);
+}
+
+template <typename T, typename U>
+bool operator!=(const std::shared_ptr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return !(x == y);
+}
+
+template <typename T, typename U>
+bool operator!=(const SingletonOrSharedTypePtr<T>& x, const SingletonTypePtr<U>& y) {
+  return !(x == y);
+}
+
+template <typename T, typename U>
+bool operator!=(const SingletonTypePtr<T>& x, const SingletonOrSharedTypePtr<U>& y) {
+  return !(x == y);
+}
+
+using TypePtr = SingletonOrSharedTypePtr<Type>;
+using ConstTypePtr = SingletonOrSharedTypePtr<const Type>;
+
+// Explicitly enable MaybeOwned<shared_ptr<T>>, rather than allowing
+// MaybeOwned to be used for any type right away.
+template <typename T>
+struct MaybeOwnedTraits<SingletonOrSharedTypePtr<T>>
+    : public MaybeOwnedTraitsGenericImpl<SingletonOrSharedTypePtr<T>> {};
+
+// Base class for Types that are guaranteed to be owned by std::shared_ptr.
+struct TORCH_API SharedType : public Type, public std::enable_shared_from_this<SharedType> {
+  using Type::Type;
+};
+
+inline TypePtr Type::withContained(std::vector<TypePtr> contained_types) {
+  auto current_contained = containedTypes();
+  // Types with no contained_types don't need this call. Check before calling!
+  //
+  // (We can't support this efficiently because types without
+  // contained types may be singletons, in which case
+  // shared_from_this will crash; we would have to provide a virtual
+  // typeptr_from_this or isSingleton.)
+  TORCH_INTERNAL_ASSERT(!current_contained.empty() && current_contained.size() == contained_types.size());
+  if (current_contained.equals(contained_types)) {
+    return std::static_pointer_cast<Type>(static_cast<SharedType *>(this)->shared_from_this());
+  }
+  return createWithContained(std::move(contained_types));
+}
+
+
+TORCH_API inline bool operator==(const Type& lhs, const Type& rhs) {
+  if (C10_UNLIKELY(!rhs.symmetric())) {
+    return rhs.equals(lhs);
+  }
+  return lhs.equals(rhs);
+}
+
+struct NamedType;
+using NamedTypePtr = std::shared_ptr<NamedType>;
+using ConstNamedTypePtr = std::shared_ptr<const NamedType>;
+
+struct TORCH_API NamedType : public SharedType {
+  NamedType(TypeKind tk, c10::optional<QualifiedName> name)
+      : SharedType(tk), name_(std::move(name)) {
+    TORCH_INTERNAL_ASSERT(
+        tk == TypeKind::TupleType || tk == TypeKind::FunctionType ||
+            tk == TypeKind::ClassType || tk == TypeKind::InterfaceType ||
+            tk == TypeKind::EnumType,
+        "If you add a new kind of NamedType, ",
+        "please update the cast<NamedType> specialization and this assert");
+  }
+
+  // Fully qualified name of type
+  // Looks like: "foo.bar.Baz".
+  const c10::optional<QualifiedName>& name() const {
+    return name_;
+  }
+
+ private:
+  c10::optional<QualifiedName> name_;
+};
+
+} // namespace c10
+
+namespace std {
+template <typename T>
+struct hash<c10::SingletonOrSharedTypePtr<T>> {
+  size_t operator()(const c10::SingletonOrSharedTypePtr<T>& x) const {
+    return std::hash<T*>()(x.get());
+  }
+};
+} // namespace std

moondream/lib/python3.10/site-packages/torch/include/ATen/core/rref_interface.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <c10/util/intrusive_ptr.h>
+#include <ATen/core/type_ptr.h>
+
+namespace c10 {
+
+struct Type;
+using worker_id_t = int16_t;
+
+// This abstract class contains only user-facing APIs, and will be shared
+// between jit and distributed to implement TorchScript support.
+class C10_EXPORT RRefInterface : public c10::intrusive_ptr_target {
+ public:
+  RRefInterface() = default;
+  // RRef is made NOT copyable NOT movable to prevent messing up reference
+  // counting.
+  RRefInterface(const RRefInterface& other) = delete;
+  RRefInterface(RRefInterface&& other) = delete;
+  RRefInterface& operator=(RRefInterface&& other) = delete;
+
+  ~RRefInterface() override = default;
+
+  // returns the worker id of the owner
+  virtual worker_id_t owner() const = 0;
+
+  // returns the worker name of the owner
+  virtual std::string ownerName() const = 0;
+
+  // Returns true if this is the ``OwnerRRef``
+  virtual bool isOwner() const = 0;
+
+  // Returns true if this is an ``OwnerRRef`` or if this ``UserRRef`` has been
+  // confirmed by its owner.
+  virtual bool confirmedByOwner() const = 0;
+
+  virtual const TypePtr type() const = 0;
+};
+
+}

moondream/lib/python3.10/site-packages/torch/include/ATen/cudnn/Descriptors.h

@@ -0,0 +1,391 @@
+#pragma once
+
+#include <string>
+
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/Exceptions.h>
+
+#include <ATen/cudnn/cudnn-wrapper.h>
+#include <ATen/cudnn/Utils.h>
+#include <ATen/core/Tensor.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/cuda/ATenCUDAGeneral.h>
+#include <cuda.h>
+
+#ifndef AT_PER_OPERATOR_HEADERS
+#include <ATen/Functions.h>
+#else
+#include <ATen/ops/empty.h>
+#endif
+
+#if defined(CUDNN_VERSION) && CUDNN_VERSION >= 8907
+#define USE_CUDNN_RNN_V8_API
+#endif
+
+namespace at { namespace native {
+
+std::string cudnnTypeToString(cudnnDataType_t dtype);
+
+// TODO: Add constructors for all of the descriptors
+
+inline int dataSize(cudnnDataType_t dataType)
+{
+  switch (dataType) {
+#if defined(CUDNN_VERSION) && CUDNN_VERSION >= 8200
+    case CUDNN_DATA_BFLOAT16:
+#endif
+    case CUDNN_DATA_HALF: return 2;
+    case CUDNN_DATA_FLOAT: return 4;
+    default: return 8;
+  }
+}
+
+// The stride for a size-1 dimensions is not uniquely determined; in
+// fact, it can be anything you want, because the fact that the
+// tensor is size 1 at this dimension means that you will never actually
+// try advancing your pointer by this stride.
+//
+// However, CuDNN has a much more stringent requirement on strides:
+// if you are passing a contiguous input, it better be the case
+// that the stride for dim i is the product of the sizes of dims
+// i+1 to the end.  This stride is indeed uniquely determined.  This
+// function modifies 'stride' in place so this invariant holds.
+template <typename T>
+static inline void fixSizeOneDimStride(int dim, const T *size, T *stride, bool nhwc) {
+  int64_t z = 1;
+  int index = 0;
+  std::vector<int> permutation(dim);
+
+  if (nhwc) {
+    permutation[index++] = 1;
+  }
+  for (int d = dim-1; d > 1; d--) {
+    permutation[index++] = d;
+  }
+  if (!nhwc) {
+    permutation[index++] = 1;
+  }
+  permutation[index++] = 0;
+  for (int d : permutation) {
+    if (size[d] == 1) {
+      stride[d] = z;
+    } else {
+      z *= size[d];
+    }
+  }
+}
+
+template <typename T, cudnnStatus_t (*dtor)(T*)>
+struct DescriptorDeleter {
+  void operator()(T* x) {
+    if (x != nullptr) {
+      AT_CUDNN_CHECK(dtor(x));
+    }
+  }
+};
+
+// A generic class for wrapping cuDNN descriptor types.  All you need
+// is to give the underlying type the Descriptor_t points to (usually,
+// if it's cudnnTensorDescriptor_t it points to cudnnTensorStruct),
+// the constructor and the destructor.  Subclasses are responsible
+// for defining a set() function to actually set the descriptor.
+//
+// Descriptors default construct to a nullptr, and have a descriptor
+// initialized the first time you call set() or any other initializing
+// function.
+template <typename T, cudnnStatus_t (*ctor)(T**), cudnnStatus_t (*dtor)(T*)>
+class TORCH_CUDA_CPP_API Descriptor {
+ public:
+  // TODO: Figure out why const-correctness doesn't work here
+
+  // Use desc() to access the underlying descriptor pointer in
+  // a read-only fashion.  Most client code should use this.
+  // If the descriptor was never initialized, this will return
+  // nullptr.
+  T* desc() const { return desc_.get(); }
+  T* desc() { return desc_.get(); }
+
+  // Use mut_desc() to access the underlying descriptor pointer
+  // if you intend to modify what it points to (e.g., using
+  // cudnnSetFooDescriptor).  This will ensure that the descriptor
+  // is initialized.  Code in this file will use this function.
+  T* mut_desc() { init(); return desc_.get(); }
+protected:
+  void init() {
+    if (desc_ == nullptr) {
+      T* raw_desc;
+      AT_CUDNN_CHECK(ctor(&raw_desc));
+      desc_.reset(raw_desc);
+    }
+  }
+private:
+  std::unique_ptr<T, DescriptorDeleter<T, dtor>> desc_;
+};
+
+class TORCH_CUDA_CPP_API RNNDataDescriptor : public Descriptor<
+                                       cudnnRNNDataStruct,
+                                       &cudnnCreateRNNDataDescriptor,
+                                       &cudnnDestroyRNNDataDescriptor> {
+public:
+  void set(const at::Tensor &t, cudnnRNNDataLayout_t layout, int maxSeqLength, int batchSize, int vectorSize, const int* seqLengthArray);
+private:
+  void set(cudnnDataType_t dataType, cudnnRNNDataLayout_t layout, int maxSeqLength, int batchSize, int vectorSize, const int* seqLengthArray) {
+    AT_CUDNN_CHECK(cudnnSetRNNDataDescriptor(mut_desc(), dataType, layout, maxSeqLength, batchSize, vectorSize, seqLengthArray, NULL));
+  }
+};
+
+class TORCH_CUDA_CPP_API TensorDescriptor : public Descriptor<
+                                               cudnnTensorStruct,
+                                               &cudnnCreateTensorDescriptor,
+                                               &cudnnDestroyTensorDescriptor> {
+ public:
+  TensorDescriptor() = default;
+  explicit TensorDescriptor(const at::Tensor &t, size_t pad = 0) {
+    set(t, pad);
+  }
+
+  // Note [CuDNN broadcast padding]
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // pad specifies the minimum dimensionality of the tensor descriptor
+  // we produce (it doesn't have anything to do with, e.g., convolution
+  // padding).  If 't' is lower-dimensional than 'pad', the remaining
+  // dimensions (on the right) are padded with ones.  This doesn't
+  // affect the underlying data layout.  This is particularly useful for
+  // dealing with a peculiarity of the CuDNN API, which is that broadcasting in CuDNN is
+  // done in two steps: first, the client code is expected to pad out
+  // (the dimensions) input tensors to be the same dimension as the
+  // target broadcast, and then second, CuDNN takes of actually
+  // broadcasting size 1 dimensions.
+
+  void set(const at::Tensor &t, size_t pad = 0);
+  void set(const at::Tensor &t, at::MemoryFormat memory_format, size_t pad = 0);
+  void set(cudnnDataType_t dataType, IntArrayRef sizes, IntArrayRef strides, size_t pad = 0);
+
+  void print();
+
+private:
+  void set(cudnnDataType_t dataType, IntArrayRef sizes, IntArrayRef strides, size_t pad, bool nhwc);
+
+  void set(cudnnDataType_t dataType, int dim, int* size, int* stride, bool nhwc) {
+    fixSizeOneDimStride<int>(dim, size, stride, nhwc);
+    AT_CUDNN_CHECK(cudnnSetTensorNdDescriptor(mut_desc(), dataType, dim, size, stride));
+  }
+};
+
+std::ostream& operator<<(std::ostream & out, const TensorDescriptor& d);
+
+class TORCH_CUDA_CPP_API FilterDescriptor : public Descriptor<
+                                               cudnnFilterStruct,
+                                               &cudnnCreateFilterDescriptor,
+                                               &cudnnDestroyFilterDescriptor> {
+ public:
+  void set(const at::Tensor &t, int64_t pad = 0) {
+    set(t, at::MemoryFormat::Contiguous, pad);
+  }
+
+  void set(const at::Tensor &t, const at::MemoryFormat memory_format, int64_t pad = 0);
+
+  void print();
+private:
+  void set(cudnnDataType_t dataType, int dim, int* size, cudnnTensorFormat_t filter_format) {
+    AT_CUDNN_CHECK(cudnnSetFilterNdDescriptor(mut_desc(), dataType, filter_format, dim, size));
+  }
+};
+
+std::ostream& operator<<(std::ostream & out, const FilterDescriptor& d);
+
+struct TORCH_CUDA_CPP_API ConvolutionDescriptor
+    : public Descriptor<
+          cudnnConvolutionStruct,
+          &cudnnCreateConvolutionDescriptor,
+          &cudnnDestroyConvolutionDescriptor> {
+  void set(cudnnDataType_t dataType, int dim, int* pad, int* stride, int * upscale /* aka dilation */, int groups, bool allow_tf32) {
+    cudnnDataType_t mathType = dataType;
+    if (dataType == CUDNN_DATA_HALF) mathType = CUDNN_DATA_FLOAT;
+    AT_CUDNN_CHECK(cudnnSetConvolutionNdDescriptor(mut_desc(), dim, pad, stride, upscale,
+                                          CUDNN_CROSS_CORRELATION, mathType));
+    AT_CUDNN_CHECK(cudnnSetConvolutionGroupCount(mut_desc(), groups));
+    // See Note [behavior of cudnnFind and cudnnGet]
+    AT_CUDNN_CHECK(cudnnSetConvolutionMathType(mut_desc(), CUDNN_DEFAULT_MATH));
+    if(dataType == CUDNN_DATA_HALF) {
+      AT_CUDNN_CHECK(cudnnSetConvolutionMathType(mut_desc(), CUDNN_TENSOR_OP_MATH));
+    } else if (dataType == CUDNN_DATA_FLOAT && !allow_tf32) {
+      AT_CUDNN_CHECK(cudnnSetConvolutionMathType(mut_desc(), CUDNN_FMA_MATH));
+    }
+  }
+};
+
+struct TORCH_CUDA_CPP_API SpatialTransformerDescriptor
+    : public Descriptor<
+          cudnnSpatialTransformerStruct,
+          &cudnnCreateSpatialTransformerDescriptor,
+          &cudnnDestroySpatialTransformerDescriptor> {
+  void set(cudnnDataType_t dataType, int dim, int* size) {
+    AT_CUDNN_CHECK(cudnnSetSpatialTransformerNdDescriptor(mut_desc(), CUDNN_SAMPLER_BILINEAR, dataType, dim, size));
+  }
+};
+
+struct TORCH_CUDA_CPP_API DropoutDescriptor
+    : public Descriptor<
+          cudnnDropoutStruct,
+          &cudnnCreateDropoutDescriptor,
+          &cudnnDestroyDropoutDescriptor> {
+  at::Tensor state;
+
+  // Initialize a dropout descriptor's RNG state.
+  // WARNING: This function is very expensive, avoid calling this function!
+  void initialize_rng(cudnnHandle_t handle, float dropout, long long int seed, const TensorOptions& options) {
+    TORCH_INTERNAL_ASSERT(dropout > 0, "dropout must be nonzero; otherwise call set_no_dropout");
+    size_t state_size;
+    AT_CUDNN_CHECK(cudnnDropoutGetStatesSize(handle, &state_size));
+    AT_ASSERT(options.device().type() == kCUDA);
+    AT_ASSERT(options.dtype() == kByte);
+    state = at::empty({static_cast<int64_t>(state_size)}, options);
+    AT_CUDNN_CHECK(cudnnSetDropoutDescriptor(mut_desc(), handle, dropout, state.data_ptr(), state_size, seed));
+  }
+
+  // Restore a dropout descriptor given a dropout probability and existing RNG state.
+  void set(cudnnHandle_t handle, float dropout, at::Tensor state_) {
+    TORCH_INTERNAL_ASSERT(dropout > 0, "dropout must be nonzero; otherwise call set_no_dropout");
+    state = state_;
+    void *state_ptr = state.data_ptr();
+    size_t state_size = state.size(0);
+    // NB: The seed doesn't actually matter, so we give a dummy value
+    AT_CUDNN_CHECK(cudnnRestoreDropoutDescriptor(mut_desc(), handle, dropout, state_ptr, state_size, 0 /* seed */));
+  }
+
+  // Restore a dropout descriptor corresponding to no dropout
+  void set_no_dropout(cudnnHandle_t handle) {
+    // NB: seed doesn't matter when dropout = 0, because no random number
+    // initialization actually takes place when there is no dropout.
+    // NB: Empirically, cudnnSetDropoutDescriptor is cheap when
+    // dropout == 0
+    AT_CUDNN_CHECK(cudnnSetDropoutDescriptor(mut_desc(), handle, 0 /* dropout */, nullptr, 0 /* state_size */, 0 /* seed */));
+  }
+};
+
+struct TORCH_CUDA_CPP_API RNNDescriptor : public Descriptor<
+                                             cudnnRNNStruct,
+                                             &cudnnCreateRNNDescriptor,
+                                             &cudnnDestroyRNNDescriptor> {
+  DropoutDescriptor dropout_desc_;
+  void set(cudnnHandle_t handle,
+#ifdef USE_CUDNN_RNN_V8_API
+       int input_size,
+       bool packed,
+#endif
+       int hidden_size, int proj_size, int num_layers, DropoutDescriptor&& dropout_desc,
+           cudnnRNNInputMode_t input_mode, cudnnDirectionMode_t bidirectional,
+           cudnnRNNMode_t mode, cudnnDataType_t datatype, cudnnDataType_t input_type, cudnnRNNAlgo_t algo, bool allow_tf32) {
+    dropout_desc_ = std::move(dropout_desc);
+#ifndef USE_CUDNN_RNN_V8_API
+    AT_CUDNN_CHECK(cudnnSetRNNDescriptor_v6(
+          handle,
+          mut_desc(),
+          hidden_size,
+          num_layers,
+          dropout_desc_.desc(),
+          input_mode,
+          bidirectional,
+          mode,
+          algo,
+          datatype));
+    if (proj_size != 0) {
+      AT_CUDNN_CHECK(cudnnSetRNNProjectionLayers(
+            handle,
+            /*rnnDesc=*/mut_desc(),
+            /*recProjSize=*/proj_size,
+            /*outProjSize=*/0));
+    }
+    cudaDeviceProp* prop = at::cuda::getCurrentDeviceProperties();
+    if (prop->major >= 7) {
+      if (input_type == CUDNN_DATA_HALF) {
+        cudnnSetRNNMatrixMathType(mut_desc(), CUDNN_TENSOR_OP_MATH);
+      }
+      else if (input_type == CUDNN_DATA_FLOAT && !allow_tf32) {
+        cudnnSetRNNMatrixMathType(mut_desc(), CUDNN_FMA_MATH);
+      }
+      else {
+        // Technically, as the default it's not necessary to explicitly
+        // set this.
+        cudnnSetRNNMatrixMathType(mut_desc(), CUDNN_DEFAULT_MATH);
+      }
+    }
+#else
+    cudaDeviceProp* prop = at::cuda::getCurrentDeviceProperties();
+    auto math_type = CUDNN_DEFAULT_MATH;
+    if (prop->major >= 7) {
+      if (input_type == CUDNN_DATA_HALF) {
+        math_type = CUDNN_TENSOR_OP_MATH;
+      } else if (!allow_tf32) {
+        math_type = CUDNN_FMA_MATH;
+      }
+    }
+    AT_CUDNN_CHECK(cudnnSetRNNDescriptor_v8(
+          mut_desc(),
+          algo,
+          mode,
+          CUDNN_RNN_DOUBLE_BIAS,
+          bidirectional,
+          input_mode,
+          input_type,
+          datatype,
+          math_type,
+          input_size,
+          hidden_size,
+          proj_size ? proj_size : hidden_size,
+          num_layers,
+          dropout_desc_.desc(),
+          packed ? CUDNN_RNN_PADDED_IO_DISABLED : CUDNN_RNN_PADDED_IO_ENABLED));
+#endif
+  }
+};
+
+struct TORCH_CUDA_CPP_API CTCLossDescriptor
+    : public Descriptor<
+          cudnnCTCLossStruct,
+          &cudnnCreateCTCLossDescriptor,
+          &cudnnDestroyCTCLossDescriptor> {
+  void set(cudnnDataType_t datatype) {
+    AT_CUDNN_CHECK(cudnnSetCTCLossDescriptor(mut_desc(), datatype));
+  }
+  void setEx(
+      cudnnDataType_t datatype,
+      cudnnLossNormalizationMode_t normMode,
+      cudnnNanPropagation_t gradMode) {
+    AT_CUDNN_CHECK(
+        cudnnSetCTCLossDescriptorEx(mut_desc(), datatype, normMode, gradMode));
+  }
+};
+
+struct TORCH_CUDA_CPP_API ActivationDescriptor
+    : public Descriptor<
+          cudnnActivationStruct,
+          &cudnnCreateActivationDescriptor,
+          &cudnnDestroyActivationDescriptor> {
+  void set(cudnnActivationMode_t mode) {
+    AT_ASSERT(
+        mode == CUDNN_ACTIVATION_RELU,
+        "TODO: support more cuDNN activation modes");
+    AT_CUDNN_CHECK(cudnnSetActivationDescriptor(
+        mut_desc(),
+        mode,
+        cudnnNanPropagation_t::CUDNN_NOT_PROPAGATE_NAN,
+        std::numeric_limits<double>::max()));
+  }
+};
+
+union Constant
+{
+  float f;
+  double d;
+  Constant(cudnnDataType_t dataType, double value) {
+    if (dataType == CUDNN_DATA_HALF || dataType == CUDNN_DATA_FLOAT) {
+      f = static_cast<float>(value);
+    } else {
+      d = value;
+    }
+  }
+};
+
+}}  // namespace

moondream/lib/python3.10/site-packages/torch/include/ATen/cudnn/Handles.h

@@ -0,0 +1,2 @@
+#pragma once
+#include <ATen/cudnn/Handle.h>

moondream/lib/python3.10/site-packages/torch/include/ATen/cudnn/Types.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ATen/cudnn/cudnn-wrapper.h>
+#include <ATen/Tensor.h>
+
+namespace at { namespace native {
+
+TORCH_CUDA_CPP_API cudnnDataType_t
+getCudnnDataTypeFromScalarType(const at::ScalarType dtype);
+cudnnDataType_t getCudnnDataType(const at::Tensor& tensor);
+
+int64_t cudnn_version();
+
+}}  // namespace at::cudnn

moondream/lib/python3.10/site-packages/torch/include/ATen/cudnn/Utils.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <ATen/core/Tensor.h>
+#include <ATen/cuda/Exceptions.h>
+#include <ATen/cudnn/cudnn-wrapper.h>
+#include <ATen/cudnn/Handle.h>
+
+namespace at { namespace native {
+
+// cuDNN has a buggy check for tensor being contiguous (that is, it does
+// not ignore stride for dimension that is equal to 0).  This function
+// makes tensors which have zero stride contiguous, by setting the
+// strides to 1 as cuDNN likes.
+inline Tensor contiguousIfZeroInStrides(const Tensor& t) {
+  for (auto s : t.strides()) {
+    if (s == 0) return t.contiguous();
+  }
+  return t;
+}
+
+}}

moondream/lib/python3.10/site-packages/torch/include/ATen/cudnn/cudnn-wrapper.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cudnn.h>
+
+#define STRINGIFY(x) #x
+#define STRING(x) STRINGIFY(x)
+
+#if CUDNN_MAJOR < 6
+#pragma message ("CuDNN v" STRING(CUDNN_MAJOR) " found, but need at least CuDNN v6. You can get the latest version of CuDNN from https://developer.nvidia.com/cudnn or disable CuDNN with USE_CUDNN=0")
+#pragma message "We strongly encourage you to move to 6.0 and above."
+#pragma message "This message is intended to annoy you enough to update."
+#endif
+
+#undef STRINGIFY
+#undef STRING

moondream/lib/python3.10/site-packages/torch/include/ATen/detail/CUDAHooksInterface.h

@@ -0,0 +1,201 @@
+#pragma once
+
+#include <c10/core/Allocator.h>
+#include <c10/util/Exception.h>
+#include <c10/util/Registry.h>
+
+#include <ATen/detail/AcceleratorHooksInterface.h>
+
+// Forward-declares at::Generator and at::cuda::NVRTC
+namespace at {
+struct Generator;
+namespace cuda {
+struct NVRTC;
+} // namespace cuda
+} // namespace at
+
+// NB: Class must live in `at` due to limitations of Registry.h.
+namespace at {
+
+#ifdef _MSC_VER
+constexpr const char* CUDA_HELP =
+  "PyTorch splits its backend into two shared libraries: a CPU library "
+  "and a CUDA library; this error has occurred because you are trying "
+  "to use some CUDA functionality, but the CUDA library has not been "
+  "loaded by the dynamic linker for some reason.  The CUDA library MUST "
+  "be loaded, EVEN IF you don't directly use any symbols from the CUDA library! "
+  "One common culprit is a lack of -INCLUDE:?warp_size@cuda@at@@YAHXZ "
+  "in your link arguments; many dynamic linkers will delete dynamic library "
+  "dependencies if you don't depend on any of their symbols.  You can check "
+  "if this has occurred by using link on your binary to see if there is a "
+  "dependency on *_cuda.dll library.";
+#else
+constexpr const char* CUDA_HELP =
+  "PyTorch splits its backend into two shared libraries: a CPU library "
+  "and a CUDA library; this error has occurred because you are trying "
+  "to use some CUDA functionality, but the CUDA library has not been "
+  "loaded by the dynamic linker for some reason.  The CUDA library MUST "
+  "be loaded, EVEN IF you don't directly use any symbols from the CUDA library! "
+  "One common culprit is a lack of -Wl,--no-as-needed in your link arguments; many "
+  "dynamic linkers will delete dynamic library dependencies if you don't "
+  "depend on any of their symbols.  You can check if this has occurred by "
+  "using ldd on your binary to see if there is a dependency on *_cuda.so "
+  "library.";
+#endif
+
+// The CUDAHooksInterface is an omnibus interface for any CUDA functionality
+// which we may want to call into from CPU code (and thus must be dynamically
+// dispatched, to allow for separate compilation of CUDA code).  How do I
+// decide if a function should live in this class?  There are two tests:
+//
+//  1. Does the *implementation* of this function require linking against
+//     CUDA libraries?
+//
+//  2. Is this function *called* from non-CUDA ATen code?
+//
+// (2) should filter out many ostensible use-cases, since many times a CUDA
+// function provided by ATen is only really ever used by actual CUDA code.
+//
+// TODO: Consider putting the stub definitions in another class, so that one
+// never forgets to implement each virtual function in the real implementation
+// in CUDAHooks.  This probably doesn't buy us much though.
+struct TORCH_API CUDAHooksInterface : AcceleratorHooksInterface {
+  // This should never actually be implemented, but it is used to
+  // squelch -Werror=non-virtual-dtor
+  virtual ~CUDAHooksInterface() override = default;
+
+  // Initialize THCState and, transitively, the CUDA state
+  virtual void initCUDA() const {
+    TORCH_CHECK(false, "Cannot initialize CUDA without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual const Generator& getDefaultCUDAGenerator(C10_UNUSED DeviceIndex device_index = -1) const {
+    TORCH_CHECK(false, "Cannot get default CUDA generator without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual Device getDeviceFromPtr(void* /*data*/) const {
+    TORCH_CHECK(false, "Cannot get device of pointer on CUDA without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual bool isPinnedPtr(const void* /*data*/) const {
+    return false;
+  }
+
+  virtual bool hasCUDA() const {
+    return false;
+  }
+
+  virtual bool hasCUDART() const {
+    return false;
+  }
+
+  virtual bool hasMAGMA() const {
+    return false;
+  }
+
+  virtual bool hasCuDNN() const {
+    return false;
+  }
+
+  virtual bool hasCuSOLVER() const {
+    return false;
+  }
+
+  virtual bool hasROCM() const {
+    return false;
+  }
+
+  virtual const at::cuda::NVRTC& nvrtc() const {
+    TORCH_CHECK(false, "NVRTC requires CUDA. ", CUDA_HELP);
+  }
+
+  virtual bool hasPrimaryContext(DeviceIndex device_index) const override {
+    TORCH_CHECK(false, "Cannot call hasPrimaryContext(", device_index, ") without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual DeviceIndex current_device() const {
+    return -1;
+  }
+
+  virtual Allocator* getPinnedMemoryAllocator() const {
+    TORCH_CHECK(false, "Pinned memory requires CUDA. ", CUDA_HELP);
+  }
+
+  virtual Allocator* getCUDADeviceAllocator() const {
+    TORCH_CHECK(false, "CUDADeviceAllocator requires CUDA. ", CUDA_HELP);
+  }
+
+  virtual bool compiledWithCuDNN() const {
+    return false;
+  }
+
+  virtual bool compiledWithMIOpen() const {
+    return false;
+  }
+
+  virtual bool supportsDilatedConvolutionWithCuDNN() const {
+    return false;
+  }
+
+  virtual bool supportsDepthwiseConvolutionWithCuDNN() const {
+    return false;
+  }
+
+  virtual bool supportsBFloat16ConvolutionWithCuDNNv8() const {
+    return false;
+  }
+
+  virtual long versionCuDNN() const {
+    TORCH_CHECK(false, "Cannot query cuDNN version without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual long versionCUDART() const {
+    TORCH_CHECK(false, "Cannot query CUDART version without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual std::string showConfig() const {
+    TORCH_CHECK(false, "Cannot query detailed CUDA version without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual double batchnormMinEpsilonCuDNN() const {
+    TORCH_CHECK(false,
+        "Cannot query batchnormMinEpsilonCuDNN() without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual int64_t cuFFTGetPlanCacheMaxSize(DeviceIndex /*device_index*/) const {
+    TORCH_CHECK(false, "Cannot access cuFFT plan cache without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual void cuFFTSetPlanCacheMaxSize(DeviceIndex /*device_index*/, int64_t /*max_size*/) const {
+    TORCH_CHECK(false, "Cannot access cuFFT plan cache without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual int64_t cuFFTGetPlanCacheSize(DeviceIndex /*device_index*/) const {
+    TORCH_CHECK(false, "Cannot access cuFFT plan cache without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual void cuFFTClearPlanCache(DeviceIndex /*device_index*/) const {
+    TORCH_CHECK(false, "Cannot access cuFFT plan cache without ATen_cuda library. ", CUDA_HELP);
+  }
+
+  virtual int getNumGPUs() const {
+    return 0;
+  }
+
+  virtual void deviceSynchronize(DeviceIndex /*device_index*/) const {
+    TORCH_CHECK(false, "Cannot synchronize CUDA device without ATen_cuda library. ", CUDA_HELP);
+  }
+};
+
+// NB: dummy argument to suppress "ISO C++11 requires at least one argument
+// for the "..." in a variadic macro"
+struct TORCH_API CUDAHooksArgs {};
+
+TORCH_DECLARE_REGISTRY(CUDAHooksRegistry, CUDAHooksInterface, CUDAHooksArgs);
+#define REGISTER_CUDA_HOOKS(clsname) \
+  C10_REGISTER_CLASS(CUDAHooksRegistry, clsname, clsname)
+
+namespace detail {
+TORCH_API const CUDAHooksInterface& getCUDAHooks();
+} // namespace detail
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/detail/MPSHooksInterface.h

@@ -0,0 +1,106 @@
+//  Copyright © 2022 Apple Inc.
+
+#pragma once
+
+#include <c10/core/Allocator.h>
+#include <ATen/core/Generator.h>
+#include <ATen/detail/AcceleratorHooksInterface.h>
+#include <c10/util/Exception.h>
+#include <c10/util/Registry.h>
+
+#include <cstddef>
+
+namespace at {
+
+struct TORCH_API MPSHooksInterface : AcceleratorHooksInterface {
+  // this fails the implementation if MPSHooks functions are called, but
+  // MPS backend is not present.
+  #define FAIL_MPSHOOKS_FUNC(func) \
+    TORCH_CHECK(false, "Cannot execute ", func, "() without MPS backend.");
+
+  virtual ~MPSHooksInterface() override = default;
+
+  // Initialize the MPS library state
+  virtual void initMPS() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual bool hasMPS() const {
+    return false;
+  }
+  virtual bool isOnMacOSorNewer(unsigned major = 13, unsigned minor = 0) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual const Generator& getDefaultMPSGenerator() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual Allocator* getMPSDeviceAllocator() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void deviceSynchronize() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void commitStream() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void* getCommandBuffer() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void* getDispatchQueue() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void emptyCache() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual size_t getCurrentAllocatedMemory() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual size_t getDriverAllocatedMemory() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void setMemoryFraction(double /*ratio*/) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void profilerStartTrace(const std::string& mode, bool waitUntilCompleted) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void profilerStopTrace() const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual uint32_t acquireEvent(bool enable_timing) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void releaseEvent(uint32_t event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void recordEvent(uint32_t event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void waitForEvent(uint32_t event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual void synchronizeEvent(uint32_t event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual bool queryEvent(uint32_t event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual double elapsedTimeOfEvents(uint32_t start_event_id, uint32_t end_event_id) const {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  virtual bool hasPrimaryContext(DeviceIndex device_index) const override {
+    FAIL_MPSHOOKS_FUNC(__func__);
+  }
+  #undef FAIL_MPSHOOKS_FUNC
+};
+
+struct TORCH_API MPSHooksArgs {};
+
+TORCH_DECLARE_REGISTRY(MPSHooksRegistry, MPSHooksInterface, MPSHooksArgs);
+#define REGISTER_MPS_HOOKS(clsname) \
+  C10_REGISTER_CLASS(MPSHooksRegistry, clsname, clsname)
+
+namespace detail {
+TORCH_API const MPSHooksInterface& getMPSHooks();
+
+} // namespace detail
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/detail/PrivateUse1HooksInterface.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <ATen/core/Generator.h>
+#include <ATen/detail/AcceleratorHooksInterface.h>
+#include <c10/core/Allocator.h>
+#include <c10/core/Device.h>
+#include <c10/core/Storage.h>
+#include <c10/util/Exception.h>
+namespace at {
+
+struct TORCH_API PrivateUse1HooksInterface : AcceleratorHooksInterface {
+  virtual ~PrivateUse1HooksInterface() override = default;
+  virtual const at::Generator& getDefaultGenerator(
+      c10::DeviceIndex device_index) {
+    TORCH_CHECK_NOT_IMPLEMENTED(
+        false,
+        "You should register `PrivateUse1HooksInterface` for PrivateUse1 before call `getDefaultGenerator`.");
+  }
+
+  virtual at::Device getDeviceFromPtr(void* data) const {
+    TORCH_CHECK_NOT_IMPLEMENTED(
+        false,
+        "You should register `PrivateUse1HooksInterface` for PrivateUse1 before call `getDeviceFromPtr`.");
+  }
+
+  virtual Allocator* getPinnedMemoryAllocator() const {
+    TORCH_CHECK(
+        false,
+        "You should register `PrivateUse1HooksInterface` for PrivateUse1 before call `getPinnedMemoryAllocator`.");
+  }
+
+  virtual bool hasPrimaryContext(DeviceIndex device_index) const override {
+    TORCH_CHECK_NOT_IMPLEMENTED(
+        false,
+        "You should register `PrivateUse1HooksInterface` for PrivateUse1 before call `hasPrimaryContext`.");
+  }
+
+  virtual void initPrivateUse1() const {}
+  virtual void resizePrivateUse1Bytes(const c10::Storage &storage, size_t newsize) const {
+    TORCH_CHECK_NOT_IMPLEMENTED(
+        false,
+        "You should register `PrivateUse1HooksInterface` for PrivateUse1 before call `resizePrivateUse1Bytes`.");
+  }
+};
+
+struct TORCH_API PrivateUse1HooksArgs {};
+
+TORCH_API void RegisterPrivateUse1HooksInterface(
+    at::PrivateUse1HooksInterface* hook_);
+
+TORCH_API at::PrivateUse1HooksInterface* GetPrivateUse1HooksInterface();
+
+TORCH_API bool isPrivateUse1HooksRegistered();
+
+namespace detail {
+
+TORCH_API const at::PrivateUse1HooksInterface& getPrivateUse1Hooks();
+
+} // namespace detail
+
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/detail/XPUHooksInterface.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <c10/core/Device.h>
+#include <c10/util/Exception.h>
+#include <ATen/core/Generator.h>
+#include <c10/util/Registry.h>
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+
+namespace at {
+
+constexpr const char* XPU_HELP =
+    "The XPU backend requires Intel Extension for Pytorch;"
+    "this error has occurred because you are trying "
+    "to use some XPU's functionality, but the Intel Extension for Pytorch has not been "
+    "loaded for some reason. The Intel Extension for Pytorch MUST "
+    "be loaded, EVEN IF you don't directly use any symbols from that!";
+
+struct TORCH_API XPUHooksInterface {
+  virtual ~XPUHooksInterface() {}
+
+  virtual void initXPU() const {
+    TORCH_CHECK(
+        false,
+        "Cannot initialize XPU without Intel Extension for Pytorch.",
+        XPU_HELP);
+  }
+
+  virtual bool hasXPU() const {
+    return false;
+  }
+
+  virtual std::string showConfig() const {
+    TORCH_CHECK(
+        false,
+        "Cannot query detailed XPU version without Intel Extension for Pytorch. ",
+        XPU_HELP);
+  }
+
+  virtual int32_t getGlobalIdxFromDevice(const Device& device) const {
+    TORCH_CHECK(false, "Cannot get XPU global device index without ATen_xpu library.");
+  }
+
+  virtual Generator getXPUGenerator(C10_UNUSED DeviceIndex device_index = -1) const {
+    TORCH_CHECK(false, "Cannot get XPU generator without Intel Extension for Pytorch. ", XPU_HELP);
+  }
+
+  virtual const Generator& getDefaultXPUGenerator(C10_UNUSED DeviceIndex device_index = -1) const {
+    TORCH_CHECK(false, "Cannot get default XPU generator without Intel Extension for Pytorch. ", XPU_HELP);
+  }
+
+  virtual DeviceIndex getNumGPUs() const {
+    return 0;
+  }
+
+  virtual DeviceIndex current_device() const {
+    TORCH_CHECK(false, "Cannot get current device on XPU without ATen_xpu library.");
+  }
+
+  virtual Device getDeviceFromPtr(void* /*data*/) const {
+    TORCH_CHECK(false, "Cannot get device of pointer on XPU without ATen_xpu library.");
+  }
+
+  virtual void deviceSynchronize(DeviceIndex /*device_index*/) const {
+    TORCH_CHECK(false, "Cannot synchronize XPU device without ATen_xpu library.");
+  }
+};
+
+struct TORCH_API XPUHooksArgs {};
+
+C10_DECLARE_REGISTRY(XPUHooksRegistry, XPUHooksInterface, XPUHooksArgs);
+#define REGISTER_XPU_HOOKS(clsname) \
+  C10_REGISTER_CLASS(XPUHooksRegistry, clsname, clsname)
+
+namespace detail {
+TORCH_API const XPUHooksInterface& getXPUHooks();
+} // namespace detail
+} // namespace at

moondream/lib/python3.10/site-packages/torch/include/ATen/functorch/ADInterpreters.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <ATen/functorch/Interpreter.h>
+
+namespace at::functorch {
+
+// These are the interpreters for our AD transforms
+// (grad, vjp and jvp).
+// See NOTE: [functorch interpreter stack] for more details.
+
+struct TORCH_API GradInterpreterPtr {
+  explicit GradInterpreterPtr(const Interpreter* base): base_(base) { TORCH_INTERNAL_ASSERT(base->key() == TransformType::Grad); }
+  TransformType key() const { return base_->key(); }
+  int64_t level() const { return base_->level(); }
+  void processImpl(const c10::OperatorHandle& op, torch::jit::Stack* stack);
+  void sendToNextInterpreterImpl(const c10::OperatorHandle& op, torch::jit::Stack* stack, bool grad_special_case);
+  bool prevGradMode() const {
+    return std::get<GradInterpreterMeta>(base_->meta()).prevGradMode_;
+  }
+  Tensor lift(const Tensor& tensor) const;
+ private:
+  const Interpreter* base_;
+};
+
+struct TORCH_API JvpInterpreterPtr {
+  explicit JvpInterpreterPtr(const Interpreter* base): base_(base) { TORCH_INTERNAL_ASSERT(base->key() == TransformType::Jvp); }
+  TransformType key() const { return base_->key(); }
+  int64_t level() const { return base_->level(); }
+  void processImpl(const c10::OperatorHandle& op, torch::jit::Stack* stack);
+  void sendToNextInterpreterImpl(const c10::OperatorHandle& op, torch::jit::Stack* stack, bool grad_special_case);
+  bool prevFwdGradMode() const {
+    return std::get<JvpInterpreterMeta>(base_->meta()).prevFwdGradMode_;
+  }
+  Tensor lift(const Tensor& tensor) const;
+ private:
+  const Interpreter* base_;
+};
+
+} // namespace at::functorch

moondream/lib/python3.10/site-packages/torch/include/ATen/functorch/BatchRulesHelper.h

@@ -0,0 +1,475 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree.
+#pragma once
+
+#include <c10/util/TypeList.h>
+
+#include <ATen/ATen.h>
+#include <ATen/Operators.h>
+
+#include <ATen/functorch/DynamicLayer.h>
+#include <ATen/functorch/TensorWrapper.h>
+#include <ATen/functorch/BatchingMetaprogramming.h>
+#include <ATen/functorch/LegacyVmapTransforms.h>
+#include <ATen/functorch/BatchedFallback.h>
+#include <ATen/functorch/PlumbingHelper.h>
+#include <ATen/core/dispatch/Dispatcher.h>
+#include <ATen/VmapGeneratedPlumbing.h>
+
+#include <utility>
+
+// This file contains helper functions for batching rules.
+
+namespace at::functorch {
+
+TORCH_API Tensor reshape_dim_into(int64_t src, int64_t dst, const Tensor& x);
+TORCH_API Tensor reshape_dim_outof(int64_t src, int64_t size1, const Tensor& x);
+
+TORCH_API Tensor reshape_dim_outof_symint(int64_t src, c10::SymInt size1, const Tensor& x);
+
+Tensor moveBatchDimToFront(const Tensor& tensor, optional<int64_t> maybe_batch_dim);
+int64_t rankWithoutBatchDim(const Tensor& tensor, optional<int64_t> maybe_batch_dim);
+int64_t numelWithoutBatchDim(const Tensor& tensor, optional<int64_t> maybe_batch_dim);
+optional<int64_t> valIfNonempty(optional<int64_t> maybe_empty, int64_t new_val);
+int64_t getPhysicalDim(const Tensor& tensor, bool has_batch_dim, int64_t logical_dim);
+VmapDimVector getPhysicalDims(const Tensor& tensor, bool has_batch_dim, IntArrayRef logical_dims);
+
+void vmapIncompatibleInplaceError(const char* schema_name);
+
+Tensor maybePadToLogicalRank(const Tensor& tensor, optional<int64_t> has_bdim, int64_t logical_rank);
+
+void check_randomness(RandomnessType randomness);
+void check_randomness(RandomnessType randomness, bool any_tensor_bdim);
+
+inline Tensor ensure_has_bdim(const Tensor& tensor, bool has_bdim, c10::SymInt batch_size) {
+  if (has_bdim) {
+    return tensor;
+  }
+  const auto sizes = tensor.sym_sizes();
+  SymDimVector expanded_shape;
+  expanded_shape.reserve(sizes.size());
+  expanded_shape.emplace_back(std::move(batch_size));
+  expanded_shape.insert(expanded_shape.end(), sizes.begin(), sizes.end());
+  return tensor.expand_symint(expanded_shape);
+}
+
+#define VMAP_SUPPORT(op, batch_rule) \
+  m.impl(#op, op ## _generated_plumbing<decltype(&batch_rule), &batch_rule>);
+
+#define VMAP_SUPPORT2(op, overload, batch_rule) \
+  m.impl(#op "." #overload, op ## _ ## overload ## _generated_plumbing<decltype(&batch_rule), &batch_rule>);
+
+#define OP_DECOMPOSE(op)  m.impl(#op, static_cast<decltype(&ATEN_FN(op))>(native::op));
+#define OP_DECOMPOSE2(op, overload)  m.impl(#op"."#overload, static_cast<decltype(&ATEN_FN2(op, overload))>(native::op));
+
+// DO NOT USE ME DIRECTLY! Use BASIC_UNARY_BATCH_RULE to save yourself some pain
+template <typename A, A a, typename C>
+struct BasicUnaryBatchRuleHelper;
+
+template <typename F, F Func, typename A, typename... T>
+struct BasicUnaryBatchRuleHelper<F, Func, c10::guts::typelist::typelist<A, T...>> {
+  static std::tuple<Tensor,optional<int64_t>> apply(
+      const Tensor& tensor,
+      optional<int64_t> batch_dim,
+      T... extra_args) {
+    return std::make_tuple(Func(tensor, std::forward<T>(extra_args)...), batch_dim);
+  }
+};
+
+// USAGE: BASIC_UNARY_BATCH_RULE(at::sin)
+// INCORRECT USAGE: BASIC_UNARY_BATCH_RULE(&at::sin)
+// It is important that this macro is not passed a function pointer!!
+#define BASIC_UNARY_BATCH_RULE(fn) SINGLE_ARG(\
+    BasicUnaryBatchRuleHelper<\
+      decltype(&fn),\
+      &fn,\
+      c10::guts::function_traits<decltype(fn)>::parameter_types>::apply)
+
+#define UNARY_POINTWISE(op) \
+  VMAP_SUPPORT(op, BASIC_UNARY_BATCH_RULE(ATEN_FN(op)));
+
+template <typename A, A a, typename C>
+struct VariadicBdimsBatchRuleHelper;
+
+template <typename F, F Func, typename A, typename... T>
+struct VariadicBdimsBatchRuleHelper<F, Func, c10::guts::typelist::typelist<A, T...>> {
+  static std::tuple<Tensor,optional<int64_t>> apply(
+      const Tensor& tensor,
+      optional<int64_t> batch_dim,
+      T... extra_args) {
+    auto tensor_ = moveBatchDimToFront(tensor, batch_dim);
+    return std::make_tuple(Func(tensor_, std::forward<T>(extra_args)...), 0);
+  }
+};
+
+// USAGE: VARIADIC_BDIMS_BATCH_RULE(at::cholesky_inverse)
+// INCORRECT USAGE: VARIADIC_BDIMS_BATCH_RULE(&at::cholesky_inverse)
+// It is important that this macro is not passed a function pointer!!
+#define VARIADIC_BDIMS_BATCH_RULE(fn) SINGLE_ARG(\
+    VariadicBdimsBatchRuleHelper<\
+      decltype(&fn),\
+      &fn,\
+      c10::guts::function_traits<decltype(fn)>::parameter_types>::apply)
+
+#define VARIADIC_BDIMS(op) \
+  VMAP_SUPPORT(op, VARIADIC_BDIMS_BATCH_RULE(ATEN_FN(op)));
+
+#define VARIADIC_BDIMS2(op, overload) \
+  VMAP_SUPPORT2(op, overload, VARIADIC_BDIMS_BATCH_RULE(ATEN_FN2(op, overload)));
+
+template<class F, F Func>
+void boxed_tensor_inputs_batch_rule(const c10::OperatorHandle& op, torch::jit::Stack* stack) {
+  const auto& schema = op.schema();
+  const auto num_returns = schema.returns().size();
+  const auto num_arguments = schema.arguments().size();
+
+  c10::impl::ExcludeDispatchKeyGuard guard(DispatchKey::FuncTorchBatched);
+  auto maybe_layer = maybeCurrentDynamicLayer();
+  vmap_check_escaped(maybe_layer, "boxed_tensor_inputs_batch_rule");
+
+  int64_t cur_level = maybe_layer->layerId();
+
+  auto orig_arguments = torch::jit::last(*stack, num_arguments);
+  if (std::none_of(orig_arguments.begin(), orig_arguments.end(), ivalueParticipatesInCurrentLevel)) {
+    op.callBoxed(stack);
+    return;
+  }
+
+  auto arguments = torch::jit::pop(*stack, num_arguments);
+  std::vector<std::pair<Tensor, optional<int64_t>>> tensor_inputs;
+  std::vector<int64_t> tensor_pos;
+  for (const auto idx : c10::irange(0, num_arguments)) {
+    const auto& ivalue = arguments[idx];
+    if (ivalue.isTensor()) {
+      auto [tensor_value, tensor_bdim] = unwrapTensorAtLevel(ivalue.toTensor(), cur_level);
+      tensor_inputs.emplace_back(tensor_value, tensor_bdim);
+      tensor_pos.push_back(idx);
+    }
+  }
+  Func(tensor_inputs);
+
+  size_t tensor_idx = 0;
+  TORCH_INTERNAL_ASSERT(!tensor_pos.empty());
+  for (const auto arg_idx : c10::irange(0, num_arguments)) {
+    if (tensor_idx >= tensor_pos.size() || (int64_t)arg_idx != tensor_pos[tensor_idx]) {
+      torch::jit::push(stack, arguments[arg_idx]);
+    } else {
+      TORCH_INTERNAL_ASSERT(tensor_idx < tensor_inputs.size());
+      torch::jit::push(stack, tensor_inputs[tensor_idx].first);
+      tensor_idx++;
+    }
+  }
+
+  op.callBoxed(stack);
+  const auto returns = torch::jit::pop(*stack, num_returns);
+  for (const auto& ret : returns) {
+    if (ret.isTensor()) {
+      torch::jit::push(stack, makeBatched(ret.toTensor(), 0, cur_level));
+    } else {
+      TORCH_INTERNAL_ASSERT(false, "This boxed batching rule does not currently support ops that return non-tensor values");
+    }
+  }
+}
+
+inline void handle_pointwise_ops(std::vector<std::pair<Tensor, optional<int64_t>>> &tensor_inputs) {
+  int64_t out_logical_rank = 0;
+  for (auto& tensor_input : tensor_inputs) {
+    int64_t cur_logical_rank = rankWithoutBatchDim(tensor_input.first, tensor_input.second);
+    out_logical_rank = std::max(out_logical_rank, cur_logical_rank);
+  }
+  for (auto& tensor_input: tensor_inputs) {
+    tensor_input.first = moveBatchDimToFront(tensor_input.first, tensor_input.second);
+    tensor_input.first = maybePadToLogicalRank(tensor_input.first, tensor_input.second, out_logical_rank);
+  }
+}
+
+#define POINTWISE_BOXED(op) \
+  m.impl(#op, torch::CppFunction::makeFromBoxedFunction<boxed_tensor_inputs_batch_rule<decltype(&handle_pointwise_ops), &handle_pointwise_ops>>());
+
+#define POINTWISE_BOXED2(op, overload) \
+  m.impl(#op "." #overload, torch::CppFunction::makeFromBoxedFunction<boxed_tensor_inputs_batch_rule<decltype(&handle_pointwise_ops), &handle_pointwise_ops>>());
+
+inline void handle_variadic_bdims(std::vector<std::pair<Tensor, optional<int64_t>>> &tensor_inputs) {
+  for (auto & tensor_input : tensor_inputs) {
+    tensor_input.first = moveBatchDimToFront(tensor_input.first, tensor_input.second);
+  }
+}
+
+#define VARIADIC_BDIMS_BOXED(op) \
+  m.impl(#op, torch::CppFunction::makeFromBoxedFunction<boxed_tensor_inputs_batch_rule<decltype(&handle_variadic_bdims), &handle_variadic_bdims>>());
+
+using UnpackedBatchedTensor = std::tuple<Tensor,optional<int64_t>>;
+
+inline void find_and_unpack_tensors(
+    const torch::jit::Stack* stack,
+    int64_t num_args,
+    int64_t cur_level,
+    SmallVector<UnpackedBatchedTensor, 5>* tensors,
+    SmallVector<int64_t, 5>* tensors_pos,
+    int64_t* batch_size) {
+
+  int64_t computed_batch_size = -1;
+  int64_t args_begin = stack->size() - num_args;
+
+  for (const auto idx : c10::irange(0, num_args)) {
+    const auto& ivalue = (*stack)[args_begin + idx];
+    if (!ivalue.isTensor()) {
+      continue;
+    }
+    auto unpacked = unwrapTensorAtLevel(ivalue.toTensor(), cur_level);
+    const auto& tensor_value = std::get<0>(unpacked);
+    const auto tensor_bdim = std::get<1>(unpacked);
+    if (tensor_bdim.has_value()) {
+      auto candidate_batch_size = tensor_value.size(*tensor_bdim);
+      if (computed_batch_size == -1) {
+        computed_batch_size = candidate_batch_size;
+      }
+      TORCH_INTERNAL_ASSERT(candidate_batch_size == computed_batch_size);
+    }
+
+    tensors->push_back(std::move(unpacked));
+    tensors_pos->push_back(idx);
+  }
+  TORCH_INTERNAL_ASSERT(computed_batch_size > -1);
+  *batch_size = computed_batch_size;
+}
+
+inline void boxed_existing_bdim_all_batch_rule(
+    const c10::OperatorHandle& op, torch::jit::Stack* stack) {
+  const auto& schema = op.schema();
+  const auto num_returns = schema.returns().size();
+  const auto num_arguments = schema.arguments().size();
+
+  c10::impl::ExcludeDispatchKeyGuard guard(DispatchKey::FuncTorchBatched);
+  auto maybe_layer = maybeCurrentDynamicLayer();
+  vmap_check_escaped(maybe_layer, "boxed_existing_bdim_all_batch_rule");
+  int64_t cur_level = maybe_layer->layerId();
+
+  const auto arguments = torch::jit::last(stack, num_arguments);
+  if (std::none_of(arguments.begin(), arguments.end(), ivalueParticipatesInCurrentLevel)) {
+    op.callBoxed(stack);
+    return;
+  }
+
+  int64_t args_begin = stack->size() - num_arguments;
+  SmallVector<UnpackedBatchedTensor, 5> tensor_inputs;
+  SmallVector<int64_t, 5> tensor_pos;
+  int64_t batch_size;
+
+  find_and_unpack_tensors(
+      stack, num_arguments, cur_level,
+      &tensor_inputs, &tensor_pos, &batch_size);
+
+  // for each tensor, ensure it has a bdim and reshape it.
+  for (const auto tensor_idx : c10::irange(0, tensor_inputs.size())) {
+    const auto& value = std::get<0>(tensor_inputs[tensor_idx]);
+    auto bdim = std::get<1>(tensor_inputs[tensor_idx]);
+    auto value_ = ensure_has_bdim(value, bdim.has_value(), batch_size);
+    if (!bdim.has_value()) {
+      bdim = 0;
+    }
+    (*stack)[args_begin + tensor_pos[tensor_idx]] = reshape_dim_into(*bdim, 0, value_);
+  }
+
+  op.callBoxed(stack);
+
+  for (const auto idx : c10::irange(args_begin, args_begin + num_returns)) {
+    const auto& ret = (*stack)[idx];
+    TORCH_INTERNAL_ASSERT(ret.isTensor(),
+        "This boxed batching rule does not currently support ops that return non-tensor values");
+    (*stack)[idx] = makeBatched(reshape_dim_outof(0, batch_size, ret.toTensor()), 0, cur_level);
+  }
+}
+
+// Use when all tensors arguments accept one (normal) batch dim.
+// This batching rule expands the batch dim on all Tensors, reshapes it into
+// dim 0, calls the op, and then reshapes the batch dim out of dim 0.
+// This is not the most efficient thing; if there are alternatives, plese try
+// to use them. Use this only as a last resort.
+#define EXISTING_BDIM_ALL_BOXED(op) \
+  m.impl(#op, torch::CppFunction::makeFromBoxedFunction<boxed_existing_bdim_all_batch_rule>());
+
+template <int64_t feature_rank, int64_t contig_tensor_index=-1>
+inline void boxed_all_tensors_have_optional_bdim(
+    const c10::OperatorHandle& op, torch::jit::Stack* stack) {
+  const auto& schema = op.schema();
+  const auto num_returns = schema.returns().size();
+  const auto num_arguments = schema.arguments().size();
+
+  c10::impl::ExcludeDispatchKeyGuard guard(DispatchKey::FuncTorchBatched);
+  auto maybe_layer = maybeCurrentDynamicLayer();
+  vmap_check_escaped(maybe_layer, "boxed_all_tensors_have_optional_bdim");
+  int64_t cur_level = maybe_layer->layerId();
+
+  const auto arguments = torch::jit::last(stack, num_arguments);
+  if (std::none_of(arguments.begin(), arguments.end(), ivalueParticipatesInCurrentLevel)) {
+    op.callBoxed(stack);
+    return;
+  }
+
+  int64_t args_begin = stack->size() - num_arguments;
+  SmallVector<UnpackedBatchedTensor, 5> tensor_inputs;
+  SmallVector<int64_t, 5> tensor_pos;
+  int64_t batch_size;
+
+  find_and_unpack_tensors(
+      stack, num_arguments, cur_level,
+      &tensor_inputs, &tensor_pos, &batch_size);
+
+  optional<bool> is_no_batch_dim_case;
+
+  for (const auto tensor_idx : c10::irange(0, tensor_inputs.size())) {
+    const auto& value = std::get<0>(tensor_inputs[tensor_idx]);
+    auto bdim = std::get<1>(tensor_inputs[tensor_idx]);
+    const auto logical_rank = rankWithoutBatchDim(value, bdim);
+
+    if (!is_no_batch_dim_case.has_value()) {
+      is_no_batch_dim_case = (logical_rank == feature_rank);
+    }
+    auto value_ = ensure_has_bdim(value, bdim.has_value(), batch_size);
+    if (!bdim.has_value()) {
+      bdim = 0;
+    }
+    if (*is_no_batch_dim_case) {
+      TORCH_INTERNAL_ASSERT(logical_rank == feature_rank);
+      value_ = moveBatchDimToFront(value_, bdim);
+      if (tensor_idx == contig_tensor_index) {
+        value_ = value_.contiguous();
+      }
+      (*stack)[args_begin + tensor_pos[tensor_idx]] = std::move(value_);
+      continue;
+    }
+    TORCH_INTERNAL_ASSERT(logical_rank == feature_rank + 1);
+    value_ = reshape_dim_into(*bdim, 0, value_);
+    if (tensor_idx == contig_tensor_index) {
+      value_ = value_.contiguous();
+    }
+    (*stack)[args_begin + tensor_pos[tensor_idx]] = std::move(value_);
+  }
+
+  op.callBoxed(stack);
+
+  for (const auto idx : c10::irange(args_begin, args_begin + num_returns)) {
+    const auto& ret = (*stack)[idx];
+    TORCH_INTERNAL_ASSERT(ret.isTensor(),
+        "This boxed batching rule does not currently support ops that return non-tensor values");
+    if (*is_no_batch_dim_case) {
+      (*stack)[idx] = makeBatched(ret.toTensor(), 0, cur_level);
+    } else {
+      (*stack)[idx] = makeBatched(reshape_dim_outof(0, batch_size, ret.toTensor()), 0, cur_level);
+    }
+  }
+}
+
+// Useful for many NN operators.
+// The operator must satisfy the following:
+// - All arguments must accept an optional batch dim.
+// - All arguments must be the same rank
+#define ALL_TENSORS_HAVE_OPTIONAL_BDIM_BOXED(feature_rank, op) \
+  m.impl(#op, torch::CppFunction::makeFromBoxedFunction<boxed_all_tensors_have_optional_bdim<feature_rank>>());
+
+#define ALL_TENSORS_HAVE_OPTIONAL_BDIM_BOXED_CONTIG1(feature_rank, op, contig_tensor_index) \
+  m.impl(#op, \
+         torch::CppFunction::makeFromBoxedFunction<\
+             boxed_all_tensors_have_optional_bdim<\
+                 feature_rank, \
+                 contig_tensor_index>\
+             >());
+
+template <typename A, A a, typename C>
+struct ExistingBdimBatchRuleHelper;
+
+template <typename F, F Func, typename A, typename... T>
+struct ExistingBdimBatchRuleHelper<F, Func, c10::guts::typelist::typelist<A, T...>> {
+  static std::tuple<Tensor,optional<int64_t>> apply(
+      const Tensor& self,
+      optional<int64_t> self_bdim,
+      T... extra_args) {
+    auto self_ = reshape_dim_into(*self_bdim, 0, self);
+    auto out = Func(self_, std::forward<T>(extra_args)...);
+    return std::make_tuple(reshape_dim_outof_symint(0, self.sym_sizes()[*self_bdim], out), 0);
+  }
+};
+
+// USAGE: EXISTING_BDIM_BATCH_RULE(at::cholesky_inverse)
+// INCORRECT USAGE: EXISTING_BDIM_BATCH_RULE(&at::cholesky_inverse)
+// It is important that this macro is not passed a function pointer!!
+#define EXISTING_BDIM_BATCH_RULE(fn) SINGLE_ARG(\
+    ExistingBdimBatchRuleHelper<\
+      decltype(&fn),\
+      &fn,\
+      c10::guts::function_traits<decltype(fn)>::parameter_types>::apply)
+
+
+#define EXISTING_BDIM(op) \
+  VMAP_SUPPORT(op, EXISTING_BDIM_BATCH_RULE(ATEN_FN(op)));
+
+#define EXISTING_BDIM2(op, overload) \
+  VMAP_SUPPORT2(op, overload, EXISTING_BDIM_BATCH_RULE(ATEN_FN2(op, overload)));
+
+#define INVOKE(object,ptrToMember)  ((object).*(ptrToMember))
+
+
+template <typename F, F Method, typename... ExtraArgs>
+Tensor& unary_inplace_batch_rule(Tensor& self, optional<int64_t>, ExtraArgs... extra_args) {
+  INVOKE(self, Method)(std::forward<ExtraArgs>(extra_args)...);
+  return self;
+}
+
+inline int64_t get_bdim_size4(
+    const Tensor& a_value, optional<int64_t> a_bdim,
+    const Tensor& b_value, optional<int64_t> b_bdim,
+    const Tensor& c_value, optional<int64_t> c_bdim,
+    const Tensor& d_value, optional<int64_t> d_bdim) {
+  if (a_bdim)
+    return a_value.size(*a_bdim);
+  if (b_bdim)
+    return b_value.size(*b_bdim);
+  if (c_bdim)
+    return c_value.size(*c_bdim);
+  if (d_bdim)
+    return d_value.size(*d_bdim);
+  TORCH_INTERNAL_ASSERT(false);
+}
+
+inline int64_t get_bdim_size3(
+    const Tensor& a_value, optional<int64_t> a_bdim,
+    const Tensor& b_value, optional<int64_t> b_bdim,
+    const Tensor& c_value, optional<int64_t> c_bdim) {
+  if (a_bdim)
+    return a_value.size(*a_bdim);
+  if (b_bdim)
+    return b_value.size(*b_bdim);
+  if (c_bdim)
+    return c_value.size(*c_bdim);
+  TORCH_INTERNAL_ASSERT(false);
+}
+
+inline int64_t get_bdim_size2(
+    const Tensor& a_value, optional<int64_t> a_bdim,
+    const Tensor& b_value, optional<int64_t> b_bdim) {
+  if (a_bdim)
+    return a_value.size(*a_bdim);
+  if (b_bdim)
+    return b_value.size(*b_bdim);
+  TORCH_INTERNAL_ASSERT(false);
+}
+
+// [start, start + 1, ..., stop - 1]
+inline VmapDimVector range(int64_t start, int64_t stop) {
+  TORCH_INTERNAL_ASSERT(stop >= start);
+  VmapDimVector dims;
+  dims.reserve(stop - start);
+  for (int64_t i = start; i < stop; i++) {
+    dims.emplace_back(i);
+  }
+  return dims;
+}
+std::tuple<Tensor, Tensor> _binary_pointwise_helper(
+    const Tensor& tensor, optional<int64_t> tensor_batch_dim, const Tensor& other, optional<int64_t> other_batch_dim,
+    bool do_type_promotion=true);
+
+} // namespace at::functorch