Add files using upload-large-folder tool

.gitattributes

@@ -1748,3 +1748,7 @@ infer_4_30_0/lib/python3.10/site-packages/transformers/generation/__pycache__/lo
 infer_4_30_0/lib/python3.10/site-packages/transformers/generation/__pycache__/tf_utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/transformers/models/seamless_m4t/__pycache__/modeling_seamless_m4t.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/transformers/models/perceiver/__pycache__/modeling_perceiver.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/safetensors/_safetensors_rust.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/transformers/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/transformers/models/seamless_m4t_v2/__pycache__/modeling_seamless_m4t_v2.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_tf449/lib/python3.10/site-packages/triton/backends/nvidia/bin/nvdisasm filter=lfs diff=lfs merge=lfs -text

evalkit_tf449/lib/python3.10/site-packages/triton/backends/nvidia/bin/nvdisasm

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

infer_4_30_0/lib/python3.10/site-packages/PyYAML-6.0.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_30_0/lib/python3.10/site-packages/aiofiles/threadpool/__init__.py

@@ -0,0 +1,139 @@
+"""Handle files using a thread pool executor."""
+import asyncio
+import sys
+from functools import partial, singledispatch
+from io import (
+    BufferedIOBase,
+    BufferedRandom,
+    BufferedReader,
+    BufferedWriter,
+    FileIO,
+    TextIOBase,
+)
+
+from ..base import AiofilesContextManager
+from .binary import (
+    AsyncBufferedIOBase,
+    AsyncBufferedReader,
+    AsyncFileIO,
+    AsyncIndirectBufferedIOBase,
+)
+from .text import AsyncTextIndirectIOWrapper, AsyncTextIOWrapper
+
+sync_open = open
+
+__all__ = (
+    "open",
+    "stdin",
+    "stdout",
+    "stderr",
+    "stdin_bytes",
+    "stdout_bytes",
+    "stderr_bytes",
+)
+
+
+def open(
+    file,
+    mode="r",
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None,
+    *,
+    loop=None,
+    executor=None,
+):
+    return AiofilesContextManager(
+        _open(
+            file,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            closefd=closefd,
+            opener=opener,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+async def _open(
+    file,
+    mode="r",
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None,
+    *,
+    loop=None,
+    executor=None,
+):
+    """Open an asyncio file."""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+    cb = partial(
+        sync_open,
+        file,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        errors=errors,
+        newline=newline,
+        closefd=closefd,
+        opener=opener,
+    )
+    f = await loop.run_in_executor(executor, cb)
+
+    return wrap(f, loop=loop, executor=executor)
+
+
+@singledispatch
+def wrap(file, *, loop=None, executor=None):
+    raise TypeError("Unsupported io type: {}.".format(file))
+
+
+@wrap.register(TextIOBase)
+def _(file, *, loop=None, executor=None):
+    return AsyncTextIOWrapper(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedWriter)
+@wrap.register(BufferedIOBase)
+def _(file, *, loop=None, executor=None):
+    return AsyncBufferedIOBase(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedReader)
+@wrap.register(BufferedRandom)
+def _(file, *, loop=None, executor=None):
+    return AsyncBufferedReader(file, loop=loop, executor=executor)
+
+
+@wrap.register(FileIO)
+def _(file, *, loop=None, executor=None):
+    return AsyncFileIO(file, loop=loop, executor=executor)
+
+
+stdin = AsyncTextIndirectIOWrapper("sys.stdin", None, None, indirect=lambda: sys.stdin)
+stdout = AsyncTextIndirectIOWrapper(
+    "sys.stdout", None, None, indirect=lambda: sys.stdout
+)
+stderr = AsyncTextIndirectIOWrapper(
+    "sys.stderr", None, None, indirect=lambda: sys.stderr
+)
+stdin_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stdin.buffer", None, None, indirect=lambda: sys.stdin.buffer
+)
+stdout_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stdout.buffer", None, None, indirect=lambda: sys.stdout.buffer
+)
+stderr_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stderr.buffer", None, None, indirect=lambda: sys.stderr.buffer
+)

infer_4_30_0/lib/python3.10/site-packages/aiofiles/threadpool/binary.py

@@ -0,0 +1,104 @@
+from ..base import AsyncBase, AsyncIndirectBase
+from .utils import delegate_to_executor, proxy_method_directly, proxy_property_directly
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "read1",
+    "readinto",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "writable",
+    "write",
+    "writelines",
+)
+@proxy_method_directly("detach", "fileno", "readable")
+@proxy_property_directly("closed", "raw", "name", "mode")
+class AsyncBufferedIOBase(AsyncBase):
+    """The asyncio executor version of io.BufferedWriter and BufferedIOBase."""
+
+
+@delegate_to_executor("peek")
+class AsyncBufferedReader(AsyncBufferedIOBase):
+    """The asyncio executor version of io.BufferedReader and Random."""
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readall",
+    "readinto",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "writable",
+    "write",
+    "writelines",
+)
+@proxy_method_directly("fileno", "readable")
+@proxy_property_directly("closed", "name", "mode")
+class AsyncFileIO(AsyncBase):
+    """The asyncio executor version of io.FileIO."""
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "read1",
+    "readinto",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "writable",
+    "write",
+    "writelines",
+)
+@proxy_method_directly("detach", "fileno", "readable")
+@proxy_property_directly("closed", "raw", "name", "mode")
+class AsyncIndirectBufferedIOBase(AsyncIndirectBase):
+    """The indirect asyncio executor version of io.BufferedWriter and BufferedIOBase."""
+
+
+@delegate_to_executor("peek")
+class AsyncIndirectBufferedReader(AsyncIndirectBufferedIOBase):
+    """The indirect asyncio executor version of io.BufferedReader and Random."""
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readall",
+    "readinto",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "writable",
+    "write",
+    "writelines",
+)
+@proxy_method_directly("fileno", "readable")
+@proxy_property_directly("closed", "name", "mode")
+class AsyncIndirectFileIO(AsyncIndirectBase):
+    """The indirect asyncio executor version of io.FileIO."""

infer_4_30_0/lib/python3.10/site-packages/aiofiles/threadpool/text.py

@@ -0,0 +1,64 @@
+from ..base import AsyncBase, AsyncIndirectBase
+from .utils import delegate_to_executor, proxy_method_directly, proxy_property_directly
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readable",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "write",
+    "writable",
+    "writelines",
+)
+@proxy_method_directly("detach", "fileno", "readable")
+@proxy_property_directly(
+    "buffer",
+    "closed",
+    "encoding",
+    "errors",
+    "line_buffering",
+    "newlines",
+    "name",
+    "mode",
+)
+class AsyncTextIOWrapper(AsyncBase):
+    """The asyncio executor version of io.TextIOWrapper."""
+
+
+@delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readable",
+    "readline",
+    "readlines",
+    "seek",
+    "seekable",
+    "tell",
+    "truncate",
+    "write",
+    "writable",
+    "writelines",
+)
+@proxy_method_directly("detach", "fileno", "readable")
+@proxy_property_directly(
+    "buffer",
+    "closed",
+    "encoding",
+    "errors",
+    "line_buffering",
+    "newlines",
+    "name",
+    "mode",
+)
+class AsyncTextIndirectIOWrapper(AsyncIndirectBase):
+    """The indirect asyncio executor version of io.TextIOWrapper."""

infer_4_30_0/lib/python3.10/site-packages/lit/LitConfig.py

@@ -0,0 +1,246 @@
+from __future__ import absolute_import
+import inspect
+import os
+import platform
+import sys
+
+import lit.Test
+import lit.formats
+import lit.TestingConfig
+import lit.util
+
+# LitConfig must be a new style class for properties to work
+class LitConfig(object):
+    """LitConfig - Configuration data for a 'lit' test runner instance, shared
+    across all tests.
+
+    The LitConfig object is also used to communicate with client configuration
+    files, it is always passed in as the global variable 'lit' so that
+    configuration files can access common functionality and internal components
+    easily.
+    """
+
+    def __init__(
+        self,
+        progname,
+        path,
+        quiet,
+        useValgrind,
+        valgrindLeakCheck,
+        valgrindArgs,
+        noExecute,
+        debug,
+        isWindows,
+        order,
+        params,
+        config_prefix=None,
+        maxIndividualTestTime=0,
+        parallelism_groups={},
+        per_test_coverage=False,
+        gtest_sharding=True,
+    ):
+        # The name of the test runner.
+        self.progname = progname
+        # The items to add to the PATH environment variable.
+        self.path = [str(p) for p in path]
+        self.quiet = bool(quiet)
+        self.useValgrind = bool(useValgrind)
+        self.valgrindLeakCheck = bool(valgrindLeakCheck)
+        self.valgrindUserArgs = list(valgrindArgs)
+        self.noExecute = noExecute
+        self.debug = debug
+        self.isWindows = bool(isWindows)
+        self.order = order
+        self.params = dict(params)
+        self.bashPath = None
+
+        # Configuration files to look for when discovering test suites.
+        self.config_prefix = config_prefix or "lit"
+        self.suffixes = ["cfg.py", "cfg"]
+        self.config_names = ["%s.%s" % (self.config_prefix, x) for x in self.suffixes]
+        self.site_config_names = [
+            "%s.site.%s" % (self.config_prefix, x) for x in self.suffixes
+        ]
+        self.local_config_names = [
+            "%s.local.%s" % (self.config_prefix, x) for x in self.suffixes
+        ]
+
+        self.numErrors = 0
+        self.numWarnings = 0
+
+        self.valgrindArgs = []
+        if self.useValgrind:
+            self.valgrindArgs = [
+                "valgrind",
+                "-q",
+                "--run-libc-freeres=no",
+                "--tool=memcheck",
+                "--trace-children=yes",
+                "--error-exitcode=123",
+            ]
+            if self.valgrindLeakCheck:
+                self.valgrindArgs.append("--leak-check=full")
+            else:
+                # The default is 'summary'.
+                self.valgrindArgs.append("--leak-check=no")
+            self.valgrindArgs.extend(self.valgrindUserArgs)
+
+        self.maxIndividualTestTime = maxIndividualTestTime
+        self.parallelism_groups = parallelism_groups
+        self.per_test_coverage = per_test_coverage
+        self.gtest_sharding = bool(gtest_sharding)
+
+    @property
+    def maxIndividualTestTime(self):
+        """
+        Interface for getting maximum time to spend executing
+        a single test
+        """
+        return self._maxIndividualTestTime
+
+    @property
+    def maxIndividualTestTimeIsSupported(self):
+        """
+        Returns a tuple (<supported> , <error message>)
+        where
+        `<supported>` is True if setting maxIndividualTestTime is supported
+            on the current host, returns False otherwise.
+        `<error message>` is an empty string if `<supported>` is True,
+            otherwise is contains a string describing why setting
+            maxIndividualTestTime is not supported.
+        """
+        return lit.util.killProcessAndChildrenIsSupported()
+
+    @maxIndividualTestTime.setter
+    def maxIndividualTestTime(self, value):
+        """
+        Interface for setting maximum time to spend executing
+        a single test
+        """
+        if not isinstance(value, int):
+            self.fatal("maxIndividualTestTime must set to a value of type int.")
+        self._maxIndividualTestTime = value
+        if self.maxIndividualTestTime > 0:
+            # The current implementation needs psutil on some platforms to set
+            # a timeout per test. Check it's available.
+            # See lit.util.killProcessAndChildren()
+            supported, errormsg = self.maxIndividualTestTimeIsSupported
+            if not supported:
+                self.fatal("Setting a timeout per test not supported. " + errormsg)
+        elif self.maxIndividualTestTime < 0:
+            self.fatal("The timeout per test must be >= 0 seconds")
+
+    @property
+    def per_test_coverage(self):
+        """
+        Interface for getting the per_test_coverage value
+        """
+        return self._per_test_coverage
+
+    @per_test_coverage.setter
+    def per_test_coverage(self, value):
+        """
+        Interface for setting the per_test_coverage value
+        """
+        if not isinstance(value, bool):
+            self.fatal("per_test_coverage must set to a value of type bool.")
+        self._per_test_coverage = value
+
+    def load_config(self, config, path):
+        """load_config(config, path) - Load a config object from an alternate
+        path."""
+        if self.debug:
+            self.note("load_config from %r" % path)
+        config.load_from_path(path, self)
+        return config
+
+    def getBashPath(self):
+        """getBashPath - Get the path to 'bash'"""
+        if self.bashPath is not None:
+            return self.bashPath
+
+        self.bashPath = lit.util.which("bash", os.pathsep.join(self.path))
+        if self.bashPath is None:
+            self.bashPath = lit.util.which("bash")
+
+        if self.bashPath is None:
+            self.bashPath = ""
+
+        # Check whether the found version of bash is able to cope with paths in
+        # the host path format. If not, don't return it as it can't be used to
+        # run scripts. For example, WSL's bash.exe requires '/mnt/c/foo' rather
+        # than 'C:\\foo' or 'C:/foo'.
+        if self.isWindows and self.bashPath:
+            command = [
+                self.bashPath,
+                "-c",
+                '[[ -f "%s" ]]' % self.bashPath.replace("\\", "\\\\"),
+            ]
+            _, _, exitCode = lit.util.executeCommand(command)
+            if exitCode:
+                self.note(
+                    "bash command failed: %s" % (" ".join('"%s"' % c for c in command))
+                )
+                self.bashPath = ""
+
+        if not self.bashPath:
+            self.warning("Unable to find a usable version of bash.")
+
+        return self.bashPath
+
+    def getToolsPath(self, dir, paths, tools):
+        if dir is not None and os.path.isabs(dir) and os.path.isdir(dir):
+            if not lit.util.checkToolsPath(dir, tools):
+                return None
+        else:
+            dir = lit.util.whichTools(tools, paths)
+
+        # bash
+        self.bashPath = lit.util.which("bash", dir)
+        if self.bashPath is None:
+            self.bashPath = ""
+
+        return dir
+
+    def _write_message(self, kind, message):
+        # Get the file/line where this message was generated.
+        f = inspect.currentframe()
+        # Step out of _write_message, and then out of wrapper.
+        f = f.f_back.f_back
+        file = os.path.abspath(inspect.getsourcefile(f))
+        line = inspect.getlineno(f)
+        sys.stderr.write(
+            "%s: %s:%d: %s: %s\n" % (self.progname, file, line, kind, message)
+        )
+        if self.isWindows:
+            # In a git bash terminal, the writes to sys.stderr aren't visible
+            # on screen immediately. Flush them here to avoid broken/misoredered
+            # output.
+            sys.stderr.flush()
+
+    def substitute(self, string):
+        """substitute - Interpolate params into a string"""
+        try:
+            return string % self.params
+        except KeyError as e:
+            (key,) = e.args
+            self.fatal(
+                "unable to find %r parameter, use '--param=%s=VALUE'" % (key, key)
+            )
+
+    def note(self, message):
+        if not self.quiet:
+            self._write_message("note", message)
+
+    def warning(self, message):
+        if not self.quiet:
+            self._write_message("warning", message)
+        self.numWarnings += 1
+
+    def error(self, message):
+        self._write_message("error", message)
+        self.numErrors += 1
+
+    def fatal(self, message):
+        self._write_message("fatal", message)
+        sys.exit(2)

infer_4_30_0/lib/python3.10/site-packages/lit/Test.py

@@ -0,0 +1,436 @@
+import itertools
+import os
+from json import JSONEncoder
+
+from lit.BooleanExpression import BooleanExpression
+from lit.TestTimes import read_test_times
+
+# Test result codes.
+
+
+class ResultCode(object):
+    """Test result codes."""
+
+    # All result codes (including user-defined ones) in declaration order
+    _all_codes = []
+
+    @staticmethod
+    def all_codes():
+        return ResultCode._all_codes
+
+    # We override __new__ and __getnewargs__ to ensure that pickling still
+    # provides unique ResultCode objects in any particular instance.
+    _instances = {}
+
+    def __new__(cls, name, label, isFailure):
+        res = cls._instances.get(name)
+        if res is None:
+            cls._instances[name] = res = super(ResultCode, cls).__new__(cls)
+        return res
+
+    def __getnewargs__(self):
+        return (self.name, self.label, self.isFailure)
+
+    def __init__(self, name, label, isFailure):
+        self.name = name
+        self.label = label
+        self.isFailure = isFailure
+        ResultCode._all_codes.append(self)
+
+    def __repr__(self):
+        return "%s%r" % (self.__class__.__name__, (self.name, self.isFailure))
+
+
+# Successes
+EXCLUDED = ResultCode("EXCLUDED", "Excluded", False)
+SKIPPED = ResultCode("SKIPPED", "Skipped", False)
+UNSUPPORTED = ResultCode("UNSUPPORTED", "Unsupported", False)
+PASS = ResultCode("PASS", "Passed", False)
+FLAKYPASS = ResultCode("FLAKYPASS", "Passed With Retry", False)
+XFAIL = ResultCode("XFAIL", "Expectedly Failed", False)
+# Failures
+UNRESOLVED = ResultCode("UNRESOLVED", "Unresolved", True)
+TIMEOUT = ResultCode("TIMEOUT", "Timed Out", True)
+FAIL = ResultCode("FAIL", "Failed", True)
+XPASS = ResultCode("XPASS", "Unexpectedly Passed", True)
+
+
+# Test metric values.
+
+
+class MetricValue(object):
+    def format(self):
+        """
+        format() -> str
+
+        Convert this metric to a string suitable for displaying as part of the
+        console output.
+        """
+        raise RuntimeError("abstract method")
+
+    def todata(self):
+        """
+        todata() -> json-serializable data
+
+        Convert this metric to content suitable for serializing in the JSON test
+        output.
+        """
+        raise RuntimeError("abstract method")
+
+
+class IntMetricValue(MetricValue):
+    def __init__(self, value):
+        self.value = value
+
+    def format(self):
+        return str(self.value)
+
+    def todata(self):
+        return self.value
+
+
+class RealMetricValue(MetricValue):
+    def __init__(self, value):
+        self.value = value
+
+    def format(self):
+        return "%.4f" % self.value
+
+    def todata(self):
+        return self.value
+
+
+class JSONMetricValue(MetricValue):
+    """
+    JSONMetricValue is used for types that are representable in the output
+    but that are otherwise uninterpreted.
+    """
+
+    def __init__(self, value):
+        # Ensure the value is a serializable by trying to encode it.
+        # WARNING: The value may change before it is encoded again, and may
+        #          not be encodable after the change.
+        try:
+            e = JSONEncoder()
+            e.encode(value)
+        except TypeError:
+            raise
+        self.value = value
+
+    def format(self):
+        e = JSONEncoder(indent=2, sort_keys=True)
+        return e.encode(self.value)
+
+    def todata(self):
+        return self.value
+
+
+def toMetricValue(value):
+    if isinstance(value, MetricValue):
+        return value
+    elif isinstance(value, int):
+        return IntMetricValue(value)
+    elif isinstance(value, float):
+        return RealMetricValue(value)
+    else:
+        # 'long' is only present in python2
+        try:
+            if isinstance(value, long):
+                return IntMetricValue(value)
+        except NameError:
+            pass
+
+        # Try to create a JSONMetricValue and let the constructor throw
+        # if value is not a valid type.
+        return JSONMetricValue(value)
+
+
+# Test results.
+
+
+class Result(object):
+    """Wrapper for the results of executing an individual test."""
+
+    def __init__(self, code, output="", elapsed=None):
+        # The result code.
+        self.code = code
+        # The test output.
+        self.output = output
+        # The wall timing to execute the test, if timing.
+        self.elapsed = elapsed
+        self.start = None
+        self.pid = None
+        # The metrics reported by this test.
+        self.metrics = {}
+        # The micro-test results reported by this test.
+        self.microResults = {}
+
+    def addMetric(self, name, value):
+        """
+        addMetric(name, value)
+
+        Attach a test metric to the test result, with the given name and list of
+        values. It is an error to attempt to attach the metrics with the same
+        name multiple times.
+
+        Each value must be an instance of a MetricValue subclass.
+        """
+        if name in self.metrics:
+            raise ValueError("result already includes metrics for %r" % (name,))
+        if not isinstance(value, MetricValue):
+            raise TypeError("unexpected metric value: %r" % (value,))
+        self.metrics[name] = value
+
+    def addMicroResult(self, name, microResult):
+        """
+        addMicroResult(microResult)
+
+        Attach a micro-test result to the test result, with the given name and
+        result.  It is an error to attempt to attach a micro-test with the
+        same name multiple times.
+
+        Each micro-test result must be an instance of the Result class.
+        """
+        if name in self.microResults:
+            raise ValueError("Result already includes microResult for %r" % (name,))
+        if not isinstance(microResult, Result):
+            raise TypeError("unexpected MicroResult value %r" % (microResult,))
+        self.microResults[name] = microResult
+
+
+# Test classes.
+
+
+class TestSuite:
+    """TestSuite - Information on a group of tests.
+
+    A test suite groups together a set of logically related tests.
+    """
+
+    def __init__(self, name, source_root, exec_root, config):
+        self.name = name
+        self.source_root = source_root
+        self.exec_root = exec_root
+        # The test suite configuration.
+        self.config = config
+
+        self.test_times = read_test_times(self)
+
+    def getSourcePath(self, components):
+        return os.path.join(self.source_root, *components)
+
+    def getExecPath(self, components):
+        return os.path.join(self.exec_root, *components)
+
+
+class Test:
+    """Test - Information on a single test instance."""
+
+    def __init__(
+        self, suite, path_in_suite, config, file_path=None, gtest_json_file=None
+    ):
+        self.suite = suite
+        self.path_in_suite = path_in_suite
+        self.config = config
+        self.file_path = file_path
+        self.gtest_json_file = gtest_json_file
+
+        # A list of conditions under which this test is expected to fail.
+        # Each condition is a boolean expression of features, or '*'.
+        # These can optionally be provided by test format handlers,
+        # and will be honored when the test result is supplied.
+        self.xfails = []
+
+        # If true, ignore all items in self.xfails.
+        self.xfail_not = False
+
+        # A list of conditions that must be satisfied before running the test.
+        # Each condition is a boolean expression of features. All of them
+        # must be True for the test to run.
+        self.requires = []
+
+        # A list of conditions that prevent execution of the test.
+        # Each condition is a boolean expression of features. All of them
+        # must be False for the test to run.
+        self.unsupported = []
+
+        # An optional number of retries allowed before the test finally succeeds.
+        # The test is run at most once plus the number of retries specified here.
+        self.allowed_retries = getattr(config, "test_retry_attempts", 0)
+
+        # The test result, once complete.
+        self.result = None
+
+        # The previous test failure state, if applicable.
+        self.previous_failure = False
+
+        # The previous test elapsed time, if applicable.
+        self.previous_elapsed = 0.0
+
+        if suite.test_times and "/".join(path_in_suite) in suite.test_times:
+            time = suite.test_times["/".join(path_in_suite)]
+            self.previous_elapsed = abs(time)
+            self.previous_failure = time < 0
+
+    def setResult(self, result):
+        assert self.result is None, "result already set"
+        assert isinstance(result, Result), "unexpected result type"
+        try:
+            expected_to_fail = self.isExpectedToFail()
+        except ValueError as err:
+            # Syntax error in an XFAIL line.
+            result.code = UNRESOLVED
+            result.output = str(err)
+        else:
+            if expected_to_fail:
+                # pass -> unexpected pass
+                if result.code is PASS:
+                    result.code = XPASS
+                # fail -> expected fail
+                elif result.code is FAIL:
+                    result.code = XFAIL
+        self.result = result
+
+    def isFailure(self):
+        assert self.result
+        return self.result.code.isFailure
+
+    def getFullName(self):
+        return self.suite.config.name + " :: " + "/".join(self.path_in_suite)
+
+    def getFilePath(self):
+        if self.file_path:
+            return self.file_path
+        return self.getSourcePath()
+
+    def getSourcePath(self):
+        return self.suite.getSourcePath(self.path_in_suite)
+
+    def getExecPath(self):
+        return self.suite.getExecPath(self.path_in_suite)
+
+    def isExpectedToFail(self):
+        """
+        isExpectedToFail() -> bool
+
+        Check whether this test is expected to fail in the current
+        configuration. This check relies on the test xfails property which by
+        some test formats may not be computed until the test has first been
+        executed.
+        Throws ValueError if an XFAIL line has a syntax error.
+        """
+
+        if self.xfail_not:
+            return False
+
+        features = self.config.available_features
+
+        # Check if any of the xfails match an available feature.
+        for item in self.xfails:
+            # If this is the wildcard, it always fails.
+            if item == "*":
+                return True
+
+            # If this is a True expression of features, it fails.
+            try:
+                if BooleanExpression.evaluate(item, features):
+                    return True
+            except ValueError as e:
+                raise ValueError("Error in XFAIL list:\n%s" % str(e))
+
+        return False
+
+    def isWithinFeatureLimits(self):
+        """
+        isWithinFeatureLimits() -> bool
+
+        A test is within the feature limits set by run_only_tests if
+        1. the test's requirements ARE satisfied by the available features
+        2. the test's requirements ARE NOT satisfied after the limiting
+           features are removed from the available features
+
+        Throws ValueError if a REQUIRES line has a syntax error.
+        """
+
+        if not self.config.limit_to_features:
+            return True  # No limits. Run it.
+
+        # Check the requirements as-is (#1)
+        if self.getMissingRequiredFeatures():
+            return False
+
+        # Check the requirements after removing the limiting features (#2)
+        featuresMinusLimits = [
+            f
+            for f in self.config.available_features
+            if not f in self.config.limit_to_features
+        ]
+        if not self.getMissingRequiredFeaturesFromList(featuresMinusLimits):
+            return False
+
+        return True
+
+    def getMissingRequiredFeaturesFromList(self, features):
+        try:
+            return [
+                item
+                for item in self.requires
+                if not BooleanExpression.evaluate(item, features)
+            ]
+        except ValueError as e:
+            raise ValueError("Error in REQUIRES list:\n%s" % str(e))
+
+    def getMissingRequiredFeatures(self):
+        """
+        getMissingRequiredFeatures() -> list of strings
+
+        Returns a list of features from REQUIRES that are not satisfied."
+        Throws ValueError if a REQUIRES line has a syntax error.
+        """
+
+        features = self.config.available_features
+        return self.getMissingRequiredFeaturesFromList(features)
+
+    def getUnsupportedFeatures(self):
+        """
+        getUnsupportedFeatures() -> list of strings
+
+        Returns a list of features from UNSUPPORTED that are present
+        in the test configuration's features.
+        Throws ValueError if an UNSUPPORTED line has a syntax error.
+        """
+
+        features = self.config.available_features
+
+        try:
+            return [
+                item
+                for item in self.unsupported
+                if BooleanExpression.evaluate(item, features)
+            ]
+        except ValueError as e:
+            raise ValueError("Error in UNSUPPORTED list:\n%s" % str(e))
+
+    def getUsedFeatures(self):
+        """
+        getUsedFeatures() -> list of strings
+
+        Returns a list of all features appearing in XFAIL, UNSUPPORTED and
+        REQUIRES annotations for this test.
+        """
+        import lit.TestRunner
+
+        parsed = lit.TestRunner._parseKeywords(
+            self.getSourcePath(), require_script=False
+        )
+        feature_keywords = ("UNSUPPORTED:", "REQUIRES:", "XFAIL:")
+        boolean_expressions = itertools.chain.from_iterable(
+            parsed[k] or [] for k in feature_keywords
+        )
+        tokens = itertools.chain.from_iterable(
+            BooleanExpression.tokenize(expr)
+            for expr in boolean_expressions
+            if expr != "*"
+        )
+        matchExpressions = set(filter(BooleanExpression.isMatchExpression, tokens))
+        return matchExpressions

infer_4_30_0/lib/python3.10/site-packages/lit/TestTimes.py

@@ -0,0 +1,40 @@
+import os
+
+
+def read_test_times(suite):
+    test_times = {}
+    test_times_file = os.path.join(suite.exec_root, ".lit_test_times.txt")
+    if not os.path.exists(test_times_file):
+        test_times_file = os.path.join(suite.source_root, ".lit_test_times.txt")
+    if os.path.exists(test_times_file):
+        with open(test_times_file, "r") as time_file:
+            for line in time_file:
+                time, path = line.split(maxsplit=1)
+                test_times[path.strip("\n")] = float(time)
+    return test_times
+
+
+def record_test_times(tests, lit_config):
+    times_by_suite = {}
+    for t in tests:
+        assert t.suite.test_times is None
+        if t.result.elapsed is None:
+            continue
+        if not t.suite.exec_root in times_by_suite:
+            times_by_suite[t.suite.exec_root] = read_test_times(t.suite)
+        time = -t.result.elapsed if t.isFailure() else t.result.elapsed
+        # The "path" here is only used as a key into a dictionary. It is never
+        # used as an actual path to a filesystem API, therefore we use '/' as
+        # the canonical separator so that Unix and Windows machines can share
+        # timing data.
+        times_by_suite[t.suite.exec_root]["/".join(t.path_in_suite)] = time
+
+    for s, value in times_by_suite.items():
+        try:
+            path = os.path.join(s, ".lit_test_times.txt")
+            with open(path, "w") as time_file:
+                for name, time in value.items():
+                    time_file.write(("%e" % time) + " " + name + "\n")
+        except:
+            lit_config.warning("Could not save test time: " + path)
+            continue

infer_4_30_0/lib/python3.10/site-packages/lit/__init__.py

@@ -0,0 +1,8 @@
+"""'lit' Testing Tool"""
+
+__author__ = "Daniel Dunbar"
+__email__ = "[email protected]"
+__versioninfo__ = (18, 1, 8)
+__version__ = ".".join(str(v) for v in __versioninfo__)
+
+__all__ = []

infer_4_30_0/lib/python3.10/site-packages/lit/run.py

@@ -0,0 +1,141 @@
+import multiprocessing
+import os
+import time
+
+import lit.Test
+import lit.util
+import lit.worker
+
+
+class MaxFailuresError(Exception):
+    pass
+
+
+class TimeoutError(Exception):
+    pass
+
+
+class Run(object):
+    """A concrete, configured testing run."""
+
+    def __init__(
+        self, tests, lit_config, workers, progress_callback, max_failures, timeout
+    ):
+        self.tests = tests
+        self.lit_config = lit_config
+        self.workers = workers
+        self.progress_callback = progress_callback
+        self.max_failures = max_failures
+        self.timeout = timeout
+        assert workers > 0
+
+    def execute(self):
+        """
+        Execute the tests in the run using up to the specified number of
+        parallel tasks, and inform the caller of each individual result. The
+        provided tests should be a subset of the tests available in this run
+        object.
+
+        The progress_callback will be invoked for each completed test.
+
+        If timeout is non-None, it should be a time in seconds after which to
+        stop executing tests.
+
+        Returns the elapsed testing time.
+
+        Upon completion, each test in the run will have its result
+        computed. Tests which were not actually executed (for any reason) will
+        be marked SKIPPED.
+        """
+        self.failures = 0
+
+        # Larger timeouts (one year, positive infinity) don't work on Windows.
+        one_week = 7 * 24 * 60 * 60  # days * hours * minutes * seconds
+        timeout = self.timeout or one_week
+        deadline = time.time() + timeout
+
+        try:
+            self._execute(deadline)
+        finally:
+            skipped = lit.Test.Result(lit.Test.SKIPPED)
+            for test in self.tests:
+                if test.result is None:
+                    test.setResult(skipped)
+
+    def _execute(self, deadline):
+        self._increase_process_limit()
+
+        semaphores = {
+            k: multiprocessing.BoundedSemaphore(v)
+            for k, v in self.lit_config.parallelism_groups.items()
+            if v is not None
+        }
+
+        pool = multiprocessing.Pool(
+            self.workers, lit.worker.initialize, (self.lit_config, semaphores)
+        )
+
+        async_results = [
+            pool.apply_async(
+                lit.worker.execute, args=[test], callback=self.progress_callback
+            )
+            for test in self.tests
+        ]
+        pool.close()
+
+        try:
+            self._wait_for(async_results, deadline)
+        except:
+            pool.terminate()
+            raise
+        finally:
+            pool.join()
+
+    def _wait_for(self, async_results, deadline):
+        timeout = deadline - time.time()
+        for idx, ar in enumerate(async_results):
+            try:
+                test = ar.get(timeout)
+            except multiprocessing.TimeoutError:
+                raise TimeoutError()
+            else:
+                self._update_test(self.tests[idx], test)
+                if test.isFailure():
+                    self.failures += 1
+                    if self.failures == self.max_failures:
+                        raise MaxFailuresError()
+
+    # Update local test object "in place" from remote test object.  This
+    # ensures that the original test object which is used for printing test
+    # results reflects the changes.
+    def _update_test(self, local_test, remote_test):
+        # Needed for getMissingRequiredFeatures()
+        local_test.requires = remote_test.requires
+        local_test.result = remote_test.result
+
+    # TODO(yln): interferes with progress bar
+    # Some tests use threads internally, and at least on Linux each of these
+    # threads counts toward the current process limit. Try to raise the (soft)
+    # process limit so that tests don't fail due to resource exhaustion.
+    def _increase_process_limit(self):
+        ncpus = lit.util.usable_core_count()
+        desired_limit = self.workers * ncpus * 2  # the 2 is a safety factor
+
+        # Importing the resource module will likely fail on Windows.
+        try:
+            import resource
+
+            NPROC = resource.RLIMIT_NPROC
+
+            soft_limit, hard_limit = resource.getrlimit(NPROC)
+            desired_limit = min(desired_limit, hard_limit)
+
+            if soft_limit < desired_limit:
+                resource.setrlimit(NPROC, (desired_limit, hard_limit))
+                self.lit_config.note(
+                    "Raised process limit from %d to %d" % (soft_limit, desired_limit)
+                )
+        except Exception as ex:
+            # Warn, unless this is Windows, in which case this is expected.
+            if os.name != "nt":
+                self.lit_config.warning("Failed to raise process limit: %s" % ex)

infer_4_30_0/lib/python3.10/site-packages/opencensus-0.11.4.dist-info/RECORD

@@ -0,0 +1,194 @@
+opencensus-0.11.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+opencensus-0.11.4.dist-info/LICENSE,sha256=YmXwJVPDAw7MfsXq36r_DSbI55E92i-djKAC0Fa43ts,11553
+opencensus-0.11.4.dist-info/METADATA,sha256=M0nHiQlDaEteLWFmNwGGs6Xu1C3_YsczItcW70LZG4k,12351
+opencensus-0.11.4.dist-info/RECORD,,
+opencensus-0.11.4.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencensus-0.11.4.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+opencensus-0.11.4.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+opencensus-0.11.4.dist-info/top_level.txt,sha256=J24OU61lnFeMMuwOLPtTNywYsd2Bzp5KbBCPtAhDgaI,11
+opencensus/__init__.py,sha256=F0UD44DuZCpVvI1PX5rW4FcKQ004ORdqeOhf4JsheIY,66
+opencensus/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/__init__.py,sha256=F0UD44DuZCpVvI1PX5rW4FcKQ004ORdqeOhf4JsheIY,66
+opencensus/common/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/backports/__init__.py,sha256=ZfPWVZ8q7qcuRBDY9pGyH36kQ5mejJuMNDyOltEZqb0,2888
+opencensus/common/backports/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/configuration/__init__.py,sha256=YIDloGhqI4TzgvMx8lIrTMephpwaW31xcoO0a6UGmTE,1443
+opencensus/common/configuration/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/http_handler/__init__.py,sha256=CHqTDxGFN8pq1njv5f53aMVzdc1G-xYJEfqwJKR5QWc,1434
+opencensus/common/http_handler/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/monitored_resource/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencensus/common/monitored_resource/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/monitored_resource/__pycache__/aws_identity_doc_utils.cpython-310.pyc,,
+opencensus/common/monitored_resource/__pycache__/gcp_metadata_config.cpython-310.pyc,,
+opencensus/common/monitored_resource/__pycache__/k8s_utils.cpython-310.pyc,,
+opencensus/common/monitored_resource/__pycache__/monitored_resource.cpython-310.pyc,,
+opencensus/common/monitored_resource/aws_identity_doc_utils.py,sha256=v-7tuf9P554rhunHSoYmghszU14gI7i9ot7NuXJB42w,3243
+opencensus/common/monitored_resource/gcp_metadata_config.py,sha256=OufJ6HUxVTfRC-5_WFvs3SiywXxA2damyVyAtvUZsFs,4119
+opencensus/common/monitored_resource/k8s_utils.py,sha256=9RSsoqUdMSpS12P-tn3v7VtSXaIBM8KqqqBxL7MpqiM,2108
+opencensus/common/monitored_resource/monitored_resource.py,sha256=vbxUPe6kFufY7IL46QMBBOxwSI2AVHcnwZSVxqUf2U8,2389
+opencensus/common/resource/__init__.py,sha256=9c0T-2H2oHI1lXm11KvFdUjfSvsOMiowLQaGJqZ6NUY,6591
+opencensus/common/resource/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/schedule/__init__.py,sha256=6o-WqHxUC075eKEMnqVb-omWzwGY7cxbPcukxkACPUk,4738
+opencensus/common/schedule/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/transports/__init__.py,sha256=TcAW4NO62hdY2RC2-lLga_icFnrpYMrR9zcS2xcuz6U,596
+opencensus/common/transports/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/transports/__pycache__/async_.cpython-310.pyc,,
+opencensus/common/transports/__pycache__/base.cpython-310.pyc,,
+opencensus/common/transports/__pycache__/sync.cpython-310.pyc,,
+opencensus/common/transports/async_.py,sha256=yVabLF1avTBMMewrndVZ5Uet7WPVpH6wncfDpF4hXIA,8063
+opencensus/common/transports/base.py,sha256=MHpSA0DWEe3bd9S1Pqz85i3UOa5yjkP0I_b894VYW5A,1021
+opencensus/common/transports/sync.py,sha256=5cxYNnC3ntynQmM59ccER1aGHKWRWp1yNUZD7DNZKCE,1058
+opencensus/common/utils/__init__.py,sha256=JRpGoXBroCFQTlwm7a3sP2AihrPpfFL8Ots8Yp11eYU,3738
+opencensus/common/utils/__pycache__/__init__.cpython-310.pyc,,
+opencensus/common/version/__init__.py,sha256=3A51Klomvw2AvHVZ7lV3G1qmldc3cfIPvHNl8C-N55s,622
+opencensus/common/version/__pycache__/__init__.cpython-310.pyc,,
+opencensus/log/__init__.py,sha256=U3ULx0SpGhjuUlbaItEQv0bQLUKSlQEBjEgplNEyJcI,4159
+opencensus/log/__pycache__/__init__.cpython-310.pyc,,
+opencensus/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencensus/metrics/__pycache__/__init__.cpython-310.pyc,,
+opencensus/metrics/__pycache__/label_key.cpython-310.pyc,,
+opencensus/metrics/__pycache__/label_value.cpython-310.pyc,,
+opencensus/metrics/__pycache__/transport.cpython-310.pyc,,
+opencensus/metrics/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencensus/metrics/export/__pycache__/__init__.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/cumulative.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/gauge.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/metric.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/metric_descriptor.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/metric_producer.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/point.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/summary.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/time_series.cpython-310.pyc,,
+opencensus/metrics/export/__pycache__/value.cpython-310.pyc,,
+opencensus/metrics/export/cumulative.py,sha256=pXuvoBu8dk97HlEH_kH5iAXVzMGVnkZB49HQREOPcmc,2958
+opencensus/metrics/export/gauge.py,sha256=XOLPsP2IEmSRaINvIwPcMjJI-07LdscYRqo2oxVeEmI,17770
+opencensus/metrics/export/metric.py,sha256=Uo6rJKw6D7-UcRwSpsqkGfhli8XU4KrvufmjQ1r38mc,3224
+opencensus/metrics/export/metric_descriptor.py,sha256=NhFPIeQn_G42GU0mxkPG5cRD6pH07y4bxXTGq4BUVrg,6174
+opencensus/metrics/export/metric_producer.py,sha256=8XSFwJpAiliqaIR7TTuaYp26sJ1GZhep4H9Ul_5DSjk,2764
+opencensus/metrics/export/point.py,sha256=S5P0dnPFMT5Waj-nIPlT3V0TBeTyCAiQ4Fx0gWw2QyI,1571
+opencensus/metrics/export/summary.py,sha256=n30_7EsVZy5CEeNSfGaxVUe-l7bzvjbLTasRJJH48H8,4449
+opencensus/metrics/export/time_series.py,sha256=K-Va6EKfdS5b1ifO68r8d4rOVJRYhcDPp_w_hW18h7A,3278
+opencensus/metrics/export/value.py,sha256=uX9IrsAZirUspDJrxPWPqE4V2Y0REOoRjidPCsMGRUQ,9082
+opencensus/metrics/label_key.py,sha256=ZS0RSVW4VzQzLESLJho9yLRnV4Oi78Hum93mfMSf8CA,1630
+opencensus/metrics/label_value.py,sha256=lv1HbhzOyi4xOIvLFazzYqi8YPoAz1Saci4Se_T26F8,1289
+opencensus/metrics/transport.py,sha256=rVaKjRwPhdSy1Ik9ks1u6Z7CMwf9hbbBRDpBFV5YTts,4534
+opencensus/stats/__init__.py,sha256=TcAW4NO62hdY2RC2-lLga_icFnrpYMrR9zcS2xcuz6U,596
+opencensus/stats/__pycache__/__init__.cpython-310.pyc,,
+opencensus/stats/__pycache__/aggregation.cpython-310.pyc,,
+opencensus/stats/__pycache__/aggregation_data.cpython-310.pyc,,
+opencensus/stats/__pycache__/base_exporter.cpython-310.pyc,,
+opencensus/stats/__pycache__/bucket_boundaries.cpython-310.pyc,,
+opencensus/stats/__pycache__/execution_context.cpython-310.pyc,,
+opencensus/stats/__pycache__/measure.cpython-310.pyc,,
+opencensus/stats/__pycache__/measure_to_view_map.cpython-310.pyc,,
+opencensus/stats/__pycache__/measurement.cpython-310.pyc,,
+opencensus/stats/__pycache__/measurement_map.cpython-310.pyc,,
+opencensus/stats/__pycache__/metric_utils.cpython-310.pyc,,
+opencensus/stats/__pycache__/stats.cpython-310.pyc,,
+opencensus/stats/__pycache__/stats_recorder.cpython-310.pyc,,
+opencensus/stats/__pycache__/view.cpython-310.pyc,,
+opencensus/stats/__pycache__/view_data.cpython-310.pyc,,
+opencensus/stats/__pycache__/view_manager.cpython-310.pyc,,
+opencensus/stats/aggregation.py,sha256=M8PAxMf0RXMhezuItnOhcPvadmmRvxeX9xoMCWQexFY,5180
+opencensus/stats/aggregation_data.py,sha256=Q4_xZm5hqpVRZH0qW0hhByXAIBQjL3daVcMQBKruMnA,13885
+opencensus/stats/base_exporter.py,sha256=LlCB_0lLw2XMXChIUU4KOoPfvMWirX8U7-i7p7Fmg9w,1569
+opencensus/stats/bucket_boundaries.py,sha256=2e6lj0dbuRwQPELehsaAhnAO6hSThz8QerJ5tWTzswU,1407
+opencensus/stats/execution_context.py,sha256=vSMam4Q_CgCfuJ4lVCPBtbBLTK4PCFCyWOhG6zVUtLc,1067
+opencensus/stats/measure.py,sha256=dCxrmRi88TqMgULZYz4amooB7hvMc91xanUB4aMGp0M,1928
+opencensus/stats/measure_to_view_map.py,sha256=mvEDs_p2NLuNnV6qKL0QB2k5AzxIO9eVpCqZzJJCu3w,6271
+opencensus/stats/measurement.py,sha256=DXSUTsSkabsF8y7kjZjuUN0n76weaJi86z1TRPwETw0,1649
+opencensus/stats/measurement_map.py,sha256=8nr-W2OzvKXpNDKXE0hCDNWWVuH3JykKHQ7269tn1KY,4821
+opencensus/stats/metric_utils.py,sha256=JHJWHFm8ztm4Yy1e7pP5qxeRh6_Jk4CmgbrPwmt7DQA,2858
+opencensus/stats/stats.py,sha256=4nBU5aIQXbuCYNfpdwcmH19tS37_VUSJktoxMArq08c,1545
+opencensus/stats/stats_recorder.py,sha256=xoYyGI__Ml-NiKinYH4q9wyT9Z7jXPbsPH5UH5wYAAw,1378
+opencensus/stats/view.py,sha256=-7wzEVJEw3OnC67pi3FVzr2JM-aqhJTXaKnaAA2gaIc,3638
+opencensus/stats/view_data.py,sha256=mlj-tzvvCHnQjgUF_2Rpyfh4BGUDq8uwdX6TgE5BytA,3273
+opencensus/stats/view_manager.py,sha256=ePgy60hsjWf-eR6FNp1biQYbD8umxYtnpMK8FIjDUV0,2216
+opencensus/tags/__init__.py,sha256=TqjMu0ZDj4wMrhcDfIPuswSw4F2PTpxPwlO4ZGzzjys,966
+opencensus/tags/__pycache__/__init__.cpython-310.pyc,,
+opencensus/tags/__pycache__/tag.cpython-310.pyc,,
+opencensus/tags/__pycache__/tag_key.cpython-310.pyc,,
+opencensus/tags/__pycache__/tag_map.cpython-310.pyc,,
+opencensus/tags/__pycache__/tag_value.cpython-310.pyc,,
+opencensus/tags/__pycache__/validation.cpython-310.pyc,,
+opencensus/tags/propagation/__init__.py,sha256=TcAW4NO62hdY2RC2-lLga_icFnrpYMrR9zcS2xcuz6U,596
+opencensus/tags/propagation/__pycache__/__init__.cpython-310.pyc,,
+opencensus/tags/propagation/__pycache__/binary_serializer.cpython-310.pyc,,
+opencensus/tags/propagation/binary_serializer.py,sha256=eWygMfCWytI66OVO4lRpEQxAb9sKER5wi0IlRjKbGRY,3891
+opencensus/tags/tag.py,sha256=myzlZNWW2TdF4nvL4BsiqIFnsqsmalHAvUYsqWPQnc4,1145
+opencensus/tags/tag_key.py,sha256=obev7j_EvSTK56MD6OOS8yhlzu0-xIMHiVevdt0_C0o,1227
+opencensus/tags/tag_map.py,sha256=hNuiRO1qZJf3l_gesb3extDUnwCMfl-mW-8TH1tfKTE,3339
+opencensus/tags/tag_value.py,sha256=5opAVWqI50CovpSh_Z6mqnaC2T4ZDpurLB423OyI5lE,1255
+opencensus/tags/validation.py,sha256=OV8gJ9b3UyLz9tYr6IbAT65vHr6jp3gB9Bo8UmpeA8I,1255
+opencensus/trace/__init__.py,sha256=3vmAI0NGA5urfT7sweDlIpvWmGUf5LG2luZsd_Ra4f4,660
+opencensus/trace/__pycache__/__init__.cpython-310.pyc,,
+opencensus/trace/__pycache__/attributes.cpython-310.pyc,,
+opencensus/trace/__pycache__/attributes_helper.cpython-310.pyc,,
+opencensus/trace/__pycache__/base_exporter.cpython-310.pyc,,
+opencensus/trace/__pycache__/base_span.cpython-310.pyc,,
+opencensus/trace/__pycache__/blank_span.cpython-310.pyc,,
+opencensus/trace/__pycache__/config_integration.cpython-310.pyc,,
+opencensus/trace/__pycache__/exceptions_status.cpython-310.pyc,,
+opencensus/trace/__pycache__/execution_context.cpython-310.pyc,,
+opencensus/trace/__pycache__/file_exporter.cpython-310.pyc,,
+opencensus/trace/__pycache__/integrations.cpython-310.pyc,,
+opencensus/trace/__pycache__/link.cpython-310.pyc,,
+opencensus/trace/__pycache__/logging_exporter.cpython-310.pyc,,
+opencensus/trace/__pycache__/print_exporter.cpython-310.pyc,,
+opencensus/trace/__pycache__/span.cpython-310.pyc,,
+opencensus/trace/__pycache__/span_context.cpython-310.pyc,,
+opencensus/trace/__pycache__/span_data.cpython-310.pyc,,
+opencensus/trace/__pycache__/stack_trace.cpython-310.pyc,,
+opencensus/trace/__pycache__/status.cpython-310.pyc,,
+opencensus/trace/__pycache__/time_event.cpython-310.pyc,,
+opencensus/trace/__pycache__/trace_options.cpython-310.pyc,,
+opencensus/trace/__pycache__/tracer.cpython-310.pyc,,
+opencensus/trace/__pycache__/tracestate.cpython-310.pyc,,
+opencensus/trace/__pycache__/utils.cpython-310.pyc,,
+opencensus/trace/attributes.py,sha256=YAyn_Fp2V969gOwB_QhQN0iwnlskKV3f4E9rt_xMjOA,2457
+opencensus/trace/attributes_helper.py,sha256=o67kxxUOGwbjUY_Zeorr4AkCsqj0z8FYYvNizgx8z_Y,1522
+opencensus/trace/base_exporter.py,sha256=R2B4vWebq5BxEdxTJ6sXxnRfBTzJI7NBSpsvJC9eaRk,1585
+opencensus/trace/base_span.py,sha256=gMYlnYrsYwBbhmUxT_lC0kcFqAoJTSIU7q35RSAvOlE,3429
+opencensus/trace/blank_span.py,sha256=tcSFY4WtINQy9ygclZncSg5qq1gPW8J2PCIXx9L7Akc,5440
+opencensus/trace/config_integration.py,sha256=DuUsSoIG4Mg0Z3eNjp13bZ0mygabe8GFpnSNj7F2GNs,1330
+opencensus/trace/exceptions_status.py,sha256=YYyGIYnsVNevsg6bdloxzEObxO4WmMmBTyTKPWjCbZQ,940
+opencensus/trace/execution_context.py,sha256=OYQGwRUXSx9Tn9p_wxghrI3MFV-1ME9Wp7pYXyuaaCw,2476
+opencensus/trace/file_exporter.py,sha256=eXYNXEx5dHU5wPFb61ASUDyUZepxJMhKbmcQ9Mt8mJo,2669
+opencensus/trace/integrations.py,sha256=OeyzYjBpA501-96KC1fEccfasTb03njsswbZV0Er230,1448
+opencensus/trace/link.py,sha256=e-Wwrsnk3-zlK9JMaWQ1t80jSmdkPQa-dBM667DnRTQ,2622
+opencensus/trace/logging_exporter.py,sha256=zSby20MJ1o6M4nIB9hCeiA1zhNdZgZcos3_2IZf_83I,3217
+opencensus/trace/print_exporter.py,sha256=T0SvkDcbwIiA5V-UriZLSMDDetuDesLXQ6Ru-xveCYw,1932
+opencensus/trace/propagation/__init__.py,sha256=3cwrGSSn3JMa-Au3B1875PPwj3Ndg-lxgslMZRNsW3s,596
+opencensus/trace/propagation/__pycache__/__init__.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/b3_format.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/binary_format.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/google_cloud_format.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/text_format.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/trace_context_http_header_format.cpython-310.pyc,,
+opencensus/trace/propagation/__pycache__/tracestate_string_format.cpython-310.pyc,,
+opencensus/trace/propagation/b3_format.py,sha256=7C2dZQgsu2NVTdwsnE8qnU-WfdHgpBfb5g4oSItgVuU,4053
+opencensus/trace/propagation/binary_format.py,sha256=aahWtjg1AUJDkMiE3FUrSQrRZyb-H5KeULsEYaM_QjA,6168
+opencensus/trace/propagation/google_cloud_format.py,sha256=GDkpPWW5r3bubkp86CDSQwKDYeiY6X9i-m57-Ysdwgs,4605
+opencensus/trace/propagation/text_format.py,sha256=nBUZq4_jf5WhdSth1sl30rhrmIaaIabJiIQ1fwiY0GY,3174
+opencensus/trace/propagation/trace_context_http_header_format.py,sha256=y77aO_Hx9WI-pji-7HakeKK_DRnalZg0XAyYiTQ5UGw,3946
+opencensus/trace/propagation/tracestate_string_format.py,sha256=jw_mhR2_NvuAvjrF4B4_bilLiEqw-ocTJBDXGBE1Ryo,1604
+opencensus/trace/samplers/__init__.py,sha256=MQtXRIokFq2UCXR5Xj7K8_Nk_Ga1DCIF7iwAFBpYZ-g,2895
+opencensus/trace/samplers/__pycache__/__init__.cpython-310.pyc,,
+opencensus/trace/span.py,sha256=F6JaUIiyOlOp9soyu8VoKHkx3SbrizKRsLYD2p_TEd4,15598
+opencensus/trace/span_context.py,sha256=KN8newixFHvWZ-JXP_UBFyHtVUSVFm5mRFA5upV2gBE,5548
+opencensus/trace/span_data.py,sha256=aCJm2UwEIcJ2pDI3UXHtNsyVadAUOIvC05eqybIN_yA,6514
+opencensus/trace/stack_trace.py,sha256=rm1kCy2U_sXq9ndW0DVcHfZO98X8jIJo8Fdb2nAr0bQ,6998
+opencensus/trace/status.py,sha256=yLcQgs8gvL0Yb4lqJ3ZFsWFBdU5vkeQtOfSWUyVBqlk,2624
+opencensus/trace/time_event.py,sha256=bEZ8_6zVheAn8V-3OI5lL76mZxJ-9tJUOCJBMAZSXS0,4301
+opencensus/trace/trace_options.py,sha256=I-SOm3_iaPyjjZR69D4XmFcQaEqTu19A-Btk6iaR72o,2651
+opencensus/trace/tracer.py,sha256=bORAnkVg1y__ZJt3keuxqms2dB4NpW6zclKNDYaUK0I,5166
+opencensus/trace/tracers/__init__.py,sha256=3cwrGSSn3JMa-Au3B1875PPwj3Ndg-lxgslMZRNsW3s,596
+opencensus/trace/tracers/__pycache__/__init__.cpython-310.pyc,,
+opencensus/trace/tracers/__pycache__/base.cpython-310.pyc,,
+opencensus/trace/tracers/__pycache__/context_tracer.cpython-310.pyc,,
+opencensus/trace/tracers/__pycache__/noop_tracer.cpython-310.pyc,,
+opencensus/trace/tracers/base.py,sha256=KRi_n-OAvpFHZnhLl8ZTlWofTmvoZEeaa18OMaG9Kr4,2622
+opencensus/trace/tracers/context_tracer.py,sha256=RGTy0IzYEsEgxj5u6eBG7PrmYfs7Pq-0ZCyDSHBJN-Q,5991
+opencensus/trace/tracers/noop_tracer.py,sha256=CotRxATBNii4YSNi--7_fl7-iIFj1z6rQmCzzk2f07k,2686
+opencensus/trace/tracestate.py,sha256=mKFckhglUTxHdwNnoGdHoaQeJcdOvYPCbCX7mIr0MUI,2516
+opencensus/trace/utils.py,sha256=khhyGNpkjOL8Sognf_zdZn_WSiHHKhrgSf31mDAtsBU,4059

infer_4_30_0/lib/python3.10/site-packages/opencensus-0.11.4.dist-info/namespace_packages.txt

@@ -0,0 +1 @@
+

infer_4_30_0/lib/python3.10/site-packages/opencensus-0.11.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+opencensus

infer_4_30_0/lib/python3.10/site-packages/referencing-0.35.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_30_0/lib/python3.10/site-packages/safetensors/_safetensors_rust.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a8aa6ef051354553c86afcb40a3bae5d68dac20017e4b5225a3054b7bed71e9
+size 1012224

infer_4_30_0/lib/python3.10/site-packages/setuptools-75.1.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_30_0/lib/python3.10/site-packages/setuptools-75.1.0.dist-info/RECORD

@@ -0,0 +1,936 @@
+_distutils_hack/__init__.py,sha256=oyXE9i-SoZ2qpVgIjkM5r9eOFN9Awgp9UcncOnFNwjc,6754
+_distutils_hack/__pycache__/__init__.cpython-310.pyc,,
+_distutils_hack/__pycache__/override.cpython-310.pyc,,
+_distutils_hack/override.py,sha256=Eu_s-NF6VIZ4Cqd0tbbA5wtWky2IZPNd8et6GLt1mzo,44
+distutils-precedence.pth,sha256=JjjOniUA5XKl4N5_rtZmHrVp0baW_LoHsN0iPaX10iQ,151
+pkg_resources/__init__.py,sha256=-d69BOtMx-kE22-8JSKHJD4hx-dd-8c8v8G_nT1HcuQ,126236
+pkg_resources/__pycache__/__init__.cpython-310.pyc,,
+pkg_resources/api_tests.txt,sha256=XEdvy4igHHrq2qNHNMHnlfO6XSQKNqOyLHbl6QcpfAI,12595
+pkg_resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_resources/tests/__pycache__/__init__.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_find_distributions.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_markers.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_pkg_resources.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_resources.cpython-310.pyc,,
+pkg_resources/tests/__pycache__/test_working_set.cpython-310.pyc,,
+pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-310.pyc,,
+pkg_resources/tests/data/my-test-package-source/setup.cfg,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_resources/tests/data/my-test-package-source/setup.py,sha256=1VobhAZbMb7M9mfhb_NE8PwDsvukoWLs9aUAS0pYhe8,105
+pkg_resources/tests/data/my-test-package-zip/my-test-package.zip,sha256=AYRcQ39GVePPnMT8TknP1gdDHyJnXhthESmpAjnzSCI,1809
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO,sha256=JvWv9Io2PAuYwEEw2fBW4Qc5YvdbkscpKX1kmLzsoHk,187
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt,sha256=4ClkH8eTovZrdVrJFsVuxdbMEF--lBVSuKonDAPE5Jc,208
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg,sha256=ZTlMGxjRGiKDNkiA2c75jbQH2TWIteP00irF9gvczbo,843
+pkg_resources/tests/test_find_distributions.py,sha256=U91cov5L1COAIWLNq3Xy4plU7_MnOE1WtXMu6iV2waM,1972
+pkg_resources/tests/test_integration_zope_interface.py,sha256=nzVoK557KZQN0V3DIQ1sVeaCOgt4Kpl-CODAWsO7pmc,1652
+pkg_resources/tests/test_markers.py,sha256=0orKg7UMDf7fnuNQvRMOc-EF9EAP_JTQnk4mtGgbW50,241
+pkg_resources/tests/test_pkg_resources.py,sha256=lwOYAJOui0e86isYT7cq9OJLqsB8eXHBqTlrQOaoPIg,15221
+pkg_resources/tests/test_resources.py,sha256=vjvbX9SkDRLcxIO5_g3ZuX-ZiWUlWoaXNHdrEUyxFds,31252
+pkg_resources/tests/test_working_set.py,sha256=v3lf3NSsGGNwKJFZY7y1C5_cp-dnXsoxBuSxe1Rwk78,8531
+setuptools-75.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools-75.1.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools-75.1.0.dist-info/METADATA,sha256=Lk5ZLxvvviolVBVgH3IqVot9N8lKqYrKIS_A3WjC2Bo,6855
+setuptools-75.1.0.dist-info/RECORD,,
+setuptools-75.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools-75.1.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+setuptools-75.1.0.dist-info/entry_points.txt,sha256=zkgthpf_Fa9NVE9p6FKT3Xk9DR1faAcRU4coggsV7jA,2449
+setuptools-75.1.0.dist-info/top_level.txt,sha256=d9yL39v_W7qmKDDSH6sT4bE0j_Ls1M3P161OGgdsm4g,41
+setuptools/__init__.py,sha256=WQlS2dBCSX3SzoH64dzjc1sJI-Ou2GZGzvbYiLCCWMA,10389
+setuptools/__pycache__/__init__.cpython-310.pyc,,
+setuptools/__pycache__/_core_metadata.cpython-310.pyc,,
+setuptools/__pycache__/_entry_points.cpython-310.pyc,,
+setuptools/__pycache__/_imp.cpython-310.pyc,,
+setuptools/__pycache__/_importlib.cpython-310.pyc,,
+setuptools/__pycache__/_itertools.cpython-310.pyc,,
+setuptools/__pycache__/_normalization.cpython-310.pyc,,
+setuptools/__pycache__/_path.cpython-310.pyc,,
+setuptools/__pycache__/_reqs.cpython-310.pyc,,
+setuptools/__pycache__/archive_util.cpython-310.pyc,,
+setuptools/__pycache__/build_meta.cpython-310.pyc,,
+setuptools/__pycache__/depends.cpython-310.pyc,,
+setuptools/__pycache__/discovery.cpython-310.pyc,,
+setuptools/__pycache__/dist.cpython-310.pyc,,
+setuptools/__pycache__/errors.cpython-310.pyc,,
+setuptools/__pycache__/extension.cpython-310.pyc,,
+setuptools/__pycache__/glob.cpython-310.pyc,,
+setuptools/__pycache__/installer.cpython-310.pyc,,
+setuptools/__pycache__/launch.cpython-310.pyc,,
+setuptools/__pycache__/logging.cpython-310.pyc,,
+setuptools/__pycache__/modified.cpython-310.pyc,,
+setuptools/__pycache__/monkey.cpython-310.pyc,,
+setuptools/__pycache__/msvc.cpython-310.pyc,,
+setuptools/__pycache__/namespaces.cpython-310.pyc,,
+setuptools/__pycache__/package_index.cpython-310.pyc,,
+setuptools/__pycache__/sandbox.cpython-310.pyc,,
+setuptools/__pycache__/unicode_utils.cpython-310.pyc,,
+setuptools/__pycache__/version.cpython-310.pyc,,
+setuptools/__pycache__/warnings.cpython-310.pyc,,
+setuptools/__pycache__/wheel.cpython-310.pyc,,
+setuptools/__pycache__/windows_support.cpython-310.pyc,,
+setuptools/_core_metadata.py,sha256=7xeUsLocaSZQlgRQ81-HVRMWUWFXMyFJpVyjCDJgXS0,9795
+setuptools/_distutils/__init__.py,sha256=xGYuhWwLG07J0Q49BVnEjPy6wyDcd6veJMDJX7ljlyM,359
+setuptools/_distutils/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/_log.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/_macos_compat.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/_modified.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/_msvccompiler.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/archive_util.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/ccompiler.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/cmd.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/core.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/cygwinccompiler.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/debug.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/dep_util.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/dir_util.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/dist.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/errors.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/extension.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/fancy_getopt.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/file_util.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/filelist.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/log.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/spawn.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/sysconfig.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/text_file.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/unixccompiler.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/util.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/version.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/versionpredicate.cpython-310.pyc,,
+setuptools/_distutils/__pycache__/zosccompiler.cpython-310.pyc,,
+setuptools/_distutils/_log.py,sha256=i-lNTTcXS8TmWITJ6DODGvtW5z5tMattJQ76h8rZxQU,42
+setuptools/_distutils/_macos_compat.py,sha256=JzUGhF4E5yIITHbUaPobZEWjGHdrrcNV63z86S4RjBc,239
+setuptools/_distutils/_modified.py,sha256=JZvIUKHidnO_yddOaS9oaXdSrWnyQMifataAkvpsnIU,2446
+setuptools/_distutils/_msvccompiler.py,sha256=C88msUcJV1aUqK7YBXz5ZAUbkZefg6evxhjHrTTOiOs,20798
+setuptools/_distutils/archive_util.py,sha256=15jHbLmCDcnZ75J2tFFyCmCP6yF2aWEzVz-lusaeyr4,7844
+setuptools/_distutils/ccompiler.py,sha256=xvBQgcsWvjt1gd3GH3RxrBxChITq-NKhFJKUVYQPWz0,48873
+setuptools/_distutils/cmd.py,sha256=sZeDnYHuZqykNMOlX4usslxJ4jwPjAXKJvXYu5o7tns,17877
+setuptools/_distutils/command/__init__.py,sha256=GfFAzbBqk1qxSH4BdaKioKS4hRRnD44BAmwEN85C4u8,386
+setuptools/_distutils/command/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/_framework_compat.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/bdist.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/build.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/build_clib.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/build_ext.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/build_py.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/build_scripts.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/check.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/clean.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/config.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install_data.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install_egg_info.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install_headers.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install_lib.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/install_scripts.cpython-310.pyc,,
+setuptools/_distutils/command/__pycache__/sdist.cpython-310.pyc,,
+setuptools/_distutils/command/_framework_compat.py,sha256=0iZdSJYzGRWCCvzRDKE-R0-_yaAYvFMd1ylXb2eYXug,1609
+setuptools/_distutils/command/bdist.py,sha256=kALmrhET0pRKlSqY3EdvF-Y0zz-iJUx4_jorH9Mdadk,5346
+setuptools/_distutils/command/bdist_dumb.py,sha256=Gi_d1Nz4l6Gz_xU4LRfRVRKBri22WoNPM7uYyX2ksdk,4582
+setuptools/_distutils/command/bdist_rpm.py,sha256=DfZgvPmm3PTAd39YzLeQ8fmbyRGaXo-nmnUzYEtccg0,21686
+setuptools/_distutils/command/build.py,sha256=_jUqG3GWKIddOeMVktPUtVv05hSBt-_0zLrTByu3_qA,5729
+setuptools/_distutils/command/build_clib.py,sha256=qTpvz-Db2wEjKkX_kPwYQzFUCoP5HZrcbLu4HGKTJ0o,7684
+setuptools/_distutils/command/build_ext.py,sha256=gs7TV3MAaG4hysPk24hUa7M6jZnJzFhi_kMIbwOnYLs,31758
+setuptools/_distutils/command/build_py.py,sha256=cNe8vwMhyPJ2gN6jot9cOY5OuUPUvT6j9fIFcC-Fcik,16552
+setuptools/_distutils/command/build_scripts.py,sha256=EHCVyCiP9APE9X74SkOWj4AdS5iBCue7PqpLQP86e1Y,5534
+setuptools/_distutils/command/check.py,sha256=OM9_pYSz62maIzl3LtzrtTQ658OZQ93sOls86ITghaI,4897
+setuptools/_distutils/command/clean.py,sha256=qlKth74jWLZjKa2nxOay_2Fua6MVNTroApaQOva2dwc,2595
+setuptools/_distutils/command/config.py,sha256=FKd2vUSVOp0rpVUer4bj6D94-fyxyF8HJxitRlZFc9c,13008
+setuptools/_distutils/command/install.py,sha256=TG_lbTbFim2mYt1lMgMNTD9ratag0OJ1GCtyuHpe7oo,30078
+setuptools/_distutils/command/install_data.py,sha256=TqzaoQ8PIj7tTc25WKPQ81aZvP_dTYY4p9r_tqtdmg8,2816
+setuptools/_distutils/command/install_egg_info.py,sha256=Sy2fuBqvCGlQVhJcUteGbdG0KCx2BBN7jAzWEMA9rp8,2788
+setuptools/_distutils/command/install_headers.py,sha256=Wmpw2npRNUGYPR1BAbRpRaFbDFFf-KKCEVzUGyEuyvY,1184
+setuptools/_distutils/command/install_lib.py,sha256=pKLNE1rnqdoSo8bq9efQbQuQprg5TGswFpvKka1F3Fg,8330
+setuptools/_distutils/command/install_scripts.py,sha256=Qw8KrC24mcIeJEvcBNKISMpi75npSm6jzW6BOzA9G7g,1937
+setuptools/_distutils/command/sdist.py,sha256=6Wlzz2rRAcug2Eu7uNOE9EO3b6I2QjElctClgjwZ5j8,18809
+setuptools/_distutils/compat/__init__.py,sha256=AhMdi3AzX62KYnNdOCcEuNXLuBOxhvOSQHtdji4g8z8,429
+setuptools/_distutils/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_distutils/compat/__pycache__/py38.cpython-310.pyc,,
+setuptools/_distutils/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/_distutils/compat/py38.py,sha256=QnIRFSvDKiQNGpQebTXKmC_2ZLumH08j5z8y8-J04VM,791
+setuptools/_distutils/compat/py39.py,sha256=hOsD6lwZLqZoMnacNJ3P6nUA-LJQhEpVtYTzVH0o96M,1964
+setuptools/_distutils/core.py,sha256=_MmZeNIbkopW0LdHtH7w3HSOI_XTzVhTiV8nAe3UW5w,9267
+setuptools/_distutils/cygwinccompiler.py,sha256=1LQO0p-AwDSNzLJk_KPIKp62eiDpkGZ4fMMs2N3o94w,11891
+setuptools/_distutils/debug.py,sha256=N6MrTAqK6l9SVk6tWweR108PM8Ol7qNlfyV-nHcLhsY,139
+setuptools/_distutils/dep_util.py,sha256=xN75p6ZpHhMiHEc-rpL2XilJQynHnDNiafHteaZ4tjU,349
+setuptools/_distutils/dir_util.py,sha256=zww0t31mfdXV7F1oAZFlddS25iKlgZWaNNMLKL8zElw,7407
+setuptools/_distutils/dist.py,sha256=Z51-FyibouJ2Xi2KVV9GGb1OufQyIdSWgR8QYLKHLuY,50553
+setuptools/_distutils/errors.py,sha256=bZ3cL1YpmYVHJYEgw8UM8vlsLMIpeAXqi6IDSV9Yqhw,3325
+setuptools/_distutils/extension.py,sha256=2SLJ8vzYZn_HPEAIUqExIdJ22ySxlYoEEejbrMoBBSc,10358
+setuptools/_distutils/fancy_getopt.py,sha256=FfBKjfzAXOwg1wJIVDBIoTgals9-XLpQdi-YbZS82Jw,17822
+setuptools/_distutils/file_util.py,sha256=jpPCdgpEN876TFSWEKPzEbj4hZrATpZKPQDOT4G-yHQ,7962
+setuptools/_distutils/filelist.py,sha256=PjeVfpvvjY00sOwofd4d79EUjmI_c7udePCL6REbYzM,13654
+setuptools/_distutils/log.py,sha256=VyBs5j7z4-K6XTEEBThUc9HyMpoPLGtQpERqbz5ylww,1200
+setuptools/_distutils/spawn.py,sha256=u5srFcVoBxOweFlWtZRjO9L__tRcOQvLH8DAel5kZSg,3625
+setuptools/_distutils/sysconfig.py,sha256=0rBnrkIMJc4ek_5sfaNOOACpR9bXOU9GxDAK3KLHkIs,19235
+setuptools/_distutils/tests/__init__.py,sha256=bE9qRiJgLJnfPLHIU21uY7uXYCcHY9dx-V0x1vNT_-M,1476
+setuptools/_distutils/tests/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/support.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_bdist.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_build.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_build_py.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_ccompiler.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_check.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_clean.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_cmd.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_core.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_cygwinccompiler.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_dist.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_extension.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_file_util.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_filelist.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_install.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_install_data.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_log.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_mingwccompiler.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_modified.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_msvccompiler.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_sdist.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_spawn.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_text_file.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_unixccompiler.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_util.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_version.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-310.pyc,,
+setuptools/_distutils/tests/__pycache__/unix_compat.cpython-310.pyc,,
+setuptools/_distutils/tests/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_distutils/tests/compat/__pycache__/py38.cpython-310.pyc,,
+setuptools/_distutils/tests/compat/py38.py,sha256=myShQTLl-DnyAjRDJrO44HdLaEoFkKIeReHiydCiHg4,1015
+setuptools/_distutils/tests/support.py,sha256=tjsYsyxvpTK4NrkCseh2ujvDIGV0Mf_b5SI5fP2T0yM,4099
+setuptools/_distutils/tests/test_archive_util.py,sha256=jozimSwPBF-JoJfN_vDaiVGZp66BNcWZGh34FlW57DQ,11787
+setuptools/_distutils/tests/test_bdist.py,sha256=xNHxUsLlHsZQRwkzLb_iSD24s-9Mk-NX2ffBWwOyPyc,1396
+setuptools/_distutils/tests/test_bdist_dumb.py,sha256=QF05MHNhPOdZyh88Xpw8KsO64s7pRFkl8KL-RoV4XK0,2247
+setuptools/_distutils/tests/test_bdist_rpm.py,sha256=YGv9442JC4K3Mh_f1xY6xx3XFZexdIkNdjNChC6_Fe4,3933
+setuptools/_distutils/tests/test_build.py,sha256=Lf66SO9Wi_exzKgsEE5WpVPgdNYHFr1ivOhKQ2gxC1o,1698
+setuptools/_distutils/tests/test_build_clib.py,sha256=Mo1ZFb4C1VXBYOGvnallwN7YCnTtr24akLDO8Zi4CsY,4331
+setuptools/_distutils/tests/test_build_ext.py,sha256=hyxOeHXp6sDb8CHxaGkR4---nP5nwbPtr9JoAJcT9YU,19961
+setuptools/_distutils/tests/test_build_py.py,sha256=NsfmRrojOHBXNMqWR_mp5g4PLTgjhD7iZFUffGZFIdw,6882
+setuptools/_distutils/tests/test_build_scripts.py,sha256=cD-FRy-oX55sXRX5Ez5xQCaeHrWajyKc4Xuwv2fe48w,2880
+setuptools/_distutils/tests/test_ccompiler.py,sha256=eVzZZE8JMIcl4OjwiuhdSNpNdKknAPOnlIe2DnFX-38,2964
+setuptools/_distutils/tests/test_check.py,sha256=hHSV07qf7YoSxGsTbbsUQ9tssZz5RRNdbrY1s2SwaFI,6226
+setuptools/_distutils/tests/test_clean.py,sha256=hPH6jfIpGFUrvWbF1txkiNVSNaAxt2wq5XjV499zO4E,1240
+setuptools/_distutils/tests/test_cmd.py,sha256=bgRB79mitoOKR1OiyZHnCogvGxt3pWkxeTqIC04lQWQ,3254
+setuptools/_distutils/tests/test_config_cmd.py,sha256=Zs6WX0IfxDvmuC19XzuVNnYCnTr9Y-hl73TAmDSBN4Y,2664
+setuptools/_distutils/tests/test_core.py,sha256=L7XKVAxa-MGoAZeANopnuK9fRKneYhkSQpgw8XQvcF8,3829
+setuptools/_distutils/tests/test_cygwinccompiler.py,sha256=iqxsDy0Z5ZTRgxM8ARzPXakitQod2V8aG5qet_J5tTg,2753
+setuptools/_distutils/tests/test_dir_util.py,sha256=IddXU78EoJPxHpl5wQ2TblSR0eooAYVcIRqqgAA8TLY,3822
+setuptools/_distutils/tests/test_dist.py,sha256=CFlBpbM3wJH2WjsgCGsTV4n5Z3BpfLSln6dixBxeqpM,18459
+setuptools/_distutils/tests/test_extension.py,sha256=SLJYnLhshfj4u72Q91E_5jnzVpbPljv6_xqV7yKB1Ds,3094
+setuptools/_distutils/tests/test_file_util.py,sha256=r3MNC-g3BZPKRZdHGMqSatM93D_aooTHBn-Vm4IiEDU,3502
+setuptools/_distutils/tests/test_filelist.py,sha256=Co8dDWCC5K_DUw5T6TQygBsh_PQVCoOlYQOcsl2agHc,10766
+setuptools/_distutils/tests/test_install.py,sha256=TfCB0ykhIxydIC2Q4SuTAZzSHvteMHgrBL9whoSgK9Q,8618
+setuptools/_distutils/tests/test_install_data.py,sha256=vKq3K97k0hBAnOg38nmwEdf7cEDVr9rTVyCeJolgb4A,2464
+setuptools/_distutils/tests/test_install_headers.py,sha256=PVAYpo_tYl980Qf64DPOmmSvyefIHdU06f7VsJeZykE,936
+setuptools/_distutils/tests/test_install_lib.py,sha256=qri6Rl-maNTQrNDV8DbeXNl0hjsfRIKiI4rfZLrmWBI,3612
+setuptools/_distutils/tests/test_install_scripts.py,sha256=KE3v0cDkFW-90IOID-OmZZGM2mhy-ZkEuuW7UXS2SHw,1600
+setuptools/_distutils/tests/test_log.py,sha256=isFtOufloCyEdZaQOV7cVUr46GwtdVMj43mGBB5XH7k,323
+setuptools/_distutils/tests/test_mingwccompiler.py,sha256=mBl8W8QIO2xy4eOj6aAEVom4lobwpHM-HvFUIXu6q0c,2202
+setuptools/_distutils/tests/test_modified.py,sha256=h1--bOWmtJo1bpVV6uRhdnS9br71CBiNDM1MDwSGpug,4221
+setuptools/_distutils/tests/test_msvccompiler.py,sha256=xUrfyCwCO57DEsxcoL6s-YG3YIZRllYsKuagZbBPFJ0,4301
+setuptools/_distutils/tests/test_sdist.py,sha256=InsbU09aeVdJtj8QywREnUZuV32bvi47eRmH3iWQwkk,15058
+setuptools/_distutils/tests/test_spawn.py,sha256=bxk4RmNWFmCnyYpAlqtG8VfXfk5TdzcjV53lOxFyyh4,4613
+setuptools/_distutils/tests/test_sysconfig.py,sha256=iH4Y9E8UHrfl3P-VSt0lbgJMlHuoQsIOorxrsVRQnE8,12010
+setuptools/_distutils/tests/test_text_file.py,sha256=WQWSB5AfdBDZaMA8BFgipJPnsJb_2SKMfL90fSkRVtw,3460
+setuptools/_distutils/tests/test_unixccompiler.py,sha256=wcJQJhXtkUUE3I64TyDvM3Yo7G9a0ug_Mp7DbZLwT4Q,11840
+setuptools/_distutils/tests/test_util.py,sha256=H9zlZ4z4Vh4TfjNYDBsxP7wguQLpxCfJYyOcm1yZU3c,7988
+setuptools/_distutils/tests/test_version.py,sha256=b0UMdMRBofyySAhUYnziYhImdB3CzsU7696brKDP0XM,2750
+setuptools/_distutils/tests/test_versionpredicate.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_distutils/tests/unix_compat.py,sha256=z-op6C2iVdX1aq5BIBR7cqOxijKE97alNwJqHNdLpoI,386
+setuptools/_distutils/text_file.py,sha256=EV8hDCetYeKq6c_uPfwGgkUw8hugeEoSJcXpy_EkQGo,12098
+setuptools/_distutils/unixccompiler.py,sha256=QJHNcQiMtWcOQ4WzupzIv1nQwBENo-bNkeVCSVmT4Jk,15437
+setuptools/_distutils/util.py,sha256=yFXCnYoJrLum-CouY8Q-axVMnalSFC1QvsSKpRpYAcU,17654
+setuptools/_distutils/version.py,sha256=KlbDjAvGBybVJqRDxNLNMvZLl5XL2FP0dpVjgzfm0zY,12634
+setuptools/_distutils/versionpredicate.py,sha256=qBWQ6wTj12ODytoTmIydefIY2jb4uY1sdbgbuLn-IJM,5205
+setuptools/_distutils/zosccompiler.py,sha256=bb2dQoGnsv4LmoQBfjhDsaOpt_p5R7y_28l1cltmG94,6589
+setuptools/_entry_points.py,sha256=Y3QUE9JKFW_YyquDnpffNWSs6f3jKEt1e-dnx--9-Kw,2310
+setuptools/_imp.py,sha256=b5sEz-EOJKApMsmb-yJPPgkGqZBeZFeLtoWhysLre-0,2441
+setuptools/_importlib.py,sha256=rrebj_YuvTeVM-A3gFJMp8lRgSAmD2fA-NPXVsxzt5w,327
+setuptools/_itertools.py,sha256=jWRfsIrpC7myooz3hDURj9GtvpswZeKXg2HakmEhNjo,657
+setuptools/_normalization.py,sha256=t-SeXc0jU2weQY9BA3qGlRThzBND1oYK5Hpzg1_533g,4536
+setuptools/_path.py,sha256=cjrnds-WCfAgBYPHh2FsnZF294pcKQnJiVa7VnqA4_I,2700
+setuptools/_reqs.py,sha256=Yp1pm07CHu1QUsoa6Cfa3m8B6LRZyonujt1CHb-uztQ,1411
+setuptools/_vendor/__pycache__/typing_extensions.cpython-310.pyc,,
+setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE,sha256=reeNBJgtaZctREqOFKlPh6IzTdOFXMgDSOqOJAqg3y0,7634
+setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA,sha256=OADZuR3O6iBlpu1ieTgzYul6w4uOVrk0P0BO5TGGAJk,15006
+setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD,sha256=giu6ZrQVJvpUcYa4AiH4XaUNZSvuVJPb_l0UCFES8MM,1308
+setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt,sha256=AzfhgKKS8EdAwWUTSF8mgeVQbXOY9kokHB6kSqwwqu0,12
+setuptools/_vendor/autocommand/__init__.py,sha256=zko5Rnvolvb-UXjCx_2ArPTGBWwUK5QY4LIQIKYR7As,1037
+setuptools/_vendor/autocommand/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-310.pyc,,
+setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-310.pyc,,
+setuptools/_vendor/autocommand/__pycache__/automain.cpython-310.pyc,,
+setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-310.pyc,,
+setuptools/_vendor/autocommand/__pycache__/errors.cpython-310.pyc,,
+setuptools/_vendor/autocommand/autoasync.py,sha256=AMdyrxNS4pqWJfP_xuoOcImOHWD-qT7x06wmKN1Vp-U,5680
+setuptools/_vendor/autocommand/autocommand.py,sha256=hmkEmQ72HtL55gnURVjDOnsfYlGd5lLXbvT4KG496Qw,2505
+setuptools/_vendor/autocommand/automain.py,sha256=A2b8i754Mxc_DjU9WFr6vqYDWlhz0cn8miu8d8EsxV8,2076
+setuptools/_vendor/autocommand/autoparse.py,sha256=WVWmZJPcbzUKXP40raQw_0HD8qPJ2V9VG1eFFmmnFxw,11642
+setuptools/_vendor/autocommand/errors.py,sha256=7aa3roh9Herd6nIKpQHNWEslWE8oq7GiHYVUuRqORnA,886
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA,sha256=ghXFTq132dxaEIolxr3HK1mZqm9iyUmaRANZQSr6WlE,2020
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD,sha256=JYofHISeEXUGmlWl1s41ev3QTjTNXeJwk-Ss7HqdLOE,1360
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt,sha256=cGjaLMOoBR1FK0ApojtzWVmViTtJ7JGIK_HwXiEsvtU,10
+setuptools/_vendor/backports/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81
+setuptools/_vendor/backports/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/backports/tarfile/__init__.py,sha256=Pwf2qUIfB0SolJPCKcx3vz3UEu_aids4g4sAfxy94qg,108491
+setuptools/_vendor/backports/tarfile/__main__.py,sha256=Yw2oGT1afrz2eBskzdPYL8ReB_3liApmhFkN2EbDmc4,59
+setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-310.pyc,,
+setuptools/_vendor/backports/tarfile/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-310.pyc,,
+setuptools/_vendor/backports/tarfile/compat/py38.py,sha256=iYkyt_gvWjLzGUTJD9TuTfMMjOk-ersXZmRlvQYN2qE,568
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/METADATA,sha256=anuQ7_7h4J1bSEzfcjIBakPi2cyVQ7y7jklLHsBeH1k,4648
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/RECORD,sha256=DY08buueu-hsrH1ghhVSQzwynanqUSSLYdAr4uXmQDA,2518
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+setuptools/_vendor/importlib_metadata-8.0.0.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19
+setuptools/_vendor/importlib_metadata/__init__.py,sha256=tZNB-23h8Bixi9uCrQqj9Yf0aeC--Josdy3IZRIQeB0,33798
+setuptools/_vendor/importlib_metadata/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_adapters.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_collections.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_compat.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_functools.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_itertools.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_meta.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/_text.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/__pycache__/diagnose.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/_adapters.py,sha256=rIhWTwBvYA1bV7i-5FfVX38qEXDTXFeS5cb5xJtP3ks,2317
+setuptools/_vendor/importlib_metadata/_collections.py,sha256=CJ0OTCHIjWA0ZIVS4voORAsn2R4R2cQBEtPsZEJpASY,743
+setuptools/_vendor/importlib_metadata/_compat.py,sha256=73QKrN9KNoaZzhbX5yPCCZa-FaALwXe8TPlDR72JgBU,1314
+setuptools/_vendor/importlib_metadata/_functools.py,sha256=PsY2-4rrKX4RVeRC1oGp1lB1pmC9eKN88_f-bD9uOoA,2895
+setuptools/_vendor/importlib_metadata/_itertools.py,sha256=cvr_2v8BRbxcIl5x5ldfqdHjhI8Yi8s8yk50G_nm6jQ,2068
+setuptools/_vendor/importlib_metadata/_meta.py,sha256=nxZ7C8GVlcBFAKWyVOn_dn7ot_twBcbm1NmvjIetBHI,1801
+setuptools/_vendor/importlib_metadata/_text.py,sha256=HCsFksZpJLeTP3NEk_ngrAeXVRRtTrtyh9eOABoRP4A,2166
+setuptools/_vendor/importlib_metadata/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_metadata/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/compat/__pycache__/py311.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/_vendor/importlib_metadata/compat/py311.py,sha256=uqm-K-uohyj1042TH4a9Er_I5o7667DvulcD-gC_fSA,608
+setuptools/_vendor/importlib_metadata/compat/py39.py,sha256=cPkMv6-0ilK-0Jw_Tkn0xYbOKJZc4WJKQHow0c2T44w,1102
+setuptools/_vendor/importlib_metadata/diagnose.py,sha256=nkSRMiowlmkhLYhKhvCg9glmt_11Cox-EmLzEbqYTa8,379
+setuptools/_vendor/importlib_metadata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/METADATA,sha256=g4eM2LuL0OiZcUVND0qwDJUpE29gOvtO3BSPXTbO9Fk,3944
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/RECORD,sha256=ln3Vb-6hQ_HSxOmKwfk3wFXmHJqgQlFG1V9618glEPo,7620
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/importlib_resources-6.4.0.dist-info/top_level.txt,sha256=fHIjHU1GZwAjvcydpmUnUrTnbvdiWjG4OEVZK8by0TQ,20
+setuptools/_vendor/importlib_resources/__init__.py,sha256=uyp1kzYR6SawQBsqlyaXXfIxJx4Z2mM8MjmZn8qq2Gk,505
+setuptools/_vendor/importlib_resources/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/_adapters.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/_common.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/_itertools.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/abc.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/functional.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/readers.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/__pycache__/simple.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/_adapters.py,sha256=vprJGbUeHbajX6XCuMP6J3lMrqCi-P_MTlziJUR7jfk,4482
+setuptools/_vendor/importlib_resources/_common.py,sha256=blt4-ZtHnbUPzQQyPP7jLGgl_86btIW5ZhIsEhclhoA,5571
+setuptools/_vendor/importlib_resources/_itertools.py,sha256=eDisV6RqiNZOogLSXf6LOGHOYc79FGgPrKNLzFLmCrU,1277
+setuptools/_vendor/importlib_resources/abc.py,sha256=UKNU9ncEDkZRB3txcGb3WLxsL2iju9JbaLTI-dfLE_4,5162
+setuptools/_vendor/importlib_resources/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/compat/__pycache__/py38.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/compat/py38.py,sha256=MWhut3XsAJwBYUaa5Qb2AoCrZNqcQjVThP-P1uBoE_4,230
+setuptools/_vendor/importlib_resources/compat/py39.py,sha256=Wfln4uQUShNz1XdCG-toG6_Y0WrlUmO9JzpvtcfQ-Cw,184
+setuptools/_vendor/importlib_resources/functional.py,sha256=mLU4DwSlh8_2IXWqwKOfPVxyRqAEpB3B4XTfRxr3X3M,2651
+setuptools/_vendor/importlib_resources/future/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/future/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/future/__pycache__/adapters.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/future/adapters.py,sha256=1-MF2VRcCButhcC1OMfZILU9o3kwZ4nXB2lurXpaIAw,2940
+setuptools/_vendor/importlib_resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/readers.py,sha256=WNKurBHHVu9EVtUhWkOj2fxH50HP7uanNFuupAqH2S8,5863
+setuptools/_vendor/importlib_resources/simple.py,sha256=CQ3TiIMFiJs_80o-7xJL1EpbUUVna4-NGDrSTQ3HW2Y,2584
+setuptools/_vendor/importlib_resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/_path.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_compatibilty_files.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_contents.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_custom.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_files.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_functional.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_open.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_path.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_read.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_reader.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/test_resource.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/util.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/__pycache__/zip.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/_path.py,sha256=nkv3ek7D1U898v921rYbldDCtKri2oyYOi3EJqGjEGU,1289
+setuptools/_vendor/importlib_resources/tests/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/compat/__pycache__/py312.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/compat/py312.py,sha256=qcWjpZhQo2oEsdwIlRRQHrsMGDltkFTnETeG7fLdUS8,364
+setuptools/_vendor/importlib_resources/tests/compat/py39.py,sha256=lRTk0RWAOEb9RzAgvdRnqJUGCBLc3qoFQwzuJSa_zP4,329
+setuptools/_vendor/importlib_resources/tests/data01/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/data01/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/data01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
+setuptools/_vendor/importlib_resources/tests/data01/subdirectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/data01/subdirectory/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/data01/subdirectory/binary.file,sha256=xtRM9Bj2EOP-nh2SlP9D3vgcbNytbLsYIM_0jTqkNV0,4
+setuptools/_vendor/importlib_resources/tests/data01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
+setuptools/_vendor/importlib_resources/tests/data01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
+setuptools/_vendor/importlib_resources/tests/data02/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/data02/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/data02/one/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/data02/one/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/data02/one/resource1.txt,sha256=10flKac7c-XXFzJ3t-AB5MJjlBy__dSZvPE_dOm2q6U,13
+setuptools/_vendor/importlib_resources/tests/data02/subdirectory/subsubdir/resource.txt,sha256=jnrBBztxYrtQck7cmVnc4xQVO4-agzAZDGSFkAWtlFw,10
+setuptools/_vendor/importlib_resources/tests/data02/two/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/importlib_resources/tests/data02/two/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/importlib_resources/tests/data02/two/resource2.txt,sha256=lt2jbN3TMn9QiFKM832X39bU_62UptDdUkoYzkvEbl0,13
+setuptools/_vendor/importlib_resources/tests/namespacedata01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
+setuptools/_vendor/importlib_resources/tests/namespacedata01/subdirectory/binary.file,sha256=cbkhEL8TXIVYHIoSj2oZwPasp1KwxskeNXGJnPCbFF0,4
+setuptools/_vendor/importlib_resources/tests/namespacedata01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
+setuptools/_vendor/importlib_resources/tests/namespacedata01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
+setuptools/_vendor/importlib_resources/tests/test_compatibilty_files.py,sha256=95N_R7aik8cvnE6sBJpsxmP0K5plOWRIJDgbalD-Hpw,3314
+setuptools/_vendor/importlib_resources/tests/test_contents.py,sha256=70HW3mL_hv05Emv-OgdmwoLhXxjtuVxiWVaUpgRaRWA,930
+setuptools/_vendor/importlib_resources/tests/test_custom.py,sha256=QrHZqIWl0e-fsQRfm0ych8stOlKJOsAIU3rK6QOcyN0,1221
+setuptools/_vendor/importlib_resources/tests/test_files.py,sha256=OcShYu33kCcyXlDyZSVPkJNE08h-N_4bQOLV2QaSqX0,3472
+setuptools/_vendor/importlib_resources/tests/test_functional.py,sha256=ByCVViAwb2PIlKvDNJEqTZ0aLZGpFl5qa7CMCX-7HKM,8591
+setuptools/_vendor/importlib_resources/tests/test_open.py,sha256=ccmzbOeEa6zTd4ymZZ8yISrecfuYV0jhon-Vddqysu4,2778
+setuptools/_vendor/importlib_resources/tests/test_path.py,sha256=x8r2gJxG3hFM9xCOFNkgmHYXxsMldMLTSW_AZYf1l-A,2009
+setuptools/_vendor/importlib_resources/tests/test_read.py,sha256=7tsILQ2NoqVGFQxhHqxBwc5hWcN8b_3idojCsszTNfQ,3112
+setuptools/_vendor/importlib_resources/tests/test_reader.py,sha256=IcIUXaiPAtuahGV4_ZT4YXFLMMsJmcM1iOxqdIH2Aa4,5001
+setuptools/_vendor/importlib_resources/tests/test_resource.py,sha256=fcF8WgZ6rDCTRFnxtAUbdiaNe4G23yGovT1nb2dc7ls,7823
+setuptools/_vendor/importlib_resources/tests/util.py,sha256=vjVzEyX0X2RkTN-wGiQiplayp9sZom4JDjJinTNewos,4745
+setuptools/_vendor/importlib_resources/tests/zip.py,sha256=2MKmF8-osXBJSnqcUTuAUek_-tSB3iKmIT9qPhcsOsM,783
+setuptools/_vendor/inflect-7.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/inflect-7.3.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/inflect-7.3.1.dist-info/METADATA,sha256=ZgMNY0WAZRs-U8wZiV2SMfjSKqBrMngXyDMs_CAwMwg,21079
+setuptools/_vendor/inflect-7.3.1.dist-info/RECORD,sha256=XXg0rBuiYSxoAQUP3lenuYsPNqz4jDwtTzdv2JEbMJE,943
+setuptools/_vendor/inflect-7.3.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+setuptools/_vendor/inflect-7.3.1.dist-info/top_level.txt,sha256=m52ujdp10CqT6jh1XQxZT6kEntcnv-7Tl7UiGNTzWZA,8
+setuptools/_vendor/inflect/__init__.py,sha256=Jxy1HJXZiZ85kHeLAhkmvz6EMTdFqBe-duvt34R6IOc,103796
+setuptools/_vendor/inflect/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/inflect/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/inflect/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/inflect/compat/__pycache__/py38.cpython-310.pyc,,
+setuptools/_vendor/inflect/compat/py38.py,sha256=oObVfVnWX9_OpnOuEJn1mFbJxVhwyR5epbiTNXDDaso,160
+setuptools/_vendor/inflect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/METADATA,sha256=IMUaliNsA5X1Ox9MXUWOagch5R4Wwb_3M7erp29dBtg,3933
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/RECORD,sha256=HptivXDkpfom6VlMu4CGD_7KPev-6Hc9rvp3TNJZygY,873
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+setuptools/_vendor/jaraco.collections-5.1.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/METADATA,sha256=xDtguJej0tN9iEXCUvxEJh2a7xceIRVBEakBLSr__tY,4020
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/RECORD,sha256=VRl7iKeEQyl7stgnp1uq50CzOJYlHYcoNdS0x17C9X4,641
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/jaraco.context-5.3.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/METADATA,sha256=i4aUaQDX-jjdEQK5wevhegyx8JyLfin2HyvaSk3FHso,2891
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/RECORD,sha256=YyqnwE98S8wBwCevW5vHb-iVj0oYEDW5V6O9MBS6JIs,843
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/jaraco.functools-4.0.1.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/METADATA,sha256=AzWdm6ViMfDOPoQMfLWn2zgBQSGJScyqeN29TcuWXVI,3658
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/RECORD,sha256=gW2UV0HcokYJk4jKPu10_AZnrLqjb3C1WbJJTDl5sfY,1500
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/jaraco.text-3.12.1.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7
+setuptools/_vendor/jaraco/__pycache__/context.cpython-310.pyc,,
+setuptools/_vendor/jaraco/collections/__init__.py,sha256=Pc1-SqjWm81ad1P0-GttpkwO_LWlnaY6gUq8gcKh2v0,26640
+setuptools/_vendor/jaraco/collections/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/jaraco/collections/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/jaraco/context.py,sha256=REoLIxDkO5MfEYowt_WoupNCRoxBS5v7YX2PbW8lIcs,9552
+setuptools/_vendor/jaraco/functools/__init__.py,sha256=hEAJaS2uSZRuF_JY4CxCHIYh79ZpxaPp9OiHyr9EJ1w,16642
+setuptools/_vendor/jaraco/functools/__init__.pyi,sha256=gk3dsgHzo5F_U74HzAvpNivFAPCkPJ1b2-yCd62dfnw,3878
+setuptools/_vendor/jaraco/functools/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/jaraco/functools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/jaraco/text/Lorem ipsum.txt,sha256=N_7c_79zxOufBY9HZ3yzMgOkNv-TkOTTio4BydrSjgs,1335
+setuptools/_vendor/jaraco/text/__init__.py,sha256=Y2YUqXR_orUoDaY4SkPRe6ZZhb5HUHB_Ah9RCNsVyho,16250
+setuptools/_vendor/jaraco/text/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/__pycache__/layouts.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/__pycache__/show-newlines.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/__pycache__/strip-prefix.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/__pycache__/to-dvorak.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/__pycache__/to-qwerty.cpython-310.pyc,,
+setuptools/_vendor/jaraco/text/layouts.py,sha256=HTC8aSTLZ7uXipyOXapRMC158juecjK6RVwitfmZ9_w,643
+setuptools/_vendor/jaraco/text/show-newlines.py,sha256=WGQa65e8lyhb92LUOLqVn6KaCtoeVgVws6WtSRmLk6w,904
+setuptools/_vendor/jaraco/text/strip-prefix.py,sha256=NfVXV8JVNo6nqcuYASfMV7_y4Eo8zMQqlCOGvAnRIVw,412
+setuptools/_vendor/jaraco/text/to-dvorak.py,sha256=1SNcbSsvISpXXg-LnybIHHY-RUFOQr36zcHkY1pWFqw,119
+setuptools/_vendor/jaraco/text/to-qwerty.py,sha256=s4UMQUnPwFn_dB5uZC27BurHOQcYondBfzIpVL5pEzw,119
+setuptools/_vendor/more_itertools-10.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/more_itertools-10.3.0.dist-info/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053
+setuptools/_vendor/more_itertools-10.3.0.dist-info/METADATA,sha256=BFO90O-fLNiVQMpj7oIS5ztzgJUUQZ3TA32P5HH3N-A,36293
+setuptools/_vendor/more_itertools-10.3.0.dist-info/RECORD,sha256=d8jnPgGNwP1-ntbICwWkQEVF9kH7CFIgzkKzaLWao9M,1259
+setuptools/_vendor/more_itertools-10.3.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/more_itertools-10.3.0.dist-info/WHEEL,sha256=rSgq_JpHF9fHR1lx53qwg_1-2LypZE_qmcuXbVUq948,81
+setuptools/_vendor/more_itertools/__init__.py,sha256=dtAbGjTDmn_ghiU5YXfhyDy0phAlXVdt5klZA5fUa-Q,149
+setuptools/_vendor/more_itertools/__init__.pyi,sha256=5B3eTzON1BBuOLob1vCflyEb2lSd6usXQQ-Cv-hXkeA,43
+setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/more_itertools/__pycache__/more.cpython-310.pyc,,
+setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-310.pyc,,
+setuptools/_vendor/more_itertools/more.py,sha256=1E5kzFncRKTDw0cYv1yRXMgDdunstLQd1QStcnL6U90,148370
+setuptools/_vendor/more_itertools/more.pyi,sha256=iXXeqt48Nxe8VGmIWpkVXuKpR2FYNuu2DU8nQLWCCu0,21484
+setuptools/_vendor/more_itertools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/more_itertools/recipes.py,sha256=WedhhfhGVgr6zii8fIbGJVmRTw0ZKRiLKnYBDGJv4nY,28591
+setuptools/_vendor/more_itertools/recipes.pyi,sha256=T_mdGpcFdfrP3JSWbwzYP9JyNV-Go-7RPfpxfftAWlA,4617
+setuptools/_vendor/packaging-24.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/packaging-24.1.dist-info/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197
+setuptools/_vendor/packaging-24.1.dist-info/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+setuptools/_vendor/packaging-24.1.dist-info/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344
+setuptools/_vendor/packaging-24.1.dist-info/METADATA,sha256=X3ooO3WnCfzNSBrqQjefCD1POAF1M2WSLmsHMgQlFdk,3204
+setuptools/_vendor/packaging-24.1.dist-info/RECORD,sha256=OKaJgwYpNifIHistipPl9oV9X37bc_AzTo2aU9rVO24,2565
+setuptools/_vendor/packaging-24.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/packaging-24.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+setuptools/_vendor/packaging/__init__.py,sha256=dtw2bNmWCQ9WnMoK3bk_elL1svSlikXtLpZhCFIB9SE,496
+setuptools/_vendor/packaging/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_elffile.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_parser.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_structures.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/_tokenizer.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/markers.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/metadata.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/requirements.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/tags.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/utils.cpython-310.pyc,,
+setuptools/_vendor/packaging/__pycache__/version.cpython-310.pyc,,
+setuptools/_vendor/packaging/_elffile.py,sha256=_LcJW4YNKywYsl4169B2ukKRqwxjxst_8H0FRVQKlz8,3282
+setuptools/_vendor/packaging/_manylinux.py,sha256=Xo4V0PZz8sbuVCbTni0t1CR0AHeir_7ib4lTmV8scD4,9586
+setuptools/_vendor/packaging/_musllinux.py,sha256=p9ZqNYiOItGee8KcZFeHF_YcdhVwGHdK6r-8lgixvGQ,2694
+setuptools/_vendor/packaging/_parser.py,sha256=s_TvTvDNK0NrM2QB3VKThdWFM4Nc0P6JnkObkl3MjpM,10236
+setuptools/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+setuptools/_vendor/packaging/_tokenizer.py,sha256=J6v5H7Jzvb-g81xp_2QACKwO7LxHQA6ikryMU7zXwN8,5273
+setuptools/_vendor/packaging/markers.py,sha256=dWKSqn5Sp-jDmOG-W3GfLHKjwhf1IsznbT71VlBoB5M,10671
+setuptools/_vendor/packaging/metadata.py,sha256=KINuSkJ12u-SyoKNTy_pHNGAfMUtxNvZ53qA1zAKcKI,32349
+setuptools/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/packaging/requirements.py,sha256=gYyRSAdbrIyKDY66ugIDUQjRMvxkH2ALioTmX3tnL6o,2947
+setuptools/_vendor/packaging/specifiers.py,sha256=rjpc3hoJuunRIT6DdH7gLTnQ5j5QKSuWjoTC5sdHtHI,39714
+setuptools/_vendor/packaging/tags.py,sha256=y8EbheOu9WS7s-MebaXMcHMF-jzsA_C1Lz5XRTiSy4w,18883
+setuptools/_vendor/packaging/utils.py,sha256=NAdYUwnlAOpkat_RthavX8a07YuVxgGL_vwrx73GSDM,5287
+setuptools/_vendor/packaging/version.py,sha256=V0H3SOj_8werrvorrb6QDLRhlcqSErNTTkCvvfszhDI,16198
+setuptools/_vendor/platformdirs-4.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/platformdirs-4.2.2.dist-info/METADATA,sha256=zmsie01G1MtXR0wgIv5XpVeTO7idr0WWvfmxKsKWuGk,11429
+setuptools/_vendor/platformdirs-4.2.2.dist-info/RECORD,sha256=TCEddtQu1A78Os_Mhm2JEqcYr7yit-UYSUQjZtbpn-g,1642
+setuptools/_vendor/platformdirs-4.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/platformdirs-4.2.2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/LICENSE,sha256=KeD9YukphQ6G6yjD_czwzv30-pSHkBHP-z0NS-1tTbY,1089
+setuptools/_vendor/platformdirs/__init__.py,sha256=EMGE8qeHRR9CzDFr8kL3tA8hdZZniYjXBVZd0UGTWK0,22225
+setuptools/_vendor/platformdirs/__main__.py,sha256=HnsUQHpiBaiTxwcmwVw-nFaPdVNZtQIdi1eWDtI-MzI,1493
+setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/android.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/api.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/version.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc,,
+setuptools/_vendor/platformdirs/android.py,sha256=xZXY9Jd46WOsxT2U6-5HsNtDZ-IQqxcEUrBLl3hYk4o,9016
+setuptools/_vendor/platformdirs/api.py,sha256=QBYdUac2eC521ek_y53uD1Dcq-lJX8IgSRVd4InC6uc,8996
+setuptools/_vendor/platformdirs/macos.py,sha256=wftsbsvq6nZ0WORXSiCrZNkRHz_WKuktl0a6mC7MFkI,5580
+setuptools/_vendor/platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/platformdirs/unix.py,sha256=Cci9Wqt35dAMsg6HT9nRGHSBW5obb0pR3AE1JJnsCXg,10643
+setuptools/_vendor/platformdirs/version.py,sha256=r7F76tZRjgQKzrpx_I0_ZMQOMU-PS7eGnHD7zEK3KB0,411
+setuptools/_vendor/platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125
+setuptools/_vendor/ruff.toml,sha256=XWlfZLXLxM4O_osKQZm4zOJlCmnKpl2W05Zbxz0Junc,16
+setuptools/_vendor/tomli-2.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/tomli-2.0.1.dist-info/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072
+setuptools/_vendor/tomli-2.0.1.dist-info/METADATA,sha256=zPDceKmPwJGLWtZykrHixL7WVXWmJGzZ1jyRT5lCoPI,8875
+setuptools/_vendor/tomli-2.0.1.dist-info/RECORD,sha256=DLn5pFGh42WsVLTIhmLh2gy1SnLRalJY-wq_-dPhwCI,999
+setuptools/_vendor/tomli-2.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/tomli-2.0.1.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
+setuptools/_vendor/tomli/__init__.py,sha256=JhUwV66DB1g4Hvt1UQCVMdfCu-IgAV8FXmvDU9onxd4,396
+setuptools/_vendor/tomli/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/tomli/__pycache__/_parser.cpython-310.pyc,,
+setuptools/_vendor/tomli/__pycache__/_re.cpython-310.pyc,,
+setuptools/_vendor/tomli/__pycache__/_types.cpython-310.pyc,,
+setuptools/_vendor/tomli/_parser.py,sha256=g9-ENaALS-B8dokYpCuzUFalWlog7T-SIYMjLZSWrtM,22633
+setuptools/_vendor/tomli/_re.py,sha256=dbjg5ChZT23Ka9z9DHOXfdtSpPwUfdgMXnj8NOoly-w,2943
+setuptools/_vendor/tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254
+setuptools/_vendor/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+setuptools/_vendor/typeguard-4.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/typeguard-4.3.0.dist-info/LICENSE,sha256=YWP3mH37ONa8MgzitwsvArhivEESZRbVUu8c1DJH51g,1130
+setuptools/_vendor/typeguard-4.3.0.dist-info/METADATA,sha256=z2dcHAp0TwhYCFU5Deh8x31nazElgujUz9tbuP0pjSE,3717
+setuptools/_vendor/typeguard-4.3.0.dist-info/RECORD,sha256=SKUZWVgkeDUidUKM7s1473fXmsna55bjmi6vJUAoJVI,2402
+setuptools/_vendor/typeguard-4.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/typeguard-4.3.0.dist-info/entry_points.txt,sha256=qp7NQ1aLtiSgMQqo6gWlfGpy0IIXzoMJmeQTLpzqFZQ,48
+setuptools/_vendor/typeguard-4.3.0.dist-info/top_level.txt,sha256=4z28AhuDodwRS_c1J_l8H51t5QuwfTseskYzlxp6grs,10
+setuptools/_vendor/typeguard/__init__.py,sha256=Onh4w38elPCjtlcU3JY9k3h70NjsxXIkAflmQn-Z0FY,2071
+setuptools/_vendor/typeguard/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_checkers.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_config.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_decorators.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_exceptions.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_functions.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_importhook.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_memo.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_pytest_plugin.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_suppression.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_transformer.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_union_transformer.cpython-310.pyc,,
+setuptools/_vendor/typeguard/__pycache__/_utils.cpython-310.pyc,,
+setuptools/_vendor/typeguard/_checkers.py,sha256=JRrgKicdOEfIBoNEtegYCEIlhpad-a1u1Em7GCj0WCI,31360
+setuptools/_vendor/typeguard/_config.py,sha256=nIz8QwDa-oFO3L9O8_6srzlmd99pSby2wOM4Wb7F_B0,2846
+setuptools/_vendor/typeguard/_decorators.py,sha256=v6dsIeWvPhExGLP_wXF-RmDUyjZf_Ak28g7gBJ_v0-0,9033
+setuptools/_vendor/typeguard/_exceptions.py,sha256=ZIPeiV-FBd5Emw2EaWd2Fvlsrwi4ocwT2fVGBIAtHcQ,1121
+setuptools/_vendor/typeguard/_functions.py,sha256=ibgSAKa5ptIm1eR9ARG0BSozAFJPFNASZqhPVyQeqig,10393
+setuptools/_vendor/typeguard/_importhook.py,sha256=ugjCDvFcdWMU7UugqlJG91IpVNpEIxtRr-99s0h1k7M,6389
+setuptools/_vendor/typeguard/_memo.py,sha256=1juQV_vxnD2JYKbSrebiQuj4oKHz6n67v9pYA-CCISg,1303
+setuptools/_vendor/typeguard/_pytest_plugin.py,sha256=-fcSqkv54rIfIF8pDavY5YQPkj4OX8GMt_lL7CQSD4I,4416
+setuptools/_vendor/typeguard/_suppression.py,sha256=VQfzxcwIbu3if0f7VBkKM7hkYOA7tNFw9a7jMBsmMg4,2266
+setuptools/_vendor/typeguard/_transformer.py,sha256=9Ha7_QhdwoUni_6hvdY-hZbuEergowHrNL2vzHIakFY,44937
+setuptools/_vendor/typeguard/_union_transformer.py,sha256=v_42r7-6HuRX2SoFwnyJ-E5PlxXpVeUJPJR1-HU9qSo,1354
+setuptools/_vendor/typeguard/_utils.py,sha256=5HhO1rPn5f1M6ymkVAEv7Xmlz1cX-j0OnTMlyHqqrR8,5270
+setuptools/_vendor/typeguard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjWx-N8TOznM9UGW5Gm2DicVpDtRA8W0,3018
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/RECORD,sha256=dxAALYGXHmMqpqL8M9xddKr118quIgQKZdPjFQOwXuk,571
+setuptools/_vendor/typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+setuptools/_vendor/typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451
+setuptools/_vendor/wheel-0.43.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/wheel-0.43.0.dist-info/LICENSE.txt,sha256=MMI2GGeRCPPo6h0qZYx8pBe9_IkcmO8aifpP8MmChlQ,1107
+setuptools/_vendor/wheel-0.43.0.dist-info/METADATA,sha256=WbrCKwClnT5WCKVrjPjvxDgxo2tyeS7kOJyc1GaceEE,2153
+setuptools/_vendor/wheel-0.43.0.dist-info/RECORD,sha256=eD5lR0JhGviM2fAL8BpDGiGdtTZVbmP_mBx71nMHCsk,4557
+setuptools/_vendor/wheel-0.43.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/wheel-0.43.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+setuptools/_vendor/wheel-0.43.0.dist-info/entry_points.txt,sha256=rTY1BbkPHhkGMm4Q3F0pIzJBzW2kMxoG1oriffvGdA0,104
+setuptools/_vendor/wheel/__init__.py,sha256=D6jhH00eMzbgrXGAeOwVfD5i-lCAMMycuG1L0useDlo,59
+setuptools/_vendor/wheel/__main__.py,sha256=NkMUnuTCGcOkgY0IBLgBCVC_BGGcWORx2K8jYGS12UE,455
+setuptools/_vendor/wheel/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/__main__.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/_setuptools_logging.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/bdist_wheel.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/macosx_libfile.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/metadata.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/util.cpython-310.pyc,,
+setuptools/_vendor/wheel/__pycache__/wheelfile.cpython-310.pyc,,
+setuptools/_vendor/wheel/_setuptools_logging.py,sha256=NoCnjJ4DFEZ45Eo-2BdXLsWJCwGkait1tp_17paleVw,746
+setuptools/_vendor/wheel/bdist_wheel.py,sha256=OKJyp9E831zJrxoRfmM9AgOjByG1CB-pzF5kXQFmaKk,20938
+setuptools/_vendor/wheel/cli/__init__.py,sha256=eBNhnPwWTtdKAJHy77lvz7gOQ5Eu3GavGugXxhSsn-U,4264
+setuptools/_vendor/wheel/cli/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/wheel/cli/__pycache__/convert.cpython-310.pyc,,
+setuptools/_vendor/wheel/cli/__pycache__/pack.cpython-310.pyc,,
+setuptools/_vendor/wheel/cli/__pycache__/tags.cpython-310.pyc,,
+setuptools/_vendor/wheel/cli/__pycache__/unpack.cpython-310.pyc,,
+setuptools/_vendor/wheel/cli/convert.py,sha256=qJcpYGKqdfw1P6BelgN1Hn_suNgM6bvyEWFlZeuSWx0,9439
+setuptools/_vendor/wheel/cli/pack.py,sha256=CAFcHdBVulvsHYJlndKVO7KMI9JqBTZz5ii0PKxxCOs,3103
+setuptools/_vendor/wheel/cli/tags.py,sha256=lHw-LaWrkS5Jy_qWcw-6pSjeNM6yAjDnqKI3E5JTTCU,4760
+setuptools/_vendor/wheel/cli/unpack.py,sha256=Y_J7ynxPSoFFTT7H0fMgbBlVErwyDGcObgme5MBuz58,1021
+setuptools/_vendor/wheel/macosx_libfile.py,sha256=HnW6OPdN993psStvwl49xtx2kw7hoVbe6nvwmf8WsKI,16103
+setuptools/_vendor/wheel/metadata.py,sha256=q-xCCqSAK7HzyZxK9A6_HAWmhqS1oB4BFw1-rHQxBiQ,5884
+setuptools/_vendor/wheel/util.py,sha256=e0jpnsbbM9QhaaMSyap-_ZgUxcxwpyLDk6RHcrduPLg,621
+setuptools/_vendor/wheel/vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/wheel/vendored/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_elffile.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_manylinux.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_musllinux.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_parser.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_structures.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/markers.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/requirements.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/specifiers.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/tags.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/utils.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/__pycache__/version.cpython-310.pyc,,
+setuptools/_vendor/wheel/vendored/packaging/_elffile.py,sha256=hbmK8OD6Z7fY6hwinHEUcD1by7czkGiNYu7ShnFEk2k,3266
+setuptools/_vendor/wheel/vendored/packaging/_manylinux.py,sha256=P7sdR5_7XBY09LVYYPhHmydMJIIwPXWsh4olk74Uuj4,9588
+setuptools/_vendor/wheel/vendored/packaging/_musllinux.py,sha256=z1s8To2hQ0vpn_d-O2i5qxGwEK8WmGlLt3d_26V7NeY,2674
+setuptools/_vendor/wheel/vendored/packaging/_parser.py,sha256=4tT4emSl2qTaU7VTQE1Xa9o1jMPCsBezsYBxyNMUN-s,10347
+setuptools/_vendor/wheel/vendored/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+setuptools/_vendor/wheel/vendored/packaging/_tokenizer.py,sha256=alCtbwXhOFAmFGZ6BQ-wCTSFoRAJ2z-ysIf7__MTJ_k,5292
+setuptools/_vendor/wheel/vendored/packaging/markers.py,sha256=_TSPI1BhJYO7Bp9AzTmHQxIqHEVXaTjmDh9G-w8qzPA,8232
+setuptools/_vendor/wheel/vendored/packaging/requirements.py,sha256=dgoBeVprPu2YE6Q8nGfwOPTjATHbRa_ZGLyXhFEln6Q,2933
+setuptools/_vendor/wheel/vendored/packaging/specifiers.py,sha256=IWSt0SrLSP72heWhAC8UL0eGvas7XIQHjqiViVfmPKE,39778
+setuptools/_vendor/wheel/vendored/packaging/tags.py,sha256=fedHXiOHkBxNZTXotXv8uXPmMFU9ae-TKBujgYHigcA,18950
+setuptools/_vendor/wheel/vendored/packaging/utils.py,sha256=XgdmP3yx9-wQEFjO7OvMj9RjEf5JlR5HFFR69v7SQ9E,5268
+setuptools/_vendor/wheel/vendored/packaging/version.py,sha256=PFJaYZDxBgyxkfYhH3SQw4qfE9ICCWrTmitvq14y3bs,16234
+setuptools/_vendor/wheel/vendored/vendor.txt,sha256=Z2ENjB1i5prfez8CdM1Sdr3c6Zxv2rRRolMpLmBncAE,16
+setuptools/_vendor/wheel/wheelfile.py,sha256=DtJDWoZMvnBh4leNMDPGOprQU9d_dp6q-MmV0U--4xc,7694
+setuptools/_vendor/zipp-3.19.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+setuptools/_vendor/zipp-3.19.2.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+setuptools/_vendor/zipp-3.19.2.dist-info/METADATA,sha256=UIrk_kMIHGSwsKKChYizqMw0MMZpPRZ2ZiVpQAsN_bE,3575
+setuptools/_vendor/zipp-3.19.2.dist-info/RECORD,sha256=8xby4D_ZrefrvAsVRwaEjiu4_VaLkJNRCfDY484rm_4,1039
+setuptools/_vendor/zipp-3.19.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/zipp-3.19.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+setuptools/_vendor/zipp-3.19.2.dist-info/top_level.txt,sha256=iAbdoSHfaGqBfVb2XuR9JqSQHCoOsOtG6y9C_LSpqFw,5
+setuptools/_vendor/zipp/__init__.py,sha256=QuI1g00G4fRAcGt-HqbV0oWIkmSgedCGGYsHHYzNa8A,13412
+setuptools/_vendor/zipp/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/zipp/__pycache__/glob.cpython-310.pyc,,
+setuptools/_vendor/zipp/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-310.pyc,,
+setuptools/_vendor/zipp/compat/py310.py,sha256=eZpkW0zRtunkhEh8jjX3gCGe22emoKCBJw72Zt4RkhA,219
+setuptools/_vendor/zipp/glob.py,sha256=etWpnfEoRyfUvrUsi6sTiGmErvPwe6HzY6pT8jg_lUI,3082
+setuptools/archive_util.py,sha256=8C7X1KZXphqLkVpZdgme8bm2U9CPQ3tmnxpWMpbH0mM,7332
+setuptools/build_meta.py,sha256=fqJx2glC_hPOq3Md2MXmkyPlbtARZCPxlbigDl5fehg,19151
+setuptools/cli-32.exe,sha256=MqzBvFQxFsviz_EMuGd3LfLyVP8mNMhwrvC0bEtpb9s,11776
+setuptools/cli-64.exe,sha256=u7PeVwdinmpgoMI4zUd7KPB_AGaYL9qVP6b87DkHOko,14336
+setuptools/cli-arm64.exe,sha256=uafQjaiA36yLz1SOuksG-1m28JsX0zFIoPZhgyiSbGE,13824
+setuptools/cli.exe,sha256=MqzBvFQxFsviz_EMuGd3LfLyVP8mNMhwrvC0bEtpb9s,11776
+setuptools/command/__init__.py,sha256=JbA5PmpnZ2AHQRFVT2rz5u_PjJFs5647GOIO5OuJzDQ,397
+setuptools/command/__pycache__/__init__.cpython-310.pyc,,
+setuptools/command/__pycache__/_requirestxt.cpython-310.pyc,,
+setuptools/command/__pycache__/alias.cpython-310.pyc,,
+setuptools/command/__pycache__/bdist_egg.cpython-310.pyc,,
+setuptools/command/__pycache__/bdist_rpm.cpython-310.pyc,,
+setuptools/command/__pycache__/bdist_wheel.cpython-310.pyc,,
+setuptools/command/__pycache__/build.cpython-310.pyc,,
+setuptools/command/__pycache__/build_clib.cpython-310.pyc,,
+setuptools/command/__pycache__/build_ext.cpython-310.pyc,,
+setuptools/command/__pycache__/build_py.cpython-310.pyc,,
+setuptools/command/__pycache__/develop.cpython-310.pyc,,
+setuptools/command/__pycache__/dist_info.cpython-310.pyc,,
+setuptools/command/__pycache__/easy_install.cpython-310.pyc,,
+setuptools/command/__pycache__/editable_wheel.cpython-310.pyc,,
+setuptools/command/__pycache__/egg_info.cpython-310.pyc,,
+setuptools/command/__pycache__/install.cpython-310.pyc,,
+setuptools/command/__pycache__/install_egg_info.cpython-310.pyc,,
+setuptools/command/__pycache__/install_lib.cpython-310.pyc,,
+setuptools/command/__pycache__/install_scripts.cpython-310.pyc,,
+setuptools/command/__pycache__/rotate.cpython-310.pyc,,
+setuptools/command/__pycache__/saveopts.cpython-310.pyc,,
+setuptools/command/__pycache__/sdist.cpython-310.pyc,,
+setuptools/command/__pycache__/setopt.cpython-310.pyc,,
+setuptools/command/__pycache__/test.cpython-310.pyc,,
+setuptools/command/_requirestxt.py,sha256=s2MIv5vWc7N_5mHziUIPvl6VjoPIUJsiv0cS4iXEy5M,4227
+setuptools/command/alias.py,sha256=aiGMw1AeN4rqJjr3Nr3SVDbLXjgjufriwcMM1nBmiHY,2383
+setuptools/command/bdist_egg.py,sha256=MmzT4GB9e7FUJ-KyoWyyDGRdk77qzsg8N1VQvVLx35E,16526
+setuptools/command/bdist_rpm.py,sha256=99wVFBa8EF3gHbEq10QojuYcpx3zX_NLCYZNpbG66GU,1427
+setuptools/command/bdist_wheel.py,sha256=6mufhh86czvNn3bGKg5gNvwc246zslcc0ZNjM2uclzg,22883
+setuptools/command/build.py,sha256=C9TQr7t_q3TehWscxEPUbXH7r08pCyN0tDq9rxPFoo4,6028
+setuptools/command/build_clib.py,sha256=vxp5WmzR6RQYmhXXyAz4w00w8N7xwCqPmauNukgzrJ0,4736
+setuptools/command/build_ext.py,sha256=DuH4NcgaQwV2si9-27uBWmad-0AdxC5U7cDe8TKpnIA,18264
+setuptools/command/build_py.py,sha256=G2Hxu-Wqzh6dxWbRjRHfES_SllYUGUKryH_0ECsx2VU,15327
+setuptools/command/develop.py,sha256=SSQxIKZXP7-kUOfTT4a3WIozssiDOivHQf61o034UO4,6854
+setuptools/command/dist_info.py,sha256=FueFqI-t7-KeP1E8PyG9A0f4tDCfrw0XXf7vnaYHjY4,3508
+setuptools/command/easy_install.py,sha256=JYpt8YTT-CqzNidQ4JyVifC8M_zfJ1iStdRcGyrmHbc,88305
+setuptools/command/editable_wheel.py,sha256=qE0zVk4qzIMC9Q18_Ui8ioJLa54UbdmFKqSxvGyR0mI,35665
+setuptools/command/egg_info.py,sha256=_vSpINMP8w5oeMr9kH7VqSDp6X8WFXhoyMj4BUs5E40,25610
+setuptools/command/install.py,sha256=qOT-JZSBS5te3tGjvXr3Aqgoghn6HI9w1Ud4SkMrVN0,6208
+setuptools/command/install_egg_info.py,sha256=brYRRGb0_8zJ3-fQ0fnkeXCzX2raLNX05Ja7n73cJJI,2046
+setuptools/command/install_lib.py,sha256=3-_JRnvnQxTD0lSV9AtnxokwtIpvNaPBlKGp2i5S5x8,4133
+setuptools/command/install_scripts.py,sha256=mQbIx9cuMISaEj2FOi6Yu7_u_q3go_beB6gphwBCrwI,2614
+setuptools/command/launcher manifest.xml,sha256=xlLbjWrB01tKC0-hlVkOKkiSPbzMml2eOPtJ_ucCnbE,628
+setuptools/command/rotate.py,sha256=9r8g3tkbvj7yOVkr6c2cmcxv5LNqyAijADbmjJ_Zy24,2145
+setuptools/command/saveopts.py,sha256=mVAPMRIGE98gl6eXQ3C2Wo-qPOgl9lbH-Q_YsbLuqeg,657
+setuptools/command/sdist.py,sha256=kGbGbvMnHm3GX8DMQAiKPyfvzWqtulWEnZN5bT22VGQ,7277
+setuptools/command/setopt.py,sha256=MjJy-0pCjnKCouYlg_ouTyB2HZn9Gz4CY0JupdXE3no,5019
+setuptools/command/test.py,sha256=k7xcq7D7bEehgxarbw-dW3AtmGZORqz8HjKR6FGJ3jk,1343
+setuptools/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/compat/__pycache__/py310.cpython-310.pyc,,
+setuptools/compat/__pycache__/py311.cpython-310.pyc,,
+setuptools/compat/__pycache__/py312.cpython-310.pyc,,
+setuptools/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/compat/py310.py,sha256=8sqwWczIcrkzeAbhaim4pKVd4tXZdcqmebgdvzji0rc,141
+setuptools/compat/py311.py,sha256=e6tJAFwZEP82hmMBl10HYeSypelo_Ti2wTjKZVKLwOE,790
+setuptools/compat/py312.py,sha256=vYKVtdrdOTsO_R90dJkEXsFwfMJFuIFJflhIgHrjJ-Y,366
+setuptools/compat/py39.py,sha256=BJMtnkfcqyTfccqjYQxfoRtU2nTnWaEESBVkshTiXqY,493
+setuptools/config/NOTICE,sha256=Ld3wiBgpejuJ1D2V_2WdjahXQRCMkTbfo6TYVsBiO9g,493
+setuptools/config/__init__.py,sha256=aiPnL9BJn1O6MfmuNXyn8W2Lp8u9qizRVqwPiOdPIjY,1499
+setuptools/config/__pycache__/__init__.cpython-310.pyc,,
+setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-310.pyc,,
+setuptools/config/__pycache__/expand.cpython-310.pyc,,
+setuptools/config/__pycache__/pyprojecttoml.cpython-310.pyc,,
+setuptools/config/__pycache__/setupcfg.cpython-310.pyc,,
+setuptools/config/_apply_pyprojecttoml.py,sha256=sdm57TbdKG1Dn9vXm1FftVLRzr-P5-qfBgOPz2CjRQI,15457
+setuptools/config/_validate_pyproject/NOTICE,sha256=Ccm86pXKCG-Lxb7RdOQLyDWyl9QPtfhru7Vw_gpVgac,18737
+setuptools/config/_validate_pyproject/__init__.py,sha256=dnp6T7ePP1R5z4OuC7Fd2dkFlIrtIfizUfvpGJP6nz0,1042
+setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/__pycache__/formats.cpython-310.pyc,,
+setuptools/config/_validate_pyproject/error_reporting.py,sha256=meldD7nBQdolQhvG-43r1Ue-gU1n7ORAJR86vh3Rrvk,11813
+setuptools/config/_validate_pyproject/extra_validations.py,sha256=kd0SWYrsp3IXF9KGAM8QpeaKpGyMsNgL-tjh9TPfhyY,1625
+setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py,sha256=w749JgqKi8clBFcObdcbZVqsmF4oJ_QByhZ1SGbUFNw,1612
+setuptools/config/_validate_pyproject/fastjsonschema_validations.py,sha256=T8RvJSi53YBfDB4mRPuF6gsPxx8-u8KYX56y3qokp_4,335460
+setuptools/config/_validate_pyproject/formats.py,sha256=Mjz6Rjx1BMDw2XTMAfS-sM5x5Fv5aX2Zk_q5M_7rf_c,12814
+setuptools/config/distutils.schema.json,sha256=Tcp32kRnhwORGw_9p6GEi08lj2h15tQRzOYBbzGmcBU,972
+setuptools/config/expand.py,sha256=jsZUUaU_8uy-ZzlJC0khmpGjCVRlbV-sFyMIk-SGYIQ,15659
+setuptools/config/pyprojecttoml.py,sha256=pxq-sYiMQPM9wAupcAFWExB473I-Z1U-ZpBsme1LAzM,18142
+setuptools/config/setupcfg.py,sha256=7DMAL0-vo4fT6_dpG1X20Kvi4S-cDjfHe5k_gzAnQUk,25634
+setuptools/config/setuptools.schema.json,sha256=dZBRuSEnZkatoVlt1kVwG8ocTeRdO7BD0xvOWKH54PY,16071
+setuptools/depends.py,sha256=IsPdLBE6XpptUyp8WtihOD8O-PBnr2RezeiKBFT5Stc,5542
+setuptools/discovery.py,sha256=kEBc8vqi1Zq8kIGH80q0Q_xp4fFdHabQQM2EGg2eGY0,21104
+setuptools/dist.py,sha256=6bzrVzhkPdnB1AKREjMH37deKyKperYVD15yT1H55NA,36729
+setuptools/errors.py,sha256=qdHD5FonhNM6gkd863-49YacSXkR_kzh3D0lY0h2VZI,2988
+setuptools/extension.py,sha256=d5oF8022TWEo0Z7WsT-Ffvry5w9bvfz1hm3P892_IdE,6457
+setuptools/glob.py,sha256=iMCy0lhirF29sz2fa9B6KVGVvUniy11SFpdLl1UCb-I,4852
+setuptools/gui-32.exe,sha256=hdrh6V13hF8stZvKw9Sv50u-TJGpvMW_SnHNQxBNvnw,11776
+setuptools/gui-64.exe,sha256=NHG2FA6txkEid9u-_j_vjDRaDxpZd2CGuAo2GMOoPjs,14336
+setuptools/gui-arm64.exe,sha256=5pT0dDQFyLWSb_RX22_n8aEt7HwWqcOGR4TT9OB64Jc,13824
+setuptools/gui.exe,sha256=hdrh6V13hF8stZvKw9Sv50u-TJGpvMW_SnHNQxBNvnw,11776
+setuptools/installer.py,sha256=WF8FZiQXP2rNs_LpX_8C_A8l7sZivn5Xzk9g6lQG2g4,4970
+setuptools/launch.py,sha256=VsYBvZhikv-o_uJc60yM-2_PCQB5P5vSFnLl5C5BJ5A,812
+setuptools/logging.py,sha256=BYKd0bzbiCvUB9XEtfCYaYh9F_QNpxYjRsF2Xmw51k8,1241
+setuptools/modified.py,sha256=GGzc71yEkfwLV1-HqXRwwsnzhnb97k1D3R7H8EE_0z4,190
+setuptools/monkey.py,sha256=fx7_00njkB2cCrdtTWqZDKzdKsTz9d9GHZtMBozgwOo,3573
+setuptools/msvc.py,sha256=Hl-0f3cuxY90s3d7HxWF6lgTp1G99O65weTw7JWQDEk,40791
+setuptools/namespaces.py,sha256=8NrxNa4ZrkfvhoIVTO2PzqLyhO6A1ClULDX6muw4s60,3155
+setuptools/package_index.py,sha256=9xqvwwBgse9Lq6R6IRcXqSWJSPIz_cHZz1pckNTgQnM,39051
+setuptools/sandbox.py,sha256=iPmzIPvHDl42cwFK0gnUpWkIzigXXjdTIy_8EYGgyQQ,14550
+setuptools/script (dev).tmpl,sha256=RUzQzCQUaXtwdLtYHWYbIQmOaES5Brqq1FvUA_tu-5I,218
+setuptools/script.tmpl,sha256=WGTt5piezO27c-Dbx6l5Q4T3Ff20A5z7872hv3aAhYY,138
+setuptools/tests/__init__.py,sha256=AnBfls2iJbTDQzmMKeLRt-9lxhaOHUVOZEgXv89Uwvs,335
+setuptools/tests/__pycache__/__init__.cpython-310.pyc,,
+setuptools/tests/__pycache__/contexts.cpython-310.pyc,,
+setuptools/tests/__pycache__/environment.cpython-310.pyc,,
+setuptools/tests/__pycache__/fixtures.cpython-310.pyc,,
+setuptools/tests/__pycache__/mod_with_constant.cpython-310.pyc,,
+setuptools/tests/__pycache__/namespaces.cpython-310.pyc,,
+setuptools/tests/__pycache__/script-with-bom.cpython-310.pyc,,
+setuptools/tests/__pycache__/server.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_archive_util.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_bdist_deprecations.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_bdist_egg.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_bdist_wheel.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_build.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_build_clib.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_build_ext.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_build_meta.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_build_py.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_config_discovery.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_core_metadata.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_depends.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_develop.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_dist.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_dist_info.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_distutils_adoption.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_easy_install.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_editable_install.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_egg_info.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_extern.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_find_packages.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_find_py_modules.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_glob.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_install_scripts.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_logging.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_manifest.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_namespaces.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_packageindex.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_sandbox.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_sdist.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_setopt.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_setuptools.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_unicode_utils.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_virtualenv.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_warnings.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_wheel.cpython-310.pyc,,
+setuptools/tests/__pycache__/test_windows_wrappers.cpython-310.pyc,,
+setuptools/tests/__pycache__/text.cpython-310.pyc,,
+setuptools/tests/__pycache__/textwrap.cpython-310.pyc,,
+setuptools/tests/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/tests/compat/__pycache__/__init__.cpython-310.pyc,,
+setuptools/tests/compat/__pycache__/py39.cpython-310.pyc,,
+setuptools/tests/compat/py39.py,sha256=eUy7_F-6KRTOIKl-veshUu6I0EdTSdBZMh0EV0lZ1-g,135
+setuptools/tests/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/tests/config/__pycache__/__init__.cpython-310.pyc,,
+setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-310.pyc,,
+setuptools/tests/config/__pycache__/test_expand.cpython-310.pyc,,
+setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-310.pyc,,
+setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-310.pyc,,
+setuptools/tests/config/__pycache__/test_setupcfg.cpython-310.pyc,,
+setuptools/tests/config/downloads/__init__.py,sha256=0WrIXZDfFnFkRVio3a-Z6RffRMZbc3AuJstWaTrorxg,1762
+setuptools/tests/config/downloads/__pycache__/__init__.cpython-310.pyc,,
+setuptools/tests/config/downloads/__pycache__/preload.cpython-310.pyc,,
+setuptools/tests/config/downloads/preload.py,sha256=sIGGZpY3cmMpMwiJYYYYHG2ifZJkvJgEotRFtiulV1I,450
+setuptools/tests/config/setupcfg_examples.txt,sha256=cAbVvCbkFZuTUL6xRRzRgqyB0rLvJTfvw3D30glo2OE,1912
+setuptools/tests/config/test_apply_pyprojecttoml.py,sha256=cV9zAjrZ__sBrtsT7GCnQLdKpsuubliZB-OhB6MCxMk,19258
+setuptools/tests/config/test_expand.py,sha256=yJmhq52MqTPEft6QOSlZR8yN6dkJVtlOcTo9D7pqGXU,8111
+setuptools/tests/config/test_pyprojecttoml.py,sha256=MxQewMcnZcZTZAhoJbGRMVvRs2eRlbHQsnAJBOqlHec,12398
+setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py,sha256=h3f9fPy-oxtC_HPgxtMGM1LgdFz01RYtTL47ubFZp5M,3072
+setuptools/tests/config/test_setupcfg.py,sha256=t12suujLW4E-xARDfExy01RmSkGF1l2lsBvXqhBPfts,33361
+setuptools/tests/contexts.py,sha256=TAdZKxmmodx1ExMVo01o4QpRjpIpo4X3IWKq_BnjxpU,3480
+setuptools/tests/environment.py,sha256=95_UtTaRiuvwYC9eXKEHbn02kDtZysvZq3UZJmPUj1I,3102
+setuptools/tests/fixtures.py,sha256=-V7iD6BeE2E0Rw6dVvTOCm36JG8ZTTnrXhN0GISlgrg,5197
+setuptools/tests/indexes/test_links_priority/external.html,sha256=eL9euOuE93JKZdqlXxBOlHbKwIuNuIdq7GBRpsaPMcU,92
+setuptools/tests/indexes/test_links_priority/simple/foobar/index.html,sha256=DD-TKr7UU4zAjHHz4VexYDNSAzR27levSh1c-k3ZdLE,174
+setuptools/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setuptools/tests/integration/__pycache__/__init__.cpython-310.pyc,,
+setuptools/tests/integration/__pycache__/helpers.cpython-310.pyc,,
+setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-310.pyc,,
+setuptools/tests/integration/helpers.py,sha256=3PHcS9SCA-fwVJmUP2ad5NQOttJAETI5Nnoc_xroO5k,2522
+setuptools/tests/integration/test_pip_install_sdist.py,sha256=ebz2JTvinbE0XKm-I3HaSkunm6oElNaIzcrTfvf6OYQ,8288
+setuptools/tests/mod_with_constant.py,sha256=X_Kj80M55w1tmQ4f7uZY91ZTALo4hKVT6EHxgYocUMQ,22
+setuptools/tests/namespaces.py,sha256=HPcI3nR5MCFWXpaADIJ1fwKxymcQgBkuw87Ic5PUSAQ,2774
+setuptools/tests/script-with-bom.py,sha256=hRRgIizEULGiG_ZTNoMY46HhKhxpWfy5FGcD6Qbh5fc,18
+setuptools/tests/server.py,sha256=ZRJOKKQGUoa03ijPFrFiqNId428Eb9uy_ysOZtagUNs,2403
+setuptools/tests/test_archive_util.py,sha256=buuKdY8XkW26Pe3IKAoBRGHG0MDumnuNoPg2WsAQzIg,845
+setuptools/tests/test_bdist_deprecations.py,sha256=75Xq3gYn79LIIyusEltbHan0bEgAt2e_CaL7KLS8-KQ,775
+setuptools/tests/test_bdist_egg.py,sha256=cdfZsWpFmDRSbZeVu-69T0QiCc-246rbUjtkuB7iBiY,1851
+setuptools/tests/test_bdist_wheel.py,sha256=D-TNi3NJhneWf0yJCmpZv2reP4fnufbJwU40MXsMaQk,19480
+setuptools/tests/test_build.py,sha256=wJgMz2hwHADcLFg-nXrwRVhus7hjmAeEGgrpIQwCGnA,798
+setuptools/tests/test_build_clib.py,sha256=bX51XRAf4uO7IuHFpjePnoK8mE74N2gsoeEqF-ofgws,3123
+setuptools/tests/test_build_ext.py,sha256=XpQPFBuhvXH71P6YaLmDx_jXzfDw6j17EKUrcq8vkZY,10036
+setuptools/tests/test_build_meta.py,sha256=ipLb-ewhoR2qnetFI8v2DZMgRJ6M6mqdg52Ohx6VVu0,33570
+setuptools/tests/test_build_py.py,sha256=2MOiPfZ9CvwIOd5TNV6hCq9UrXA3HXJm5vj5GK7opsw,14185
+setuptools/tests/test_config_discovery.py,sha256=52_HEdA97dgaMvudsnIZDy7IYZPvHb5k6Yf9AA1954A,22562
+setuptools/tests/test_core_metadata.py,sha256=7xWmlSgjI_r_tUscBVt-kg2JP10Et5hMNI0f8nMtKPA,12183
+setuptools/tests/test_depends.py,sha256=yQBXoQbNQlJit6mbRVoz6Bb553f3sNrq02lZimNz5XY,424
+setuptools/tests/test_develop.py,sha256=CLzXZ8-b5-VFTuau4P4yXEdLx1UdyTFcOfrV0qyUIdE,5142
+setuptools/tests/test_dist.py,sha256=nG7y41IulZ9pjH-biwOctcQOafpRbNYz0I5sDX8d1pA,8811
+setuptools/tests/test_dist_info.py,sha256=exqqU5XSksRiXjUu4mx1SmN-_jnPoIPPWwsLqBc8fQQ,7090
+setuptools/tests/test_distutils_adoption.py,sha256=ZpdJ2wCyq2zGxsBAcjT2X72Vsj0YXIpW-7fhynb361I,4747
+setuptools/tests/test_easy_install.py,sha256=0oUehGspDiGXOyiVDKg5LPYsNmtVUhZ8FOhBoNYnigs,53241
+setuptools/tests/test_editable_install.py,sha256=W2k8YmcO9sCZleIjEtL1b_e9M16KO5L9a1GgTmNx2uY,43304
+setuptools/tests/test_egg_info.py,sha256=MvJWvIn5YZRi3vQGph4SW0AGHCf73G3L3Hdz9AnAZwk,44145
+setuptools/tests/test_extern.py,sha256=rpKU6oCcksumLwf5TeKlDluFQ0TUfbPwTLQbpxcFrCU,296
+setuptools/tests/test_find_packages.py,sha256=CTLAcTzWGWBLCcd2aAsUVkvO3ibrlqexFBdDKOWPoq8,7819
+setuptools/tests/test_find_py_modules.py,sha256=zQjuhIG5TQN2SJPix9ARo4DL_w84Ln8QsHDUjjbrtAQ,2404
+setuptools/tests/test_glob.py,sha256=pXMUqidIfGG2TM-5Z9M2T7Dz_OLPD6X-aX8QiUpFv2U,881
+setuptools/tests/test_install_scripts.py,sha256=bJFXiOYmMd-7ZgB9Kueh_vmiiBtTD3jDFOCSkzSys9Q,3441
+setuptools/tests/test_logging.py,sha256=9MeqJ_jgQTlE9M4WN7YuFC9iYhKrT9fsJIaKG1L73p4,2095
+setuptools/tests/test_manifest.py,sha256=N4UY8Y1TvjOiKerLHSF6LkHuenXGl8tw6o-ivlj3e5A,18761
+setuptools/tests/test_namespaces.py,sha256=Y6utoe5PHHqL_DlgawqB9F8XpsUDPvvw1sQMenK04e0,4515
+setuptools/tests/test_packageindex.py,sha256=zewHXX48XhgYmOwFOshw0eNT40ShsUzt5MnYB9PzRHM,8975
+setuptools/tests/test_sandbox.py,sha256=sLaKBRkvQ3NpI0ZNewIjWiwCTmuuie8IPkJQyx-5kX0,4333
+setuptools/tests/test_sdist.py,sha256=JdADuT2MWiBSIcNLd3o9oC4y2XGP5FZIT9Dp89RdXT8,32440
+setuptools/tests/test_setopt.py,sha256=3VxxM4ATfP-P4AGnDjoWCnHr5-i9CSEQTFYU1-FTnvI,1365
+setuptools/tests/test_setuptools.py,sha256=OprrduUUgTxuTCwAsSI9TUmJJFjjtr-3b6uEuW5CNY8,8978
+setuptools/tests/test_unicode_utils.py,sha256=xWfEEl8jkQCt9othUTXJfFmdyATAFggJs2tTxjbumbw,316
+setuptools/tests/test_virtualenv.py,sha256=g-njC_9JTAs1YVx_1dGJ_Q6RlInO4qKVu9-XAgNb6TY,3730
+setuptools/tests/test_warnings.py,sha256=zwR2zcnCeCeDqILZlJOPAcuyPHoDvGu1OtOVYiLMk74,3347
+setuptools/tests/test_wheel.py,sha256=pV5nPUXyJ1EIGzrWUb5cMDwrKKK2DIf8e-04pGlR7YY,19259
+setuptools/tests/test_windows_wrappers.py,sha256=2FmgEfFGX5OV0kVOpPPEZICAL76TrcNbfa2uTCzs134,7894
+setuptools/tests/text.py,sha256=a12197pMVTvB6FAWQ0ujT8fIQiLIWJlFAl1UCaDUDfg,123
+setuptools/tests/textwrap.py,sha256=FNNNq_MiaEJx88PnsbJQIRxmj1qmgcAOCXXRsODPJN4,98
+setuptools/unicode_utils.py,sha256=aDvIZZPtMn3eC1cpS4ta0WugZSZ7spoKyxGqZd7AHzw,3181
+setuptools/version.py,sha256=WJCeUuyq74Aok2TeK9-OexZOu8XrlQy7-y0BEuWNovQ,161
+setuptools/warnings.py,sha256=Xz3eESrYEdP0dYlVerP8BA0es-UbkFRAE4gOnXUmxuI,3714
+setuptools/wheel.py,sha256=w-F8n9qddusDCadC8PWJlkZ5uvlXkaGytQgnkenZGiw,8628
+setuptools/windows_support.py,sha256=wW4IYLM1Bv7Z1MaauP2xmPjyy-wkmQnXdyvXscAf9fw,726

infer_4_30_0/lib/python3.10/site-packages/setuptools-75.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

infer_4_30_0/lib/python3.10/site-packages/setuptools-75.1.0.dist-info/entry_points.txt

@@ -0,0 +1,51 @@
+[distutils.commands]
+alias = setuptools.command.alias:alias
+bdist_egg = setuptools.command.bdist_egg:bdist_egg
+bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
+bdist_wheel = setuptools.command.bdist_wheel:bdist_wheel
+build = setuptools.command.build:build
+build_clib = setuptools.command.build_clib:build_clib
+build_ext = setuptools.command.build_ext:build_ext
+build_py = setuptools.command.build_py:build_py
+develop = setuptools.command.develop:develop
+dist_info = setuptools.command.dist_info:dist_info
+easy_install = setuptools.command.easy_install:easy_install
+editable_wheel = setuptools.command.editable_wheel:editable_wheel
+egg_info = setuptools.command.egg_info:egg_info
+install = setuptools.command.install:install
+install_egg_info = setuptools.command.install_egg_info:install_egg_info
+install_lib = setuptools.command.install_lib:install_lib
+install_scripts = setuptools.command.install_scripts:install_scripts
+rotate = setuptools.command.rotate:rotate
+saveopts = setuptools.command.saveopts:saveopts
+sdist = setuptools.command.sdist:sdist
+setopt = setuptools.command.setopt:setopt
+
+[distutils.setup_keywords]
+dependency_links = setuptools.dist:assert_string_list
+eager_resources = setuptools.dist:assert_string_list
+entry_points = setuptools.dist:check_entry_points
+exclude_package_data = setuptools.dist:check_package_data
+extras_require = setuptools.dist:check_extras
+include_package_data = setuptools.dist:assert_bool
+install_requires = setuptools.dist:check_requirements
+namespace_packages = setuptools.dist:check_nsp
+package_data = setuptools.dist:check_package_data
+packages = setuptools.dist:check_packages
+python_requires = setuptools.dist:check_specifier
+setup_requires = setuptools.dist:check_requirements
+use_2to3 = setuptools.dist:invalid_unless_false
+zip_safe = setuptools.dist:assert_bool
+
+[egg_info.writers]
+PKG-INFO = setuptools.command.egg_info:write_pkg_info
+dependency_links.txt = setuptools.command.egg_info:overwrite_arg
+eager_resources.txt = setuptools.command.egg_info:overwrite_arg
+entry_points.txt = setuptools.command.egg_info:write_entries
+namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
+requires.txt = setuptools.command.egg_info:write_requirements
+top_level.txt = setuptools.command.egg_info:write_toplevel_names
+
+[setuptools.finalize_distribution_options]
+keywords = setuptools.dist:Distribution._finalize_setup_keywords
+parent_finalize = setuptools.dist:_Distribution.finalize_options

infer_4_30_0/lib/python3.10/site-packages/setuptools-75.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+_distutils_hack
+pkg_resources
+setuptools

infer_4_30_0/lib/python3.10/site-packages/sympy/abc.py

@@ -0,0 +1,111 @@
+"""
+This module exports all latin and greek letters as Symbols, so you can
+conveniently do
+
+    >>> from sympy.abc import x, y
+
+instead of the slightly more clunky-looking
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x y')
+
+Caveats
+=======
+
+1. As of the time of writing this, the names ``O``, ``S``, ``I``, ``N``,
+``E``, and ``Q`` are colliding with names defined in SymPy. If you import them
+from both ``sympy.abc`` and ``sympy``, the second import will "win".
+This is an issue only for * imports, which should only be used for short-lived
+code such as interactive sessions and throwaway scripts that do not survive
+until the next SymPy upgrade, where ``sympy`` may contain a different set of
+names.
+
+2. This module does not define symbol names on demand, i.e.
+``from sympy.abc import foo`` will be reported as an error because
+``sympy.abc`` does not contain the name ``foo``. To get a symbol named ``foo``,
+you still need to use ``Symbol('foo')`` or ``symbols('foo')``.
+You can freely mix usage of ``sympy.abc`` and ``Symbol``/``symbols``, though
+sticking with one and only one way to get the symbols does tend to make the code
+more readable.
+
+The module also defines some special names to help detect which names clash
+with the default SymPy namespace.
+
+``_clash1`` defines all the single letter variables that clash with
+SymPy objects; ``_clash2`` defines the multi-letter clashing symbols;
+and ``_clash`` is the union of both. These can be passed for ``locals``
+during sympification if one desires Symbols rather than the non-Symbol
+objects for those names.
+
+Examples
+========
+
+>>> from sympy import S
+>>> from sympy.abc import _clash1, _clash2, _clash
+>>> S("Q & C", locals=_clash1)
+C & Q
+>>> S('pi(x)', locals=_clash2)
+pi(x)
+>>> S('pi(C, Q)', locals=_clash)
+pi(C, Q)
+
+"""
+
+from typing import Any, Dict as tDict
+
+import string
+
+from .core import Symbol, symbols
+from .core.alphabets import greeks
+from sympy.parsing.sympy_parser import null
+
+##### Symbol definitions #####
+
+# Implementation note: The easiest way to avoid typos in the symbols()
+# parameter is to copy it from the left-hand side of the assignment.
+
+a, b, c, d, e, f, g, h, i, j = symbols('a, b, c, d, e, f, g, h, i, j')
+k, l, m, n, o, p, q, r, s, t = symbols('k, l, m, n, o, p, q, r, s, t')
+u, v, w, x, y, z = symbols('u, v, w, x, y, z')
+
+A, B, C, D, E, F, G, H, I, J = symbols('A, B, C, D, E, F, G, H, I, J')
+K, L, M, N, O, P, Q, R, S, T = symbols('K, L, M, N, O, P, Q, R, S, T')
+U, V, W, X, Y, Z = symbols('U, V, W, X, Y, Z')
+
+alpha, beta, gamma, delta = symbols('alpha, beta, gamma, delta')
+epsilon, zeta, eta, theta = symbols('epsilon, zeta, eta, theta')
+iota, kappa, lamda, mu = symbols('iota, kappa, lamda, mu')
+nu, xi, omicron, pi = symbols('nu, xi, omicron, pi')
+rho, sigma, tau, upsilon = symbols('rho, sigma, tau, upsilon')
+phi, chi, psi, omega = symbols('phi, chi, psi, omega')
+
+
+##### Clashing-symbols diagnostics #####
+
+# We want to know which names in SymPy collide with those in here.
+# This is mostly for diagnosing SymPy's namespace during SymPy development.
+
+_latin = list(string.ascii_letters)
+# QOSINE should not be imported as they clash; gamma, pi and zeta clash, too
+_greek = list(greeks) # make a copy, so we can mutate it
+# Note: We import lamda since lambda is a reserved keyword in Python
+_greek.remove("lambda")
+_greek.append("lamda")
+
+ns: tDict[str, Any] = {}
+exec('from sympy import *', ns)
+_clash1: tDict[str, Any] = {}
+_clash2: tDict[str, Any] = {}
+while ns:
+    _k, _ = ns.popitem()
+    if _k in _greek:
+        _clash2[_k] = null
+        _greek.remove(_k)
+    elif _k in _latin:
+        _clash1[_k] = null
+        _latin.remove(_k)
+_clash = {}
+_clash.update(_clash1)
+_clash.update(_clash2)
+
+del _latin, _greek, Symbol, _k, null

infer_4_30_0/lib/python3.10/site-packages/sympy/conftest.py

@@ -0,0 +1,96 @@
+import sys
+
+sys._running_pytest = True  # type: ignore
+from sympy.external.importtools import version_tuple
+
+import pytest
+from sympy.core.cache import clear_cache, USE_CACHE
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.misc import ARCH
+import re
+
+try:
+    import hypothesis
+
+    hypothesis.settings.register_profile("sympy_hypothesis_profile", deadline=None)
+    hypothesis.settings.load_profile("sympy_hypothesis_profile")
+except ImportError:
+    raise ImportError(
+        "hypothesis is a required dependency to run the SymPy test suite. "
+        "Install it with 'pip install hypothesis' or 'conda install -c conda-forge hypothesis'"
+    )
+
+
+sp = re.compile(r"([0-9]+)/([1-9][0-9]*)")
+
+
+def process_split(config, items):
+    split = config.getoption("--split")
+    if not split:
+        return
+    m = sp.match(split)
+    if not m:
+        raise ValueError(
+            "split must be a string of the form a/b " "where a and b are ints."
+        )
+    i, t = map(int, m.groups())
+    start, end = (i - 1) * len(items) // t, i * len(items) // t
+
+    if i < t:
+        # remove elements from end of list first
+        del items[end:]
+    del items[:start]
+
+
+def pytest_report_header(config):
+    s = "architecture: %s\n" % ARCH
+    s += "cache:        %s\n" % USE_CACHE
+    version = ""
+    if GROUND_TYPES == "gmpy":
+        import gmpy2
+
+        version = gmpy2.version()
+    elif GROUND_TYPES == "flint":
+        try:
+            from flint import __version__
+        except ImportError:
+            version = "unknown"
+        else:
+            version = f'(python-flint=={__version__})'
+    s += "ground types: %s %s\n" % (GROUND_TYPES, version)
+    return s
+
+
+def pytest_terminal_summary(terminalreporter):
+    if terminalreporter.stats.get("error", None) or terminalreporter.stats.get(
+        "failed", None
+    ):
+        terminalreporter.write_sep(" ", "DO *NOT* COMMIT!", red=True, bold=True)
+
+
+def pytest_addoption(parser):
+    parser.addoption("--split", action="store", default="", help="split tests")
+
+
+def pytest_collection_modifyitems(config, items):
+    """pytest hook."""
+    # handle splits
+    process_split(config, items)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def file_clear_cache():
+    clear_cache()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def check_disabled(request):
+    if getattr(request.module, "disabled", False):
+        pytest.skip("test requirements not met.")
+    elif getattr(request.module, "ipython", False):
+        # need to check version and options for ipython tests
+        if (
+            version_tuple(pytest.__version__) < version_tuple("2.6.3")
+            and pytest.config.getvalue("-s") != "no"
+        ):
+            pytest.skip("run py.test with -s or upgrade to newer version.")

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/__init__.py

@@ -0,0 +1,20 @@
+"""This module contains functions which operate on discrete sequences.
+
+Transforms - ``fft``, ``ifft``, ``ntt``, ``intt``, ``fwht``, ``ifwht``,
+            ``mobius_transform``, ``inverse_mobius_transform``
+
+Convolutions - ``convolution``, ``convolution_fft``, ``convolution_ntt``,
+            ``convolution_fwht``, ``convolution_subset``,
+            ``covering_product``, ``intersecting_product``
+"""
+
+from .transforms import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from .convolutions import convolution, covering_product, intersecting_product
+
+__all__ = [
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform',
+
+    'convolution', 'covering_product', 'intersecting_product',
+]

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/convolutions.py

@@ -0,0 +1,597 @@
+"""
+Convolution (using **FFT**, **NTT**, **FWHT**), Subset Convolution,
+Covering Product, Intersecting Product
+"""
+
+from sympy.core import S, sympify, Rational
+from sympy.core.function import expand_mul
+from sympy.discrete.transforms import (
+    fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.external.gmpy import MPZ, lcm
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def convolution(a, b, cycle=0, dps=None, prime=None, dyadic=None, subset=None):
+    """
+    Performs convolution by determining the type of desired
+    convolution using hints.
+
+    Exactly one of ``dps``, ``prime``, ``dyadic``, ``subset`` arguments
+    should be specified explicitly for identifying the type of convolution,
+    and the argument ``cycle`` can be specified optionally.
+
+    For the default arguments, linear convolution is performed using **FFT**.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    cycle : Integer
+        Specifies the length for doing cyclic convolution.
+    dps : Integer
+        Specifies the number of decimal digits for precision for
+        performing **FFT** on the sequence.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for
+        performing **NTT** on the sequence.
+    dyadic : bool
+        Identifies the convolution type as dyadic (*bitwise-XOR*)
+        convolution, which is performed using **FWHT**.
+    subset : bool
+        Identifies the convolution type as subset convolution.
+
+    Examples
+    ========
+
+    >>> from sympy import convolution, symbols, S, I
+    >>> u, v, w, x, y, z = symbols('u v w x y z')
+
+    >>> convolution([1 + 2*I, 4 + 3*I], [S(5)/4, 6], dps=3)
+    [1.25 + 2.5*I, 11.0 + 15.8*I, 24.0 + 18.0*I]
+    >>> convolution([1, 2, 3], [4, 5, 6], cycle=3)
+    [31, 31, 28]
+
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1)
+    [1283, 19351, 14219]
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1, cycle=2)
+    [15502, 19351]
+
+    >>> convolution([u, v], [x, y, z], dyadic=True)
+    [u*x + v*y, u*y + v*x, u*z, v*z]
+    >>> convolution([u, v], [x, y, z], dyadic=True, cycle=2)
+    [u*x + u*z + v*y, u*y + v*x + v*z]
+
+    >>> convolution([u, v, w], [x, y, z], subset=True)
+    [u*x, u*y + v*x, u*z + w*x, v*z + w*y]
+    >>> convolution([u, v, w], [x, y, z], subset=True, cycle=3)
+    [u*x + v*z + w*y, u*y + v*x, u*z + w*x]
+
+    """
+
+    c = as_int(cycle)
+    if c < 0:
+        raise ValueError("The length for cyclic convolution "
+                        "must be non-negative")
+
+    dyadic = True if dyadic else None
+    subset = True if subset else None
+    if sum(x is not None for x in (prime, dps, dyadic, subset)) > 1:
+        raise TypeError("Ambiguity in determining the type of convolution")
+
+    if prime is not None:
+        ls = convolution_ntt(a, b, prime=prime)
+        return ls if not c else [sum(ls[i::c]) % prime for i in range(c)]
+
+    if dyadic:
+        ls = convolution_fwht(a, b)
+    elif subset:
+        ls = convolution_subset(a, b)
+    else:
+        def loop(a):
+            dens = []
+            for i in a:
+                if isinstance(i, Rational) and i.q - 1:
+                    dens.append(i.q)
+                elif not isinstance(i, int):
+                    return
+            if dens:
+                l = lcm(*dens)
+                return [i*l if type(i) is int else i.p*(l//i.q) for i in a], l
+            # no lcm of den to deal with
+            return a, 1
+        ls = None
+        da = loop(a)
+        if da is not None:
+            db = loop(b)
+            if db is not None:
+                (ia, ma), (ib, mb) = da, db
+                den = ma*mb
+                ls = convolution_int(ia, ib)
+                if den != 1:
+                    ls = [Rational(i, den) for i in ls]
+        if ls is None:
+            ls = convolution_fft(a, b, dps)
+
+    return ls if not c else [sum(ls[i::c]) for i in range(c)]
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                       Convolution for Complex domain                       #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fft(a, b, dps=None):
+    """
+    Performs linear convolution using Fast Fourier Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import S, I
+    >>> from sympy.discrete.convolutions import convolution_fft
+
+    >>> convolution_fft([2, 3], [4, 5])
+    [8, 22, 15]
+    >>> convolution_fft([2, 5], [6, 7, 3])
+    [12, 44, 41, 15]
+    >>> convolution_fft([1 + 2*I, 4 + 3*I], [S(5)/4, 6])
+    [5/4 + 5*I/2, 11 + 63*I/4, 24 + 18*I]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b = a[:], b[:]
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fft(a, dps), fft(b, dps)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifft(a, dps)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Convolution for GF(p)                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_ntt(a, b, prime):
+    """
+    Performs linear convolution using Number Theoretic Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.convolutions import convolution_ntt
+    >>> convolution_ntt([2, 3], [4, 5], prime=19*2**10 + 1)
+    [8, 22, 15]
+    >>> convolution_ntt([2, 5], [6, 7, 3], prime=19*2**10 + 1)
+    [12, 44, 41, 15]
+    >>> convolution_ntt([333, 555], [222, 666], prime=19*2**10 + 1)
+    [15555, 14219, 19404]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b, p = a[:], b[:], as_int(prime)
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [0]*(n - len(a))
+    b += [0]*(n - len(b))
+
+    a, b = ntt(a, p), ntt(b, p)
+    a = [x*y % p for x, y in zip(a, b)]
+    a = intt(a, p)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Convolution for 2**n-group                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fwht(a, b):
+    """
+    Performs dyadic (*bitwise-XOR*) convolution using Fast Walsh Hadamard
+    Transform.
+
+    The convolution is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I
+    >>> from sympy.discrete.convolutions import convolution_fwht
+
+    >>> u, v, x, y = symbols('u v x y')
+    >>> convolution_fwht([u, v], [x, y])
+    [u*x + v*y, u*y + v*x]
+
+    >>> convolution_fwht([2, 3], [4, 5])
+    [23, 22]
+    >>> convolution_fwht([2, 5 + 4*I, 7], [6*I, 7, 3 + 4*I])
+    [56 + 68*I, -10 + 30*I, 6 + 50*I, 48 + 32*I]
+
+    >>> convolution_fwht([S(33)/7, S(55)/6, S(7)/4], [S(2)/3, 5])
+    [2057/42, 1870/63, 7/6, 35/4]
+
+    References
+    ==========
+
+    .. [1] https://www.radioeng.cz/fulltexts/2002/02_03_40_42.pdf
+    .. [2] https://en.wikipedia.org/wiki/Hadamard_transform
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fwht(a), fwht(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifwht(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Subset Convolution                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_subset(a, b):
+    """
+    Performs Subset Convolution of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S
+    >>> from sympy.discrete.convolutions import convolution_subset
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> convolution_subset([u, v], [x, y])
+    [u*x, u*y + v*x]
+    >>> convolution_subset([u, v, x], [y, z])
+    [u*y, u*z + v*y, x*y, x*z]
+
+    >>> convolution_subset([1, S(2)/3], [3, 4])
+    [3, 6]
+    >>> convolution_subset([1, 3, S(5)/7], [7])
+    [7, 21, 5, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    if not iterable(a) or not iterable(b):
+        raise TypeError("Expected a sequence of coefficients for convolution")
+
+    a = [sympify(arg) for arg in a]
+    b = [sympify(arg) for arg in b]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    c = [S.Zero]*n
+
+    for mask in range(n):
+        smask = mask
+        while smask > 0:
+            c[mask] += expand_mul(a[smask] * b[mask^smask])
+            smask = (smask - 1)&mask
+
+        c[mask] += expand_mul(a[smask] * b[mask^smask])
+
+    return c
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Covering Product                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def covering_product(a, b):
+    """
+    Returns the covering product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The covering product of given sequences is a sequence which contains
+    the sum of products of the elements of the given sequences grouped by
+    the *bitwise-OR* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which covering product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, covering_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> covering_product([u, v], [x, y])
+    [u*x, u*y + v*x + v*y]
+    >>> covering_product([u, v, x], [y, z])
+    [u*y, u*z + v*y + v*z, x*y, x*z]
+
+    >>> covering_product([1, S(2)/3], [3, 4 + 5*I])
+    [3, 26/3 + 25*I/3]
+    >>> covering_product([1, 3, S(5)/7], [7, 8])
+    [7, 53, 5, 40/7]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a), mobius_transform(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Intersecting Product                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def intersecting_product(a, b):
+    """
+    Returns the intersecting product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The intersecting product of given sequences is the sequence which
+    contains the sum of products of the elements of the given sequences
+    grouped by the *bitwise-AND* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which intersecting product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, intersecting_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> intersecting_product([u, v], [x, y])
+    [u*x + u*y + v*x, v*y]
+    >>> intersecting_product([u, v, x], [y, z])
+    [u*y + u*z + v*y + x*y + x*z, v*z, 0, 0]
+
+    >>> intersecting_product([1, S(2)/3], [3, 4 + 5*I])
+    [9 + 5*I, 8/3 + 10*I/3]
+    >>> intersecting_product([1, 3, S(5)/7], [7, 8])
+    [327/7, 24, 0, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a, subset=False), mobius_transform(b, subset=False)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a, subset=False)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Integer Convolutions                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_int(a, b):
+    """Return the convolution of two sequences as a list.
+
+    The iterables must consist solely of integers.
+
+    Parameters
+    ==========
+
+    a, b : Sequence
+        The sequences for which convolution is performed.
+
+    Explanation
+    ===========
+
+    This function performs the convolution of ``a`` and ``b`` by packing
+    each into a single integer, multiplying them together, and then
+    unpacking the result from the product.  The intuition behind this is
+    that if we evaluate some polynomial [1]:
+
+    .. math ::
+        1156x^6 + 3808x^5 + 8440x^4 + 14856x^3 + 16164x^2 + 14040x + 8100
+
+    at say $x = 10^5$ we obtain $1156038080844014856161641404008100$.
+    Note we can read of the coefficients for each term every five digits.
+    If the $x$ we chose to evaluate at is large enough, the same will hold
+    for the product.
+
+    The idea now is since big integer multiplication in libraries such
+    as GMP is highly optimised, this will be reasonably fast.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.convolutions import convolution_int
+
+    >>> convolution_int([2, 3], [4, 5])
+    [8, 22, 15]
+    >>> convolution_int([1, 1, -1], [1, 1])
+    [1, 2, 0, -1]
+
+    References
+    ==========
+
+    .. [1] Fateman, Richard J.
+           Can you save time in multiplying polynomials by encoding them as integers?
+           University of California, Berkeley, California (2004).
+           https://people.eecs.berkeley.edu/~fateman/papers/polysbyGMP.pdf
+    """
+    # An upper bound on the largest coefficient in p(x)q(x) is given by (1 + min(dp, dq))N(p)N(q)
+    # where dp = deg(p), dq = deg(q), N(f) denotes the coefficient of largest modulus in f [1]
+    B = max(abs(c) for c in a)*max(abs(c) for c in b)*(1 + min(len(a) - 1, len(b) - 1))
+    x, power = MPZ(1), 0
+    while x <= (2*B):  # multiply by two for negative coefficients, see [1]
+        x <<= 1
+        power += 1
+
+    def to_integer(poly):
+        n, mul = MPZ(0), 0
+        for c in reversed(poly):
+            if c and not mul: mul = -1 if c < 0 else 1
+            n <<= power
+            n += mul*int(c)
+        return mul, n
+
+    # Perform packing and multiplication
+    (a_mul, a_packed), (b_mul, b_packed) = to_integer(a), to_integer(b)
+    result = a_packed * b_packed
+
+    # Perform unpacking
+    mul = a_mul * b_mul
+    mask, half, borrow, poly = x - 1, x >> 1, 0, []
+    while result or borrow:
+        coeff = (result & mask) + borrow
+        result >>= power
+        borrow = coeff >= half
+        poly.append(mul * int(coeff if coeff < half else coeff - x))
+    return poly or [0]

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/tests/test_convolutions.py

@@ -0,0 +1,392 @@
+from sympy.core.numbers import (E, Rational, pi)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, symbols, I
+from sympy.discrete.convolutions import (
+    convolution, convolution_fft, convolution_ntt, convolution_fwht,
+    convolution_subset, covering_product, intersecting_product,
+    convolution_int)
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+def test_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+    c = [3, 5, 3, 7, 8]
+    d = [1422, 6572, 3213, 5552]
+    e = [-1, Rational(5, 3), Rational(7, 5)]
+
+    assert convolution(a, b) == convolution_fft(a, b)
+    assert convolution(a, b, dps=9) == convolution_fft(a, b, dps=9)
+    assert convolution(a, d, dps=7) == convolution_fft(d, a, dps=7)
+    assert convolution(a, d[1:], dps=3) == convolution_fft(d[1:], a, dps=3)
+
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+
+    # ntt
+    assert convolution(d, b, prime=q) == convolution_ntt(b, d, prime=q)
+    assert convolution(c, b, prime=p) == convolution_ntt(b, c, prime=p)
+    assert convolution(d, c, prime=p) == convolution_ntt(c, d, prime=p)
+    raises(TypeError, lambda: convolution(b, d, dps=5, prime=q))
+    raises(TypeError, lambda: convolution(b, d, dps=6, prime=q))
+
+    # fwht
+    assert convolution(a, b, dyadic=True) == convolution_fwht(a, b)
+    assert convolution(a, b, dyadic=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(b, d, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, d, prime=p, dyadic=True))
+    raises(TypeError, lambda: convolution(a, b, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, c, prime=p, dyadic=True))
+
+    # subset
+    assert convolution(a, b, subset=True) == convolution_subset(a, b) == \
+            convolution(a, b, subset=True, dyadic=False) == \
+                convolution(a, b, subset=True)
+    assert convolution(a, b, subset=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(a, b, subset=True, dyadic=True))
+    raises(TypeError, lambda: convolution(c, d, subset=True, dps=6))
+    raises(TypeError, lambda: convolution(a, c, subset=True, prime=q))
+
+    # integer
+    assert convolution([0], [0]) == convolution_int([0], [0])
+    assert convolution(b, c) == convolution_int(b, c)
+
+    # rational
+    assert convolution([Rational(1,2)], [Rational(1,2)]) == [Rational(1, 4)]
+    assert convolution(b, e) == [-9, 10, Rational(239, 15), Rational(34, 3),
+                                 Rational(32, 3), Rational(43, 5), Rational(113, 15),
+                                 Rational(14, 5)]
+
+
+def test_cyclic_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=0) == \
+            convolution([1, 2, 3], [4, 5, 6], cycle=5) == \
+                convolution([1, 2, 3], [4, 5, 6])
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=3) == [31, 31, 28]
+
+    a = [Rational(1, 3), Rational(7, 3), Rational(5, 9), Rational(2, 7), Rational(5, 8)]
+    b = [Rational(3, 5), Rational(4, 7), Rational(7, 8), Rational(8, 9)]
+
+    assert convolution(a, b, cycle=0) == \
+            convolution(a, b, cycle=len(a) + len(b) - 1)
+
+    assert convolution(a, b, cycle=4) == [Rational(87277, 26460), Rational(30521, 11340),
+                            Rational(11125, 4032), Rational(3653, 1080)]
+
+    assert convolution(a, b, cycle=6) == [Rational(20177, 20160), Rational(676, 315), Rational(47, 24),
+                            Rational(3053, 1080), Rational(16397, 5292), Rational(2497, 2268)]
+
+    assert convolution(a, b, cycle=9) == \
+                convolution(a, b, cycle=0) + [S.Zero]
+
+    # ntt
+    a = [2313, 5323532, S(3232), 42142, 42242421]
+    b = [S(33456), 56757, 45754, 432423]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=0) == \
+            convolution(a, b, prime=19*2**10 + 1, cycle=8) == \
+                convolution(a, b, prime=19*2**10 + 1)
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=5) == [96, 17146, 2664,
+                                                                    15534, 3517]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=7) == [4643, 3458, 1260,
+                                                        15534, 3517, 16314, 13688]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=9) == \
+            convolution(a, b, prime=19*2**10 + 1) + [0]
+
+    # fwht
+    u, v, w, x, y = symbols('u v w x y')
+    p, q, r, s, t = symbols('p q r s t')
+    c = [u, v, w, x, y]
+    d = [p, q, r, s, t]
+
+    assert convolution(a, b, dyadic=True, cycle=3) == \
+                        [2499522285783, 19861417974796, 4702176579021]
+
+    assert convolution(a, b, dyadic=True, cycle=5) == [2718149225143,
+            2114320852171, 20571217906407, 246166418903, 1413262436976]
+
+    assert convolution(c, d, dyadic=True, cycle=4) == \
+            [p*u + p*y + q*v + r*w + s*x + t*u + t*y,
+             p*v + q*u + q*y + r*x + s*w + t*v,
+             p*w + q*x + r*u + r*y + s*v + t*w,
+             p*x + q*w + r*v + s*u + s*y + t*x]
+
+    assert convolution(c, d, dyadic=True, cycle=6) == \
+            [p*u + q*v + r*w + r*y + s*x + t*w + t*y,
+             p*v + q*u + r*x + s*w + s*y + t*x,
+             p*w + q*x + r*u + s*v,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u,
+             q*y + t*v]
+
+    # subset
+    assert convolution(a, b, subset=True, cycle=7) == [18266671799811,
+                    178235365533, 213958794, 246166418903, 1413262436976,
+                    2397553088697, 1932759730434]
+
+    assert convolution(a[1:], b, subset=True, cycle=4) == \
+            [178104086592, 302255835516, 244982785880, 3717819845434]
+
+    assert convolution(a, b[:-1], subset=True, cycle=6) == [1932837114162,
+            178235365533, 213958794, 245166224504, 1413262436976, 2397553088697]
+
+    assert convolution(c, d, subset=True, cycle=3) == \
+            [p*u + p*x + q*w + r*v + r*y + s*u + t*w,
+             p*v + p*y + q*u + s*y + t*u + t*x,
+             p*w + q*y + r*u + t*v]
+
+    assert convolution(c, d, subset=True, cycle=5) == \
+            [p*u + q*y + t*v,
+             p*v + q*u + r*y + t*w,
+             p*w + r*u + s*y + t*x,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u]
+
+    raises(ValueError, lambda: convolution([1, 2, 3], [4, 5, 6], cycle=-1))
+
+
+def test_convolution_fft():
+    assert all(convolution_fft([], x, dps=y) == [] for x in ([], [1]) for y in (None, 3))
+    assert convolution_fft([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_fft([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_fft([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+
+    assert convolution_fft([1 + 2*I], [2 + 3*I]) == [-4 + 7*I]
+    assert convolution_fft([1 + 2*I, 3 + 4*I, 5 + 3*I/5], [Rational(2, 5) + 4*I/7]) == \
+            [Rational(-26, 35) + I*48/35, Rational(-38, 35) + I*116/35, Rational(58, 35) + I*542/175]
+
+    assert convolution_fft([Rational(3, 4), Rational(5, 6)], [Rational(7, 8), Rational(1, 3), Rational(2, 5)]) == \
+                                    [Rational(21, 32), Rational(47, 48), Rational(26, 45), Rational(1, 3)]
+
+    assert convolution_fft([Rational(1, 9), Rational(2, 3), Rational(3, 5)], [Rational(2, 5), Rational(3, 7), Rational(4, 9)]) == \
+                                [Rational(2, 45), Rational(11, 35), Rational(8152, 14175), Rational(523, 945), Rational(4, 15)]
+
+    assert convolution_fft([pi, E, sqrt(2)], [sqrt(3), 1/pi, 1/E]) == \
+                    [sqrt(3)*pi, 1 + sqrt(3)*E, E/pi + pi*exp(-1) + sqrt(6),
+                                            sqrt(2)/pi + 1, sqrt(2)*exp(-1)]
+
+    assert convolution_fft([2321, 33123], [5321, 6321, 71323]) == \
+                        [12350041, 190918524, 374911166, 2362431729]
+
+    assert convolution_fft([312313, 31278232], [32139631, 319631]) == \
+                        [10037624576503, 1005370659728895, 9997492572392]
+
+    raises(TypeError, lambda: convolution_fft(x, y))
+    raises(ValueError, lambda: convolution_fft([x, y], [y, x]))
+
+
+def test_convolution_ntt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+    r = 2*500000003 + 1 # only for sequences of length 1 or 2
+    # s = 2*3*5*7 # composite modulus
+
+    assert all(convolution_ntt([], x, prime=y) == [] for x in ([], [1]) for y in (p, q, r))
+    assert convolution_ntt([2], [3], r) == [6]
+    assert convolution_ntt([2, 3], [4], r) == [8, 12]
+
+    assert convolution_ntt([32121, 42144, 4214, 4241], [32132, 3232, 87242], p) == [33867619,
+                                    459741727, 79180879, 831885249, 381344700, 369993322]
+    assert convolution_ntt([121913, 3171831, 31888131, 12], [17882, 21292, 29921, 312], q) == \
+                                                [8158, 3065, 3682, 7090, 1239, 2232, 3744]
+
+    assert convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], q)
+    assert convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], q)
+
+    raises(ValueError, lambda: convolution_ntt([2, 3], [4, 5], r))
+    raises(ValueError, lambda: convolution_ntt([x, y], [y, x], q))
+    raises(TypeError, lambda: convolution_ntt(x, y, p))
+
+
+def test_convolution_fwht():
+    assert convolution_fwht([], []) == []
+    assert convolution_fwht([], [1]) == []
+    assert convolution_fwht([1, 2, 3], [4, 5, 6]) == [32, 13, 18, 27]
+
+    assert convolution_fwht([Rational(5, 7), Rational(6, 8), Rational(7, 3)], [2, 4, Rational(6, 7)]) == \
+                                    [Rational(45, 7), Rational(61, 14), Rational(776, 147), Rational(419, 42)]
+
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5), 4 + 5*I]
+    b = [94, 51, 53, 45, 31, 27, 13]
+    c = [3 + 4*I, 5 + 7*I, 3, Rational(7, 6), 8]
+
+    assert convolution_fwht(a, b) == [53*sqrt(3) + 366 + 155*I,
+                                    45*sqrt(3) + Rational(5848, 15) + 135*I,
+                                    94*sqrt(3) + Rational(1257, 5) + 65*I,
+                                    51*sqrt(3) + Rational(3974, 15),
+                                    13*sqrt(3) + 452 + 470*I,
+                                    Rational(4513, 15) + 255*I,
+                                    31*sqrt(3) + Rational(1314, 5) + 265*I,
+                                    27*sqrt(3) + Rational(3676, 15) + 225*I]
+
+    assert convolution_fwht(b, c) == [Rational(1993, 2) + 733*I, Rational(6215, 6) + 862*I,
+        Rational(1659, 2) + 527*I, Rational(1988, 3) + 551*I, 1019 + 313*I, Rational(3955, 6) + 325*I,
+        Rational(1175, 2) + 52*I, Rational(3253, 6) + 91*I]
+
+    assert convolution_fwht(a[3:], c) == [Rational(-54, 5) + I*293/5, -1 + I*204/5,
+            Rational(133, 15) + I*35/6, Rational(409, 30) + 15*I, Rational(56, 5), 32 + 40*I, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_fwht([u, v], [x, y]) == [u*x + v*y, u*y + v*x]
+
+    assert convolution_fwht([u, v, w], [x, y]) == \
+        [u*x + v*y, u*y + v*x, w*x, w*y]
+
+    assert convolution_fwht([u, v, w], [x, y, z]) == \
+        [u*x + v*y + w*z, u*y + v*x, u*z + w*x, v*z + w*y]
+
+    raises(TypeError, lambda: convolution_fwht(x, y))
+    raises(TypeError, lambda: convolution_fwht(x*y, u + v))
+
+
+def test_convolution_subset():
+    assert convolution_subset([], []) == []
+    assert convolution_subset([], [Rational(1, 3)]) == []
+    assert convolution_subset([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 3), sqrt(3), 4 + 5*I]
+    b = [64, 71, 55, 47, 33, 29, 15]
+    c = [3 + I*2/3, 5 + 7*I, 7, Rational(7, 5), 9]
+
+    assert convolution_subset(a, b) == [64, Rational(533, 3), 55 + 64*sqrt(3),
+                                        71*sqrt(3) + Rational(1184, 3) + 320*I, 33, 84,
+                                        15 + 33*sqrt(3), 29*sqrt(3) + 157 + 165*I]
+
+    assert convolution_subset(b, c) == [192 + I*128/3, 533 + I*1486/3,
+                                        613 + I*110/3, Rational(5013, 5) + I*1249/3,
+                                        675 + 22*I, 891 + I*751/3,
+                                        771 + 10*I, Rational(3736, 5) + 105*I]
+
+    assert convolution_subset(a, c) == convolution_subset(c, a)
+    assert convolution_subset(a[:2], b) == \
+            [64, Rational(533, 3), 55, Rational(416, 3), 33, 84, 15, 25]
+
+    assert convolution_subset(a[:2], c) == \
+            [3 + I*2/3, 10 + I*73/9, 7, Rational(196, 15), 9, 15, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_subset([u, v, w], [x, y]) == [u*x, u*y + v*x, w*x, w*y]
+    assert convolution_subset([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y, w*y, w*z + x*y]
+
+    assert convolution_subset([u, v], [x, y, z]) == \
+                    convolution_subset([x, y, z], [u, v])
+
+    raises(TypeError, lambda: convolution_subset(x, z))
+    raises(TypeError, lambda: convolution_subset(Rational(7, 3), u))
+
+
+def test_covering_product():
+    assert covering_product([], []) == []
+    assert covering_product([], [Rational(1, 3)]) == []
+    assert covering_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 8), sqrt(7), 4 + 9*I]
+    b = [66, 81, 95, 49, 37, 89, 17]
+    c = [3 + I*2/3, 51 + 72*I, 7, Rational(7, 15), 91]
+
+    assert covering_product(a, b) == [66, Rational(1383, 8), 95 + 161*sqrt(7),
+                                        130*sqrt(7) + 1303 + 2619*I, 37,
+                                        Rational(671, 4), 17 + 54*sqrt(7),
+                                        89*sqrt(7) + Rational(4661, 8) + 1287*I]
+
+    assert covering_product(b, c) == [198 + 44*I, 7740 + 10638*I,
+                                        1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                        9484 + I*74/3, 22163 + I*27394/3,
+                                        10621 + I*34/3, Rational(90236, 15) + 1224*I]
+
+    assert covering_product(a, c) == covering_product(c, a)
+    assert covering_product(b, c[:-1]) == [198 + 44*I, 7740 + 10638*I,
+                                         1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                         111 + I*74/3, 6693 + I*27394/3,
+                                         429 + I*34/3, Rational(23351, 15) + 1224*I]
+
+    assert covering_product(a, c[:-1]) == [3 + I*2/3,
+                            Rational(339, 4) + I*1409/12, 7 + 10*sqrt(7) + 2*sqrt(7)*I/3,
+                            -403 + 772*sqrt(7)/15 + 72*sqrt(7)*I + I*12658/15]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert covering_product([u, v, w], [x, y]) == \
+                            [u*x, u*y + v*x + v*y, w*x, w*y]
+
+    assert covering_product([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y + v*z, w*y, w*z + x*y + x*z]
+
+    assert covering_product([u, v], [x, y, z]) == \
+                    covering_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: covering_product(x, z))
+    raises(TypeError, lambda: covering_product(Rational(7, 3), u))
+
+
+def test_intersecting_product():
+    assert intersecting_product([], []) == []
+    assert intersecting_product([], [Rational(1, 3)]) == []
+    assert intersecting_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, sqrt(5), Rational(3, 8) + 5*I, 4 + 7*I]
+    b = [67, 51, 65, 48, 36, 79, 27]
+    c = [3 + I*2/5, 5 + 9*I, 7, Rational(7, 19), 13]
+
+    assert intersecting_product(a, b) == [195*sqrt(5) + Rational(6979, 8) + 1886*I,
+                                178*sqrt(5) + 520 + 910*I, Rational(841, 2) + 1344*I,
+                                192 + 336*I, 0, 0, 0, 0]
+
+    assert intersecting_product(b, c) == [Rational(128553, 19) + I*9521/5,
+                Rational(17820, 19) + 1602*I, Rational(19264, 19), Rational(336, 19), 1846, 0, 0, 0]
+
+    assert intersecting_product(a, c) == intersecting_product(c, a)
+    assert intersecting_product(b[1:], c[:-1]) == [Rational(64788, 19) + I*8622/5,
+                    Rational(12804, 19) + 1152*I, Rational(11508, 19), Rational(252, 19), 0, 0, 0, 0]
+
+    assert intersecting_product(a, c[:-2]) == \
+                    [Rational(-99, 5) + 10*sqrt(5) + 2*sqrt(5)*I/5 + I*3021/40,
+                    -43 + 5*sqrt(5) + 9*sqrt(5)*I + 71*I, Rational(245, 8) + 84*I, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert intersecting_product([u, v, w], [x, y]) == \
+                            [u*x + u*y + v*x + w*x + w*y, v*y, 0, 0]
+
+    assert intersecting_product([u, v, w, x], [y, z]) == \
+                        [u*y + u*z + v*y + w*y + w*z + x*y, v*z + x*z, 0, 0]
+
+    assert intersecting_product([u, v], [x, y, z]) == \
+                    intersecting_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: intersecting_product(x, z))
+    raises(TypeError, lambda: intersecting_product(u, Rational(8, 3)))
+
+
+def test_convolution_int():
+    assert convolution_int([1], [1]) == [1]
+    assert convolution_int([1, 1], [0]) == [0]
+    assert convolution_int([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_int([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_int([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+    assert convolution_int([10, -5, 1, 3], [-5, 6, 7]) == [-50, 85, 35, -44, 25, 21]
+    assert convolution_int([0, 1, 0, -1], [1, 0, -1, 0]) == [0, 1, 0, -2, 0, 1]
+    assert convolution_int(
+        [-341, -5, 1, 3, -71, -99, 43, 87],
+        [5, 6, 7, 12, 345, 21, -78, -7, -89]
+    ) == [-1705, -2071, -2412, -4106, -118035, -9774, 25998, 2981, 5509,
+          -34317, 19228, 38870, 5485, 1724, -4436, -7743]

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/tests/test_recurrences.py

@@ -0,0 +1,59 @@
+from sympy.core.numbers import Rational
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.core import S, symbols
+from sympy.testing.pytest import raises
+from sympy.discrete.recurrences import linrec
+
+def test_linrec():
+    assert linrec(coeffs=[1, 1], init=[1, 1], n=20) == 10946
+    assert linrec(coeffs=[1, 2, 3, 4, 5], init=[1, 1, 0, 2], n=10) == 1040
+    assert linrec(coeffs=[0, 0, 11, 13], init=[23, 27], n=25) == 59628567384
+    assert linrec(coeffs=[0, 0, 1, 1, 2], init=[1, 5, 3], n=15) == 165
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=70) == \
+        56889923441670659718376223533331214868804815612050381493741233489928913241
+    assert linrec(coeffs=[0]*55 + [1, 1, 2, 3], init=[0]*50 + [1, 2, 3], n=4000) == \
+        702633573874937994980598979769135096432444135301118916539
+
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**4)
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**5)
+
+    assert all(linrec(coeffs=[1, 1], init=[0, 1], n=n) == fibonacci(n)
+                                                    for n in range(95, 115))
+
+    assert all(linrec(coeffs=[1, 1], init=[1, 1], n=n) == fibonacci(n + 1)
+                                                    for n in range(595, 615))
+
+    a = [S.Half, Rational(3, 4), Rational(5, 6), 7, Rational(8, 9), Rational(3, 5)]
+    b = [1, 2, 8, Rational(5, 7), Rational(3, 7), Rational(2, 9), 6]
+    x, y, z = symbols('x y z')
+
+    assert linrec(coeffs=a[:5], init=b[:4], n=80) == \
+        Rational(1726244235456268979436592226626304376013002142588105090705187189,
+            1960143456748895967474334873705475211264)
+
+    assert linrec(coeffs=a[:4], init=b[:4], n=50) == \
+        Rational(368949940033050147080268092104304441, 504857282956046106624)
+
+    assert linrec(coeffs=a[3:], init=b[:3], n=35) == \
+        Rational(97409272177295731943657945116791049305244422833125109,
+            814315512679031689453125)
+
+    assert linrec(coeffs=[0]*60 + [Rational(2, 3), Rational(4, 5)], init=b, n=3000) == \
+        Rational(26777668739896791448594650497024, 48084516708184142230517578125)
+
+    raises(TypeError, lambda: linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4, 5], n=1))
+    raises(TypeError, lambda: linrec(coeffs=a[:4], init=b[:5], n=10000))
+    raises(ValueError, lambda: linrec(coeffs=a[:4], init=b[:4], n=-10000))
+    raises(TypeError, lambda: linrec(x, b, n=10000))
+    raises(TypeError, lambda: linrec(a, y, n=10000))
+
+    assert linrec(coeffs=[x, y, z], init=[1, 1, 1], n=4) == \
+        x**2  + x*y + x*z + y + z
+    assert linrec(coeffs=[1, 2, 1], init=[x, y, z], n=20) == \
+        269542*x + 664575*y + 578949*z
+    assert linrec(coeffs=[0, 3, 1, 2], init=[x, y], n=30) == \
+        58516436*x + 56372788*y
+    assert linrec(coeffs=[0]*50 + [1, 2, 3], init=[x, y, z], n=1000) == \
+        11477135884896*x + 25999077948732*y + 41975630244216*z
+    assert linrec(coeffs=[], init=[1, 1], n=20) == 0
+    assert linrec(coeffs=[x, y, z], init=[1, 2, 3], n=2) == 3

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/tests/test_transforms.py

@@ -0,0 +1,154 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, Symbol, symbols, I, Rational
+from sympy.discrete import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.testing.pytest import raises
+
+
+def test_fft_ifft():
+    assert all(tf(ls) == ls for tf in (fft, ifft)
+                            for ls in ([], [Rational(5, 3)]))
+
+    ls = list(range(6))
+    fls = [15, -7*sqrt(2)/2 - 4 - sqrt(2)*I/2 + 2*I, 2 + 3*I,
+             -4 + 7*sqrt(2)/2 - 2*I - sqrt(2)*I/2, -3,
+             -4 + 7*sqrt(2)/2 + sqrt(2)*I/2 + 2*I,
+              2 - 3*I, -7*sqrt(2)/2 - 4 - 2*I + sqrt(2)*I/2]
+
+    assert fft(ls) == fls
+    assert ifft(fls) == ls + [S.Zero]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    ifls = [Rational(9, 4) + 3*I, I*Rational(-7, 4), Rational(3, 4) + I, -2 - I/4]
+
+    assert ifft(ls) == ifls
+    assert fft(ifls) == ls + [S.Zero]
+
+    x = Symbol('x', real=True)
+    raises(TypeError, lambda: fft(x))
+    raises(ValueError, lambda: ifft([x, 2*x, 3*x**2, 4*x**3]))
+
+
+def test_ntt_intt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 2*500000003 + 1 # only for sequences of length 1 or 2
+    r = 2*3*5*7 # composite modulus
+
+    assert all(tf(ls, p) == ls for tf in (ntt, intt)
+                                for ls in ([], [5]))
+
+    ls = list(range(6))
+    nls = [15, 801133602, 738493201, 334102277, 998244350, 849020224,
+            259751156, 12232587]
+
+    assert ntt(ls, p) == nls
+    assert intt(nls, p) == ls + [0]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    x = Symbol('x', integer=True)
+
+    raises(TypeError, lambda: ntt(x, p))
+    raises(ValueError, lambda: intt([x, 2*x, 3*x**2, 4*x**3], p))
+    raises(ValueError, lambda: intt(ls, p))
+    raises(ValueError, lambda: ntt([1.2, 2.1, 3.5], p))
+    raises(ValueError, lambda: ntt([3, 5, 6], q))
+    raises(ValueError, lambda: ntt([4, 5, 7], r))
+    raises(ValueError, lambda: ntt([1.0, 2.0, 3.0], p))
+
+
+def test_fwht_ifwht():
+    assert all(tf(ls) == ls for tf in (fwht, ifwht) \
+                        for ls in ([], [Rational(7, 4)]))
+
+    ls = [213, 321, 43235, 5325, 312, 53]
+    fls = [49459, 38061, -47661, -37759, 48729, 37543, -48391, -38277]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*2
+
+    ls = [S.Half + 2*I, Rational(3, 7) + 4*I, Rational(5, 6) + 6*I, Rational(7, 3), Rational(9, 4)]
+    ifls = [Rational(533, 672) + I*3/2, Rational(23, 224) + I/2, Rational(1, 672), Rational(107, 224) - I,
+        Rational(155, 672) + I*3/2, Rational(-103, 224) + I/2, Rational(-377, 672), Rational(-19, 224) - I]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls + [S.Zero]*3
+
+    x, y = symbols('x y')
+
+    raises(TypeError, lambda: fwht(x))
+
+    ls = [x, 2*x, 3*x**2, 4*x**3]
+    ifls = [x**3 + 3*x**2/4 + x*Rational(3, 4),
+        -x**3 + 3*x**2/4 - x/4,
+        -x**3 - 3*x**2/4 + x*Rational(3, 4),
+        x**3 - 3*x**2/4 - x/4]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls
+
+    ls = [x, y, x**2, y**2, x*y]
+    fls = [x**2 + x*y + x + y**2 + y,
+        x**2 + x*y + x - y**2 - y,
+        -x**2 + x*y + x - y**2 + y,
+        -x**2 + x*y + x + y**2 - y,
+        x**2 - x*y + x + y**2 + y,
+        x**2 - x*y + x - y**2 - y,
+        -x**2 - x*y + x - y**2 + y,
+        -x**2 - x*y + x + y**2 - y]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*3
+
+    ls = list(range(6))
+
+    assert fwht(ls) == [x*8 for x in ifwht(ls)]
+
+
+def test_mobius_transform():
+    assert all(tf(ls, subset=subset) == ls
+                for ls in ([], [Rational(7, 4)]) for subset in (True, False)
+                for tf in (mobius_transform, inverse_mobius_transform))
+
+    w, x, y, z = symbols('w x y z')
+
+    assert mobius_transform([x, y]) == [x, x + y]
+    assert inverse_mobius_transform([x, x + y]) == [x, y]
+    assert mobius_transform([x, y], subset=False) == [x + y, y]
+    assert inverse_mobius_transform([x + y, y], subset=False) == [x, y]
+
+    assert mobius_transform([w, x, y, z]) == [w, w + x, w + y, w + x + y + z]
+    assert inverse_mobius_transform([w, w + x, w + y, w + x + y + z]) == \
+            [w, x, y, z]
+    assert mobius_transform([w, x, y, z], subset=False) == \
+            [w + x + y + z, x + z, y + z, z]
+    assert inverse_mobius_transform([w + x + y + z, x + z, y + z, z], subset=False) == \
+            [w, x, y, z]
+
+    ls = [Rational(2, 3), Rational(6, 7), Rational(5, 8), 9, Rational(5, 3) + 7*I]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168),
+            Rational(7, 3) + 7*I, Rational(67, 21) + 7*I, Rational(71, 24) + 7*I,
+            Rational(2153, 168) + 7*I]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls + [S.Zero]*3
+
+    mls = [Rational(2153, 168) + 7*I, Rational(69, 7), Rational(77, 8), 9, Rational(5, 3) + 7*I, 0, 0, 0]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls + [S.Zero]*3
+
+    ls = ls[:-1]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168)]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls
+
+    mls = [Rational(1873, 168), Rational(69, 7), Rational(77, 8), 9]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls
+
+    raises(TypeError, lambda: mobius_transform(x, subset=True))
+    raises(TypeError, lambda: inverse_mobius_transform(y, subset=False))

infer_4_30_0/lib/python3.10/site-packages/sympy/discrete/transforms.py

@@ -0,0 +1,425 @@
+"""
+Discrete Fourier Transform, Number Theoretic Transform,
+Walsh Hadamard Transform, Mobius Transform
+"""
+
+from sympy.core import S, Symbol, sympify
+from sympy.core.function import expand_mul
+from sympy.core.numbers import pi, I
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.ntheory import isprime, primitive_root
+from sympy.utilities.iterables import ibin, iterable
+from sympy.utilities.misc import as_int
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Discrete Fourier Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _fourier_transform(seq, dps, inverse=False):
+    """Utility function for the Discrete Fourier Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of numeric coefficients "
+                        "for Fourier Transform")
+
+    a = [sympify(arg) for arg in seq]
+    if any(x.has(Symbol) for x in a):
+        raise ValueError("Expected non-symbolic coefficients")
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1): # not a power of 2
+        b += 1
+        n = 2**b
+
+    a += [S.Zero]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    ang = -2*pi/n if inverse else 2*pi/n
+
+    if dps is not None:
+        ang = ang.evalf(dps + 2)
+
+    w = [cos(ang*i) + I*sin(ang*i) for i in range(n // 2)]
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], expand_mul(a[i + j + hf]*w[ut * j])
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [(x/n).evalf(dps) for x in a] if dps is not None \
+                            else [x/n for x in a]
+
+    return a
+
+
+def fft(seq, dps=None):
+    r"""
+    Performs the Discrete Fourier Transform (**DFT**) in the complex domain.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FFT* requires the number of sample points to be a power of 2.
+
+    This method should be used with default arguments only for short sequences
+    as the complexity of expressions increases with the size of the sequence.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import fft, ifft
+
+    >>> fft([1, 2, 3, 4])
+    [10, -2 - 2*I, -2, -2 + 2*I]
+    >>> ifft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 2, 3, 4])
+    [5/2, -1/2 + I/2, -1/2, -1/2 - I/2]
+    >>> fft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 7, 3, 4], dps=15)
+    [3.75, -0.5 - 0.75*I, -1.75, -0.5 + 0.75*I]
+    >>> fft(_)
+    [1.0, 7.0, 3.0, 4.0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
+    .. [2] https://mathworld.wolfram.com/FastFourierTransform.html
+
+    """
+
+    return _fourier_transform(seq, dps=dps)
+
+
+def ifft(seq, dps=None):
+    return _fourier_transform(seq, dps=dps, inverse=True)
+
+ifft.__doc__ = fft.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Number Theoretic Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _number_theoretic_transform(seq, prime, inverse=False):
+    """Utility function for the Number Theoretic Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of integer coefficients "
+                        "for Number Theoretic Transform")
+
+    p = as_int(prime)
+    if not isprime(p):
+        raise ValueError("Expected prime modulus for "
+                        "Number Theoretic Transform")
+
+    a = [as_int(x) % p for x in seq]
+
+    n = len(a)
+    if n < 1:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1):
+        b += 1
+        n = 2**b
+
+    if (p - 1) % n:
+        raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
+
+    a += [0]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    pr = primitive_root(p)
+
+    rt = pow(pr, (p - 1) // n, p)
+    if inverse:
+        rt = pow(rt, p - 2, p)
+
+    w = [1]*(n // 2)
+    for i in range(1, n // 2):
+        w[i] = w[i - 1]*rt % p
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]*w[ut * j]
+                a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
+        h *= 2
+
+    if inverse:
+        rv = pow(n, p - 2, p)
+        a = [x*rv % p for x in a]
+
+    return a
+
+
+def ntt(seq, prime):
+    r"""
+    Performs the Number Theoretic Transform (**NTT**), which specializes the
+    Discrete Fourier Transform (**DFT**) over quotient ring `Z/pZ` for prime
+    `p` instead of complex numbers `C`.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 NTT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy import ntt, intt
+    >>> ntt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [10, 643, 767, 122]
+    >>> intt(_, 3*2**8 + 1)
+    [1, 2, 3, 4]
+    >>> intt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [387, 415, 384, 353]
+    >>> ntt(_, prime=3*2**8 + 1)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] http://www.apfloat.org/ntt.html
+    .. [2] https://mathworld.wolfram.com/NumberTheoreticTransform.html
+    .. [3] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    return _number_theoretic_transform(seq, prime=prime)
+
+
+def intt(seq, prime):
+    return _number_theoretic_transform(seq, prime=prime, inverse=True)
+
+intt.__doc__ = ntt.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                          Walsh Hadamard Transform                          #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _walsh_hadamard_transform(seq, inverse=False):
+    """Utility function for the Walsh Hadamard Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients "
+                        "for Walsh Hadamard Transform")
+
+    a = [sympify(arg) for arg in seq]
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+    h = 2
+    while h <= n:
+        hf = h // 2
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [x/n for x in a]
+
+    return a
+
+
+def fwht(seq):
+    r"""
+    Performs the Walsh Hadamard Transform (**WHT**), and uses Hadamard
+    ordering for the sequence.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which WHT is to be applied.
+
+    Examples
+    ========
+
+    >>> from sympy import fwht, ifwht
+    >>> fwht([4, 2, 2, 0, 0, 2, -2, 0])
+    [8, 0, 8, 0, 8, 8, 0, 0]
+    >>> ifwht(_)
+    [4, 2, 2, 0, 0, 2, -2, 0]
+
+    >>> ifwht([19, -1, 11, -9, -7, 13, -15, 5])
+    [2, 0, 4, 0, 3, 10, 0, 0]
+    >>> fwht(_)
+    [19, -1, 11, -9, -7, 13, -15, 5]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hadamard_transform
+    .. [2] https://en.wikipedia.org/wiki/Fast_Walsh%E2%80%93Hadamard_transform
+
+    """
+
+    return _walsh_hadamard_transform(seq)
+
+
+def ifwht(seq):
+    return _walsh_hadamard_transform(seq, inverse=True)
+
+ifwht.__doc__ = fwht.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                    Mobius Transform for Subset Lattice                     #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _mobius_transform(seq, sgn, subset):
+    r"""Utility function for performing Mobius Transform using
+    Yate's Dynamic Programming method"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients")
+
+    a = [sympify(arg) for arg in seq]
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+
+    if subset:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    else:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    continue
+                a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    return a
+
+
+def mobius_transform(seq, subset=True):
+    r"""
+    Performs the Mobius Transform for subset lattice with indices of
+    sequence as bitmasks.
+
+    The indices of each argument, considered as bit strings, correspond
+    to subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset/superset based on bitmasks (indices) requires
+    the size of sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which Mobius Transform is to be applied.
+    subset : bool
+        Specifies if Mobius Transform is applied by enumerating subsets
+        or supersets of the given set.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy import mobius_transform, inverse_mobius_transform
+    >>> x, y, z = symbols('x y z')
+
+    >>> mobius_transform([x, y, z])
+    [x, x + y, x + z, x + y + z]
+    >>> inverse_mobius_transform(_)
+    [x, y, z, 0]
+
+    >>> mobius_transform([x, y, z], subset=False)
+    [x + y + z, y, z, 0]
+    >>> inverse_mobius_transform(_, subset=False)
+    [x, y, z, 0]
+
+    >>> mobius_transform([1, 2, 3, 4])
+    [1, 3, 4, 10]
+    >>> inverse_mobius_transform(_)
+    [1, 2, 3, 4]
+    >>> mobius_transform([1, 2, 3, 4], subset=False)
+    [10, 6, 7, 4]
+    >>> inverse_mobius_transform(_, subset=False)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_inversion_formula
+    .. [2] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+    .. [3] https://arxiv.org/pdf/1211.0189.pdf
+
+    """
+
+    return _mobius_transform(seq, sgn=+1, subset=subset)
+
+def inverse_mobius_transform(seq, subset=True):
+    return _mobius_transform(seq, sgn=-1, subset=subset)
+
+inverse_mobius_transform.__doc__ = mobius_transform.__doc__

infer_4_30_0/lib/python3.10/site-packages/sympy/multipledispatch/__init__.py

@@ -0,0 +1,11 @@
+from .core import dispatch
+from .dispatcher import (Dispatcher, halt_ordering, restart_ordering,
+    MDNotImplementedError)
+
+__version__ = '0.4.9'
+
+__all__ = [
+    'dispatch',
+
+    'Dispatcher', 'halt_ordering', 'restart_ordering', 'MDNotImplementedError',
+]